Añade plugin Redmine Git Hosting 4.0.2

plugins/redmine_git_hosting/app/use_cases/gitolite_public_keys/generate_identifier.rb

@@ -0,0 +1,72 @@
+module GitolitePublicKeys
+  class GenerateIdentifier
+
+    DEPLOY_PSEUDO_USER = 'deploy_key'
+
+    attr_reader :public_key
+    attr_reader :user
+    attr_reader :skip_auto_increment
+
+
+    def initialize(public_key, user, opts = {})
+      @public_key          = public_key
+      @user                = user
+      @skip_auto_increment = opts.delete(:skip_auto_increment) { false }
+    end
+
+
+    class << self
+
+      def call(public_key, user, opts = {})
+        new(public_key, user, opts).call
+      end
+
+    end
+
+
+    # Returns the unique identifier for this key based on the key_type
+    #
+    # For user public keys, this simply is the user's gitolite_identifier.
+    # For deployment keys, we use an incrementing number.
+    #
+    def call
+      if public_key.user_key?
+        set_identifier_for_user_key
+      elsif public_key.deploy_key?
+        set_identifier_for_deploy_key
+      end
+    end
+
+
+    private
+
+
+      def set_identifier_for_user_key
+        tag = public_key.title.gsub(/[^0-9a-zA-Z]/, '_')
+        [user.gitolite_identifier, '@', 'redmine_', tag].join
+      end
+
+
+      # Fix https://github.com/jbox-web/redmine_git_hosting/issues/288
+      # Getting user deployment keys count is not sufficient to assure uniqueness of
+      # deployment key identifier. So we need an 'external' counter to increment the global count
+      # while a key with this identifier exists.
+      #
+      def set_identifier_for_deploy_key
+        count = 0
+        begin
+          key_id = generate_deploy_key_identifier(count)
+          count += 1
+        end while user.gitolite_public_keys.deploy_key.map(&:owner).include?(key_id.split('@')[0])
+        key_id
+      end
+
+
+      def generate_deploy_key_identifier(count)
+        key_count = 1 + count
+        key_count += user.gitolite_public_keys.deploy_key.length unless skip_auto_increment
+        [user.gitolite_identifier, '_', DEPLOY_PSEUDO_USER, '_', key_count, '@', 'redmine_', DEPLOY_PSEUDO_USER, '_', key_count].join
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/projects/base.rb

@@ -0,0 +1,30 @@
+module Projects
+  class Base
+
+    include RedmineGitHosting::GitoliteAccessor::Methods
+
+    attr_reader :project
+    attr_reader :options
+
+
+    def initialize(project, opts = {})
+      @project = project
+      @options = opts
+    end
+
+
+    class << self
+
+      def call(project, opts = {})
+        new(project, opts).call
+      end
+
+    end
+
+
+    def call
+      raise NotImplementedError
+    end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/projects/create_repository.rb

@@ -0,0 +1,32 @@
+module Projects
+  class CreateRepository < Base
+
+    def call
+      create_project_repository
+    end
+
+
+    private
+
+
+      def create_project_repository
+        # Create new repository
+        repository = Repository.factory('Xitolite')
+        repository.is_default = true
+        repository.extra_info = {}
+        repository.extra_info['extra_report_last_commit'] = '1'
+
+        # Save it to database
+        project.repositories << repository
+
+        # Create it in Gitolite
+        Repositories::Create.call(repository, creation_options)
+      end
+
+
+      def creation_options
+        { create_readme_file: RedmineGitHosting::Config.init_repositories_on_create? }
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/projects/execute_hooks.rb

@@ -0,0 +1,38 @@
+module Projects
+  class ExecuteHooks
+
+    attr_reader :project
+    attr_reader :hook_type
+    attr_reader :params
+
+
+    def initialize(project, hook_type, params = {})
+      @project    = project
+      @hook_type  = hook_type
+      @params     = params
+    end
+
+
+    class << self
+
+      def call(project, hook_type, params = {})
+        new(project, hook_type, params).call
+      end
+
+    end
+
+
+    def call
+      self.send("execute_#{hook_type}_hook")
+    end
+
+
+    private
+
+
+      def execute_github_hook
+        RedmineHooks::GithubIssuesSync.call(project, params)
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/projects/update.rb

@@ -0,0 +1,29 @@
+module Projects
+  class Update < Base
+
+    def call
+      # Adjust daemon status
+      disable_git_daemon_if_not_public
+      resync
+    end
+
+
+    private
+
+
+      def disable_git_daemon_if_not_public
+        # Go through all gitolite repos and disable Git daemon if necessary
+        project.gitolite_repos.each do |repository|
+          repository.extra[:git_daemon] = false if repository.git_daemon_enabled? && !project.is_public
+          # Save GitExtra in all cases to trigger urls order consistency checks
+          repository.extra.save
+        end
+      end
+
+
+      def resync
+        gitolite_accessor.update_projects([project.id], options)
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repositories/base.rb

@@ -0,0 +1,40 @@
+module Repositories
+  class Base
+
+    include RedmineGitHosting::GitoliteAccessor::Methods
+
+    attr_reader :repository
+    attr_reader :options
+    attr_reader :project
+
+
+    def initialize(repository, opts = {})
+      @repository = repository
+      @options    = opts
+      @project    = repository.project
+    end
+
+
+    class << self
+
+      def call(repository, opts = {})
+        new(repository, opts).call
+      end
+
+    end
+
+
+    def call
+      raise NotImplementedError
+    end
+
+
+    private
+
+
+      def logger
+        RedmineGitHosting.logger
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repositories/build_payload.rb

@@ -0,0 +1,91 @@
+module Repositories
+  class BuildPayload < Base
+
+    def initialize(*args)
+      super
+      @payloads = []
+    end
+
+
+    def call
+      build_payloads
+    end
+
+
+    def refs
+      options
+    end
+
+
+    private
+
+
+      # Returns an array of GitHub post-receive hook style hashes
+      # http://help.github.com/post-receive-hooks/
+      #
+      def build_payloads
+        refs.each do |ref|
+          # Get revisions range
+          range = get_revisions_from_ref(ref)
+          next if range.nil?
+          @payloads << build_payload(ref, range)
+        end
+        @payloads
+      end
+
+
+      def get_revisions_from_ref(ref)
+        oldhead, newhead, refname = ref.split(',')
+
+        # Only pay attention to branch updates
+        return nil if !refname.match(/refs\/heads\//)
+
+        # Get branch name
+        branch_name = refname.gsub('refs/heads/', '')
+
+        if newhead.match(/\A0{40}\z/)
+          # Deleting a branch
+          logger.info("Deleting branch '#{branch_name}'")
+          range = nil
+        elsif oldhead.match(/\A0{40}\z/)
+          # Creating a branch
+          logger.info("Creating branch '#{branch_name}'")
+          range = newhead
+        else
+          range = "#{oldhead}..#{newhead}"
+        end
+
+        range
+      end
+
+
+      def build_payload(ref, range)
+        revisions_in_range = get_revisions_in_range(range)
+        logger.debug("Revisions in range : #{revisions_in_range.join(' ')}")
+
+        # Get refs
+        oldhead, newhead, refname = ref.split(',')
+
+        # Build payload hash
+        repository.github_payload
+                  .merge({ before: oldhead, after: newhead, ref: refname, commits: build_commits_list(revisions_in_range) })
+      end
+
+
+      def build_commits_list(revisions_in_range)
+        commits_list = []
+        revisions_in_range.each do |rev|
+          changeset = repository.find_changeset_by_name(rev)
+          next if changeset.nil?
+          commits_list << changeset.github_payload
+        end
+        commits_list
+      end
+
+
+      def get_revisions_in_range(range)
+        repository.rev_list(range, ['--reverse'])
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repositories/create.rb

@@ -0,0 +1,71 @@
+module Repositories
+  class Create < Base
+
+    def call
+      set_repository_extra
+      create_repository
+    end
+
+
+    private
+
+
+      def set_repository_extra
+        extra = repository.build_extra(default_extra_options)
+        extra.save!
+      end
+
+
+      def default_extra_options
+        enable_git_annex? ? git_annex_repository_options : standard_repository_options
+      end
+
+
+      def enable_git_annex?
+        options[:enable_git_annex]
+      end
+
+
+      def standard_repository_options
+        {
+          git_daemon:     RedmineGitHosting::Config.gitolite_daemon_by_default?,
+          git_notify:     RedmineGitHosting::Config.gitolite_notify_by_default?,
+          git_annex:      false,
+          default_branch: 'master',
+          key:            RedmineGitHosting::Utils::Crypto.generate_secret(64)
+        }.merge(smart_http_options)
+      end
+
+
+      def smart_http_options
+        case RedmineGitHosting::Config.gitolite_http_by_default?
+        when '1' # HTTPS only
+          { git_https: true }
+        when '2' # HTTPS and HTTP
+          { git_http: true, git_https: true }
+        when '3' # HTTP only
+          { git_http: true }
+        else
+          {}
+        end
+      end
+
+
+      def git_annex_repository_options
+        {
+          git_http:       0,
+          git_daemon:     false,
+          git_notify:     false,
+          git_annex:      true,
+          default_branch: 'git-annex',
+          key:            RedmineGitHosting::Utils::Crypto.generate_secret(64)
+        }
+      end
+
+
+      def create_repository
+        gitolite_accessor.create_repository(repository, options)
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repositories/download_revision.rb

@@ -0,0 +1,93 @@
+module Repositories
+  class DownloadRevision
+
+    attr_reader :repository
+    attr_reader :revision
+    attr_reader :format
+    attr_reader :gitolite_repository_path
+
+    attr_reader :commit_id
+    attr_reader :content_type
+    attr_reader :filename
+
+
+    def initialize(repository, revision, format)
+      @repository = repository
+      @revision   = revision
+      @format     = format
+      @gitolite_repository_path = repository.gitolite_repository_path
+
+      @valid_commit  = false
+      @commit_id     = nil
+      @content_type  = ''
+      @filename      = ''
+
+      validate_revision
+      fill_data
+    end
+
+
+    def content
+      repository.archive(commit_id, format)
+    end
+
+
+    def valid_commit?
+      @valid_commit
+    end
+
+
+    private
+
+
+      def validate_revision
+        commit = nil
+
+        # is the revision a branch?
+        repository.branches.each do |x|
+          if x.to_s == revision
+            commit = x.revision
+            break
+          end
+        end
+
+        # is the revision a tag?
+        if commit.nil?
+          repository.tags.each do |x|
+            if x == revision
+              commit = repository.rev_list(revision).first
+              break
+            end
+          end
+        end
+
+        # well, let check if this is a valid commit
+        commit = revision if commit.nil?
+        commit = repository.rev_parse(commit)
+
+        if commit == ''
+          @valid_commit = false
+        else
+          @valid_commit = true
+          @commit_id = commit
+        end
+      end
+
+
+      def fill_data
+        case format
+        when 'tar.gz' then
+          extension     = 'tar.gz'
+          @content_type = 'application/x-gzip'
+        when 'zip' then
+          extension     = 'zip'
+          @content_type = 'application/x-zip'
+        else
+          extension     = 'tar'
+          @content_type = 'application/x-tar'
+        end
+        @filename = "#{repository.redmine_name}-#{revision}.#{extension}"
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repositories/execute_hooks.rb

@@ -0,0 +1,79 @@
+module Repositories
+  class ExecuteHooks
+
+    attr_reader :repository
+    attr_reader :hook_type
+    attr_reader :payloads
+
+
+    def initialize(repository, hook_type, payloads = {})
+      @repository = repository
+      @hook_type  = hook_type
+      @payloads   = payloads
+    end
+
+
+    class << self
+
+      def call(repository, hook_type, payloads = {})
+        new(repository, hook_type, payloads).call
+      end
+
+    end
+
+
+    def call
+      self.send("execute_#{hook_type}_hook")
+    end
+
+
+    private
+
+
+      def logger
+        RedmineGitHosting.logger
+      end
+
+
+      def execute_fetch_changesets_hook
+        RedmineHooks::FetchChangesets.call(repository)
+      end
+
+
+      def execute_update_mirrors_hook
+        message = 'Notifying mirrors about changes to this repository :'
+        y = ''
+
+        ## Post to each post-receive URL
+        if repository.mirrors.active.any?
+          logger.info(message)
+          y << "\n#{message}\n"
+
+          repository.mirrors.active.each do |mirror|
+            y << RedmineHooks::UpdateMirrors.call(mirror, payloads)
+          end
+        end
+
+        y
+      end
+
+
+      def execute_call_webservices_hook
+        message = 'Notifying post receive urls about changes to this repository :'
+        y = ''
+
+        ## Post to each post-receive URL
+        if repository.post_receive_urls.active.any?
+          logger.info(message)
+          y << "\n#{message}\n"
+
+          repository.post_receive_urls.active.each do |post_receive_url|
+            y << RedmineHooks::CallWebservices.call(post_receive_url, payloads)
+          end
+        end
+
+        y
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repository_mirrors/base.rb

@@ -0,0 +1,28 @@
+module RepositoryMirrors
+  class Base
+
+    attr_reader :mirror
+    attr_reader :repository
+
+
+    def initialize(mirror)
+      @mirror     = mirror
+      @repository = mirror.repository
+    end
+
+
+    class << self
+
+      def call(mirror)
+        new(mirror).call
+      end
+
+    end
+
+
+    def call
+      raise NotImplementedError
+    end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repository_mirrors/push.rb

@@ -0,0 +1,55 @@
+module RepositoryMirrors
+  class Push < Base
+
+    def call
+      push!
+    end
+
+
+    def push!
+      begin
+        push_message = repository.mirror_push(*command)
+        push_failed = false
+      rescue RedmineGitHosting::Error::GitoliteCommandException => e
+        push_message = e.output
+        push_failed = true
+      end
+
+      return push_failed, push_message
+    end
+
+
+    def command
+      [mirror.url, branch, push_args]
+    end
+
+
+    private
+
+
+      def push_args
+        mirror.mirror_mode? ? ['--mirror'] : mirror_args
+      end
+
+
+      def mirror_args
+        push_args = []
+        push_args << '--force' if mirror.force_mode?
+        push_args << '--all'   if mirror.include_all_branches?
+        push_args << '--tags'  if mirror.include_all_tags?
+        push_args
+      end
+
+
+      def branch
+        "#{dequote(mirror.explicit_refspec)}" unless mirror.explicit_refspec.blank?
+      end
+
+
+      # Put backquote in front of crucial characters
+      def dequote(in_string)
+        in_string.gsub(/[$,"\\\n]/) { |x| "\\" + x }
+      end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/repository_protected_branches/member_manager.rb

@@ -0,0 +1,91 @@
+module RepositoryProtectedBranches
+  class MemberManager
+
+    attr_reader :protected_branch
+
+
+    def initialize(protected_branch)
+      @protected_branch = protected_branch
+    end
+
+
+    def current_user_ids
+      protected_branch.users.map(&:id)
+    end
+
+
+    def current_group_ids
+      protected_branch.groups.map(&:id)
+    end
+
+
+    def current_members
+      protected_branch.protected_branches_members
+    end
+
+
+    def users_by_group_id(id)
+      current_members.select { |pbm| pbm.principal.class.name == 'User' && pbm.inherited_by == id }.map(&:principal)
+    end
+
+
+    def add_users(ids)
+      create_user_member(ids, current_user_ids)
+    end
+
+
+    def add_groups(ids)
+      create_group_member(ids, current_group_ids) do |group|
+        ids = group.users.map(&:id)
+        current_ids = users_by_group_id(group.id).map(&:id)
+        create_user_member(ids, current_ids, inherited_by: group.id, destroy: false)
+      end
+    end
+
+
+    def create_user_member(ids, current_ids, opts = {}, &block)
+      create_member(ids, current_ids, 'User', opts, &block)
+    end
+
+
+    def create_group_member(ids, current_ids, opts = {}, &block)
+      create_member(ids, current_ids, 'Group', opts, &block)
+    end
+
+
+    def add_user_from_group(user, group_id)
+      ids = users_by_group_id(group_id).push(user).map(&:id)
+      current_ids = users_by_group_id(group_id).map(&:id)
+      create_user_member(ids, current_ids, inherited_by: group_id, destroy: false)
+    end
+
+
+    def remove_user_from_group(user, group_id)
+      return unless users_by_group_id(group_id).include?(user)
+      member = current_members.find_by_protected_branch_id_and_principal_id_and_inherited_by(protected_branch.id, user.id, group_id)
+      member.destroy! unless member.nil?
+    end
+
+
+    def create_member(ids, current_ids, klass, opts = {}, &block)
+      destroy      = opts.fetch(:destroy, true)
+      inherited_by = opts.fetch(:inherited_by, nil)
+
+      ids = (ids || []).collect(&:to_i) - [0]
+      new_ids = ids - current_ids
+
+      new_ids.each do |id|
+        object = klass.constantize.find_by_id(id)
+        next if object.nil?
+        current_members.create(principal_id: object.id, inherited_by: inherited_by)
+        yield object if block_given?
+      end
+
+      if destroy
+        member_to_destroy = current_members.select { |m| m.principal.class.name == klass && !ids.include?(m.principal.id) }
+        member_to_destroy.each(&:destroy) if member_to_destroy.any?
+      end
+    end
+
+  end
+end

plugins/redmine_git_hosting/app/use_cases/settings/apply.rb

@@ -0,0 +1,154 @@
+module Settings
+  class Apply
+    include RedmineGitHosting::GitoliteAccessor::Methods
+
+    attr_reader :previous_settings
+    attr_reader :resync_projects
+    attr_reader :resync_ssh_keys
+    attr_reader :regenerate_ssh_keys
+    attr_reader :flush_cache
+    attr_reader :delete_trash_repo
+
+    def initialize(previous_settings, opts = {})
+      @previous_settings   = previous_settings
+      @resync_projects     = opts.delete(:resync_all_projects) { false }
+      @resync_ssh_keys     = opts.delete(:resync_all_ssh_keys) { false }
+      @regenerate_ssh_keys = opts.delete(:regenerate_all_ssh_keys) { false }
+      @flush_cache         = opts.delete(:flush_gitolite_cache) { false }
+      @delete_trash_repo   = opts.delete(:delete_trash_repo) { [] }
+    end
+
+    class << self
+      def call(previous_settings, opts = {})
+        new(previous_settings, opts).call
+      end
+    end
+
+    def call
+      gitolite_accessor.flush_settings_cache
+      apply_settings
+    end
+
+    private
+
+    def apply_settings
+      check_gitolite_location
+      check_repo_hierarchy
+      check_gitolite_config
+      check_gitolite_default_values
+      check_hook_config
+      check_cache_config
+
+      do_resync_projects
+      do_resync_ssh_keys
+      do_regenerate_ssh_keys
+      do_flush_cache
+      do_delete_trash_repo
+      do_add_redmine_rw_access
+    end
+
+    def current_setting(setting)
+      Setting.plugin_redmine_git_hosting[setting]
+    end
+
+    def value_has_changed?(setting)
+      previous_settings[setting] != current_setting(setting)
+    end
+
+    def check_gitolite_location
+      ## Gitolite location has changed. Remove temp directory, it will be recloned.
+      if value_has_changed?(:gitolite_server_host) ||
+         value_has_changed?(:gitolite_server_port) ||
+         value_has_changed?(:gitolite_user)        ||
+         value_has_changed?(:gitolite_temp_dir)
+
+        RedmineGitHosting.logger.info("Temp dir has changed, remove the previous one : '#{previous_settings[:gitolite_temp_dir]}'")
+        FileUtils.rm_rf previous_settings[:gitolite_temp_dir]
+      end
+    end
+
+    def check_repo_hierarchy
+      ## Storage infos has changed, move repositories!
+      if value_has_changed?(:gitolite_global_storage_dir)  ||
+         value_has_changed?(:gitolite_redmine_storage_dir) ||
+         value_has_changed?(:hierarchical_organisation)
+
+        # Need to update everyone!
+        # We take all root projects (even those who are closed) and move each hierarchy individually
+        count = Project.includes(:repositories).all.select { |x| x if x.parent_id.nil? }.length
+        gitolite_accessor.move_repositories_tree(count) if count.positive?
+      end
+    end
+
+    def check_gitolite_config
+      ## Gitolite config file has changed, create a new one!
+      if value_has_changed?(:gitolite_config_file)       ||
+         value_has_changed?(:gitolite_identifier_prefix) ||
+         value_has_changed?(:gitolite_identifier_strip_user_id)
+        options = { message: 'Gitolite configuration has been modified, resync all projects (active, closed, archived)...' }
+        gitolite_accessor.update_projects('all', options)
+      end
+    end
+
+    def check_gitolite_default_values
+      ## Gitolite default values has changed, update active projects
+      if value_has_changed?(:gitolite_notify_global_prefix)         ||
+         value_has_changed?(:gitolite_notify_global_sender_address) ||
+         value_has_changed?(:gitolite_notify_global_include)        ||
+         value_has_changed?(:gitolite_notify_global_exclude)
+
+        # Need to update everyone!
+        options = { message: 'Gitolite configuration has been modified, resync all active projects...' }
+        gitolite_accessor.update_projects('active', options)
+      end
+    end
+
+    def check_hook_config
+      ## Gitolite hooks config has changed, update our .gitconfig!
+      if value_has_changed?(:gitolite_hooks_debug)        ||
+         value_has_changed?(:gitolite_hooks_url)          ||
+         value_has_changed?(:gitolite_hooks_are_asynchronous)
+
+        # Need to update our .gitconfig
+        RedmineGitHosting::Config.update_hook_params!
+      end
+    end
+
+    def check_cache_config
+      ## Gitolite cache has changed, clear cache entries!
+      RedmineGitHosting::Cache.clear_obsolete_cache_entries if value_has_changed?(:gitolite_cache_max_time)
+    end
+
+    def do_resync_projects
+      ## A resync has been asked within the interface, update all projects in force mode
+      options = { message: 'Forced resync of all projects (active, closed, archived)...', force: true }
+      gitolite_accessor.update_projects('all', options) if resync_projects
+    end
+
+    def do_resync_ssh_keys
+      ## A resync has been asked within the interface, update all projects in force mode
+      gitolite_accessor.resync_ssh_keys if resync_ssh_keys
+    end
+
+    def do_regenerate_ssh_keys
+      gitolite_accessor.regenerate_ssh_keys if regenerate_ssh_keys
+    end
+
+    def do_flush_cache
+      ## A cache flush has been asked within the interface
+      gitolite_accessor.flush_git_cache if flush_cache
+    end
+
+    def do_delete_trash_repo
+      gitolite_accessor.delete_from_recycle_bin(delete_trash_repo) unless delete_trash_repo.empty?
+    end
+
+    def do_add_redmine_rw_access
+      if Additionals.true? current_setting(:redmine_has_rw_access_on_all_repos)
+        gitolite_accessor.enable_rw_access
+      else
+        gitolite_accessor.disable_rw_access
+      end
+    end
+  end
+end