manuelcillero/suitepro
manuelcillero/suitepro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Elimina el plugin Redmine Git Hosting

Browse source 
Finalmente se descarta por los problemas de configuración y potencial
brecha de seguridad al requerir acceso global al puerto ssh.
This commit is contained in:
Manuel Cillero 2020-12-06 11:46:44 +01:00
parent bdd66d941f
commit 0edadcfed8
494 changed files with 0 additions and 36768 deletions
Download patch file Download diff file Expand all files Collapse all files

38
plugins/redmine_git_hosting/app/services/permissions_builder/base.rb
View file

@ -1,38 +0,0 @@
module PermissionsBuilder
class Base
attr_reader :repository
attr_reader :gitolite_users
attr_reader :old_permissions
def initialize(repository, gitolite_users, old_permissions = {})
@repository = repository
@gitolite_users = gitolite_users
@old_permissions = old_permissions
end
class << self
def build(repository, gitolite_users, old_permissions = {})
new(repository, gitolite_users, old_permissions).build
end
end
def build
raise NotImplementedError
end
private
def has_no_users?(type)
gitolite_users[type].nil? || gitolite_users[type].empty?
end
end
end

29
plugins/redmine_git_hosting/app/services/permissions_builder/protected_branches.rb
View file

@ -1,29 +0,0 @@
module PermissionsBuilder
class ProtectedBranches < Base
attr_reader :permissions
def initialize(*args)
super
@permissions = []
end
def build
build_protected_branch_permissions
permissions
end
def build_protected_branch_permissions
repository.protected_branches.each do |branch|
perms = {}
perms[branch.permissions] = {}
perms[branch.permissions][branch.path] = branch.allowed_users unless branch.allowed_users.empty?
permissions.push(perms)
end
end
end
end

71
plugins/redmine_git_hosting/app/services/permissions_builder/standard.rb
View file

@ -1,71 +0,0 @@
module PermissionsBuilder
class Standard < Base
attr_reader :permissions
def initialize(*args)
super
@permissions = {}
@permissions['RW+'] = {}
@permissions['RW'] = {}
@permissions['R'] = {}
end
def build
# Build permissions
build_permissions
# Return them
[merge_permissions(permissions, old_permissions)]
end
private
def build_permissions
@permissions['RW+'][''] = gitolite_users[:rewind_users] unless has_no_users?(:rewind_users)
@permissions['RW'][''] = gitolite_users[:write_users] unless has_no_users?(:write_users)
@permissions['R'][''] = gitolite_users[:read_users] unless has_no_users?(:read_users)
end
def merge_permissions(current_permissions, old_permissions)
merge_permissions = {}
merge_permissions['RW+'] = {}
merge_permissions['RW'] = {}
merge_permissions['R'] = {}
current_permissions.each do |perm, branch_settings|
branch_settings.each do |branch, user_list|
if user_list.any?
if !merge_permissions[perm].has_key?(branch)
merge_permissions[perm][branch] = []
end
merge_permissions[perm][branch] += user_list
end
end
end
old_permissions.each do |perm, branch_settings|
branch_settings.each do |branch, user_list|
if user_list.any?
if !merge_permissions[perm].has_key?(branch)
merge_permissions[perm][branch] = []
end
merge_permissions[perm][branch] += user_list
end
end
end
merge_permissions.each do |perm, branch_settings|
merge_permissions.delete(perm) if merge_permissions[perm].empty?
end
merge_permissions
end
end
end

70
plugins/redmine_git_hosting/app/services/redmine_hooks/base.rb
View file

@ -1,70 +0,0 @@
module RedmineHooks
class Base
attr_reader :object
attr_reader :payloads
def initialize(object, payloads = {})
@object = object
@payloads = payloads
end
class << self
def call(object, payloads = {})
new(object, payloads).call
end
end
def call
raise NotImplementedError
end
def start_message
raise NotImplementedError
end
private
def logger
RedmineGitHosting.logger
end
def success_message
" [success]\n"
end
def failure_message
" [failure]\n"
end
def log_hook_succeeded
logger.info('Succeeded!')
end
def log_hook_failed
logger.error('Failed!')
end
def execute_hook(&block)
y = ''
logger.info(start_message)
y << " - #{start_message} ... "
yield y
y
end
end
end

118
plugins/redmine_git_hosting/app/services/redmine_hooks/call_webservices.rb
View file

@ -1,118 +0,0 @@
module RedmineHooks
class CallWebservices < Base
include HttpHelper
attr_reader :payloads_to_send
def initialize(*args)
super
@payloads_to_send = []
set_payloads_to_send
end
def call
execute_hook do |out|
if needs_push?
out << call_webservice
else
out << "#{skip_message}\n"
logger.info(skip_message)
end
end
end
def post_receive_url
object
end
def needs_push?
return false if payloads.empty?
return true unless use_triggers?
return false if post_receive_url.triggers.empty?
return !payloads_to_send.empty?
end
def start_message
"Notifying #{post_receive_url.url}"
end
def skip_message
"This url doesn't need to be notified"
end
private
def set_payloads_to_send
if use_triggers?
@payloads_to_send = extract_payloads
else
@payloads_to_send = payloads
end
end
def extract_payloads
new_payloads = []
payloads.each do |payload|
data = RedmineGitHosting::Utils::Git.parse_refspec(payload[:ref])
if data[:type] == 'heads' && post_receive_url.triggers.include?(data[:name])
new_payloads << payload
end
end
new_payloads
end
def use_method
post_receive_url.mode == :github ? :http_post : :http_get
end
def use_triggers?
post_receive_url.use_triggers?
end
def split_payloads?
post_receive_url.split_payloads?
end
def call_webservice
if use_method == :http_post && split_payloads?
y = ''
payloads_to_send.each do |payload|
y << do_call_webservice(payload)
end
y
else
do_call_webservice(payloads_to_send)
end
end
def do_call_webservice(payload)
post_failed, post_message = self.send(use_method, post_receive_url.url, { data: { payload: payload } })
if post_failed
logger.error('Failed!')
logger.error(post_message)
(split_payloads? ? failure_message.gsub("\n", '') : failure_message)
else
log_hook_succeeded
(split_payloads? ? success_message.gsub("\n", '') : success_message)
end
end
end
end

38
plugins/redmine_git_hosting/app/services/redmine_hooks/fetch_changesets.rb
View file

@ -1,38 +0,0 @@
module RedmineHooks
class FetchChangesets < Base
def call
repository.empty_cache!
execute_hook do |out|
out << fetch_changesets
end
end
def repository
object
end
def start_message
"Fetching changesets for '#{repository.redmine_name}' repository"
end
private
def fetch_changesets
begin
repository.fetch_changesets
log_hook_succeeded
success_message
rescue ::Redmine::Scm::Adapters::CommandFailed => e
log_hook_failed
logger.error("Error during fetching changesets : #{e.message}")
failure_message
end
end
end
end

152
plugins/redmine_git_hosting/app/services/redmine_hooks/github_issues_sync.rb
View file

@ -1,152 +0,0 @@
require 'json'
module RedmineHooks
class GithubIssuesSync < Base
include HttpHelper
def call
sync_with_github
end
def project
object
end
def params
payloads
end
private
def github_issue
GithubIssue.find_by_github_id(params[:issue][:id])
end
def redmine_issue
Issue.find_by_subject(params[:issue][:title])
end
def sync_with_github
create_relation = false
## We don't have stored relation
if github_issue.nil?
## And we don't have issue in Redmine
if redmine_issue.nil?
create_relation = true
redmine_issue = create_redmine_issue
else
## Create relation and update issue
create_relation = true
redmine_issue = update_redmine_issue(redmine_issue)
end
else
## We have one relation, update issue
redmine_issue = update_redmine_issue(github_issue.issue)
end
if create_relation
github_issue = GithubIssue.new
github_issue.github_id = params[:issue][:id]
github_issue.issue_id = redmine_issue.id
github_issue.save!
end
if params.has_key?(:comment)
issue_journal = GithubComment.find_by_github_id(params[:comment][:id])
if issue_journal.nil?
issue_journal = create_issue_journal(github_issue.issue)
github_comment = GithubComment.new
github_comment.github_id = params[:comment][:id]
github_comment.journal_id = issue_journal.id
github_comment.save!
end
end
end
def create_redmine_issue
logger.info('Github Issues Sync : create new issue')
issue = project.issues.new
issue.tracker_id = project.trackers.first.try(:id)
issue.subject = params[:issue][:title].chomp[0, 255]
issue.description = params[:issue][:body]
issue.updated_on = params[:issue][:updated_at]
issue.created_on = params[:issue][:created_at]
## Get user mail
user = find_user(params[:issue][:user][:url])
issue.author = user
issue.save!
return issue
end
def create_issue_journal(issue)
logger.info("Github Issues Sync : create new journal for issue '##{issue.id}'")
journal = Journal.new
journal.journalized_id = issue.id
journal.journalized_type = 'Issue'
journal.notes = params[:comment][:body]
journal.created_on = params[:comment][:created_at]
## Get user mail
user = find_user(params[:comment][:user][:url])
journal.user_id = user.id
journal.save!
return journal
end
def update_redmine_issue(issue)
logger.info("Github Issues Sync : update issue '##{issue.id}'")
if params[:issue][:state] == 'closed'
issue.status_id = 5
else
issue.status_id = 1
end
issue.subject = params[:issue][:title].chomp[0, 255]
issue.description = params[:issue][:body]
issue.updated_on = params[:issue][:updated_at]
issue.save!
return issue
end
def find_user(url)
post_failed, user_data = http_get(url)
user_data = JSON.parse(user_data)
user = User.find_by_mail(user_data['email'])
if user.nil?
logger.info("Github Issues Sync : cannot find user '#{user_data['email']}' in Redmine, use anonymous")
user = User.anonymous
user.mail = user_data['email']
user.firstname = user_data['name']
user.lastname = user_data['login']
end
return user
end
end
end

14
plugins/redmine_git_hosting/app/services/redmine_hooks/http_helper.rb
View file

@ -1,14 +0,0 @@
module RedmineHooks
module HttpHelper
def http_post(url, opts = {})
RedmineGitHosting::Utils::Http.http_post(url, opts)
end
def http_get(url, opts = {})
RedmineGitHosting::Utils::Http.http_get(url, opts)
end
end
end

71
plugins/redmine_git_hosting/app/services/redmine_hooks/update_mirrors.rb
View file

@ -1,71 +0,0 @@
module RedmineHooks
class UpdateMirrors < Base
def call
execute_hook do |out|
if needs_push?
out << call_mirror
else
out << "#{skip_message}\n"
logger.info(skip_message)
end
end
end
def mirror
object
end
# If we have an explicit refspec, check it against incoming payloads
# Special case: if we do not pass in any payloads, return true
def needs_push?
return true if payloads.empty?
return true if mirror.mirror_mode?
return check_ref_spec
end
def start_message
"Pushing changes to #{mirror.url}"
end
def skip_message
"This mirror doesn't need to be updated"
end
private
def check_ref_spec
refspec_parse = RedmineGitHosting::Validators.valid_git_refspec?(mirror.explicit_refspec)
payloads.each do |payload|
if splitpath = RedmineGitHosting::Utils::Git.parse_refspec(payload[:ref])
return true if payload[:ref] == refspec_parse[1] # Explicit Reference Spec complete path
return true if splitpath[:name] == refspec_parse[1] # Explicit Reference Spec no type
return true if mirror.include_all_branches? && splitpath[:type] == 'heads'
return true if mirror.include_all_tags? && splitpath[:type] == 'tags'
end
end
false
end
def call_mirror
push_failed, push_message = RepositoryMirrors::Push.call(mirror)
if push_failed
log_hook_failed
logger.error(push_message)
failure_message
else
log_hook_succeeded
success_message
end
end
end
end