Better handling of projects with a disabled repository module.

We now treat this case exactly the same as an archived
project/repository.  Before, it was handled inconsistently.  Three
changes:

1) When a repository module is disabled/enabled through settings page
   call update_repositories to update state.  A disabling of the
   repository module will call update_repositories with :archive.

2) Existing repositories will be left alone and marked with a dummy
   redmine key of "redmine_disabled_project".  Reenabling of the
   repository module will restore project and keys to accessibility.

3) When removing redmine keys from a gitolite.conf entry, don't report
   in the log unless removing real readmine keys.  This avoids a weird
   circumstance in which every fetch_changesets operation reports that
   it is deleting redmine keys (caused when repo entry exists but the
   "delete_repositories" flag is disabled at the time that the repo is
   deleted.  This fix is entirely about removing confusing messages
   from the log.

Author: kubitron

Diff for: lib/git_hosting.rb

@@ -662,20 +662,20 @@ def self.update_repositories(*args)
 	args.each {|arg| flags.merge!(arg) if arg.is_a?(Hash)}
 	if flags[:resync_all]
 	    logger.info "Executing RESYNC_ALL operation on gitolite configuration"
-	    projects = Project.active_or_archived.has_module(:repository).find(:all, :include => :repository)
+	    projects = Project.active_or_archived.find(:all, :include => :repository)
 	elsif flags[:delete]
 	    # When delete, want to recompute users, so need to go through all projects
 	    logger.info "Executing DELETE operation (resync keys, remove dead repositories)"
-	    projects = Project.active_or_archived.has_module(:repository).find(:all, :include => :repository)
+	    projects = Project.active_or_archived.find(:all, :include => :repository)
 	elsif flags[:archive]
 	    # When archive, want to recompute users, so need to go through all projects
 	    logger.info "Executing ARCHIVE operation (remove keys)"
-	    projects = Project.active_or_archived.has_module(:repository).find(:all, :include => :repository)
+	    projects = Project.active_or_archived.find(:all, :include => :repository)
 	elsif flags[:descendants]
 	    if Project.method_defined?(:self_and_descendants)
 		projects = (args.flatten.select{|p| p.is_a?(Project)}).collect{|p| p.self_and_descendants}.flatten
 	    else
-		projects = Project.active_or_archived.has_module(:repository).find(:all, :include => :repository)
+		projects = Project.active_or_archived.find(:all, :include => :repository)
 	    end
 	else
 	    projects = args.flatten.select{|p| p.is_a?(Project)}
@@ -719,7 +719,7 @@ def self.update_repositories(*args)
 	    end
 
 	    # Collect relevant users into hash with user as key and activity (in some active project) as value
-	    (git_projects.select{|proj| proj.active?}.map{|proj| proj.member_principals.map(&:user).compact}.flatten.uniq << GitolitePublicKey::DEPLOY_PSEUDO_USER).each do |cur_user|
+	    (git_projects.select{|proj| proj.active? && proj.module_enabled?(:repository)}.map{|proj| proj.member_principals.map(&:user).compact}.flatten.uniq << GitolitePublicKey::DEPLOY_PSEUDO_USER).each do |cur_user|
 		if cur_user == GitolitePublicKey::DEPLOY_PSEUDO_USER
 		    active_keys = DeploymentCredential.active.select(&:honored?).map(&:gitolite_public_key).uniq
 		    cur_token = cur_user
@@ -882,41 +882,47 @@ def self.update_repositories(*args)
 
 		# If this is an active (non-archived) project, then update gitolite entry.  Add GIT_DAEMON_KEY.
 		if proj.active?
-		    # Get deployment keys (could be empty)
-		    write_user_keys = myrepo.deployment_credentials.active.select{|cred| cred.honored? && cred.allowed_to?(:commit_access)}.map{|x| x.gitolite_public_key.identifier}
-		    read_user_keys = myrepo.deployment_credentials.active.select{|cred| cred.honored? && cred.allowed_to?(:view_changesets) && !cred.allowed_to?(:commit_access)}.map{|x| x.gitolite_public_key.identifier}
-
-		    # fetch users
-		    users = proj.member_principals.map(&:user).compact.uniq
-		    write_users = users.select{ |user| user.allowed_to?( :commit_access, proj ) }
-		    read_users = users.select{ |user| user.allowed_to?( :view_changesets, proj ) && !user.allowed_to?( :commit_access, proj ) }
-
-		    read_users.map{|u| u.gitolite_public_keys.active.user_key}.flatten.compact.uniq.each do |key|
-			read_user_keys.push key.identifier
-		    end
-		    write_users.map{|u| u.gitolite_public_keys.active.user_key}.flatten.compact.uniq.each do |key|
-			write_user_keys.push key.identifier
-		    end
-
-		    #git daemon support
-		    if (proj.repository.extra.git_daemon == 1 || proj.repository.extra.git_daemon == nil )	&& proj.is_public
-			read_user_keys.push GitoliteConfig::GIT_DAEMON_KEY
-		    end
+		    if proj.module_enabled?(:repository)
+			# Get deployment keys (could be empty)
+			write_user_keys = myrepo.deployment_credentials.active.select{|cred| cred.honored? && cred.allowed_to?(:commit_access)}.map{|x| x.gitolite_public_key.identifier}
+			read_user_keys = myrepo.deployment_credentials.active.select{|cred| cred.honored? && cred.allowed_to?(:view_changesets) && !cred.allowed_to?(:commit_access)}.map{|x| x.gitolite_public_key.identifier}
+
+			# fetch users
+			users = proj.member_principals.map(&:user).compact.uniq
+			write_users = users.select{ |user| user.allowed_to?( :commit_access, proj ) }
+			read_users = users.select{ |user| user.allowed_to?( :view_changesets, proj ) && !user.allowed_to?( :commit_access, proj ) }
+
+			read_users.map{|u| u.gitolite_public_keys.active.user_key}.flatten.compact.uniq.each do |key|
+			    read_user_keys.push key.identifier
+			end
+			write_users.map{|u| u.gitolite_public_keys.active.user_key}.flatten.compact.uniq.each do |key|
+			    write_user_keys.push key.identifier
+			end
 
-		    # Remove previous redmine keys, then add new keys
-		    # By doing things this way, we leave non-redmine keys alone
-		    # Note -- delete_redmine_keys() will also remove the GIT_DAEMON_KEY for repos with redmine keys
-		    # (to be put back as above, when appropriate).
-		    conf.delete_redmine_keys repo_name
-		    conf.add_read_user repo_name, read_user_keys.uniq
-		    conf.add_write_user repo_name, write_user_keys.uniq
+			#git daemon support
+			if (proj.repository.extra.git_daemon == 1 || proj.repository.extra.git_daemon == nil )	&& proj.is_public
+			    read_user_keys.push GitoliteConfig::GIT_DAEMON_KEY
+			end
 
-		    # If no redmine keys, mark with dummy key
-		    if (read_user_keys+write_user_keys).empty?
-			conf.mark_with_dummy_key repo_name
+			# Remove previous redmine keys, then add new keys
+			# By doing things this way, we leave non-redmine keys alone
+			# Note -- delete_redmine_keys() will also remove the GIT_DAEMON_KEY for repos with redmine keys
+			# (to be put back as above, when appropriate).
+			conf.delete_redmine_keys repo_name
+			conf.add_read_user repo_name, read_user_keys.uniq
+			conf.add_write_user repo_name, write_user_keys.uniq
+
+			# If no redmine keys, mark with dummy key
+			if (read_user_keys+write_user_keys).empty?
+			    conf.mark_with_dummy_key repo_name
+			end
+		    else
+			# Must be a project that has repositories disabled. Mark as disabled project.
+			conf.delete_redmine_keys repo_name
+			conf.mark_disabled repo_name
 		    end
 		else
-		    # Must be an archived project! Clear out redmine keys.	Mark as an archived project.
+		    # Must be an archived project! Clear out redmine keys.  Mark as an archived project.
 		    conf.delete_redmine_keys repo_name
 		    conf.mark_archived repo_name
 		end
@@ -938,20 +944,23 @@ def self.update_repositories(*args)
 		    redmine_repos.delete_if{|basename,values| proj_ids.index(basename)}
 		end
 		redmine_repos.values.flatten.each do |repo_name|
-		    # First, delete redmine keys for this repository
+		    # First, check if there are any redmine keys other than the DUMMY or ARCHIVED key
+		    has_keys = conf.has_actual_redmine_keys? repo_name
+
+		    # Next, delete redmine keys for this repository
 		    conf.delete_redmine_keys repo_name
 		    if (Setting.plugin_redmine_git_hosting['deleteGitRepositories'] == "true")
 			if conf.repo_has_no_keys? repo_name
 			    logger.warn "Deleting #{orphanString}entry '#{repo_name}' from #{gitolite_conf}"
 			    conf.delete_repo repo_name
 			    GitoliteRecycle.move_repository_to_recycle repo_name
-			else
+			elsif has_keys # Something changed when we deleted keys
 			    logger.info "Deleting redmine keys from #{orphanString}entry '#{repo_name}' in #{gitolite_conf}"
 			    if git_repository_exists? repo_name
 				logger.info "  Not removing #{repo_name}.git from gitolite repository, because non-redmine keys remain."
 			    end
 			end
-		    else
+		    elsif has_keys # Something changed when we deleted keys
 			logger.info "Deleting redmine keys from #{orphanString}entry '#{repo_name}' in #{gitolite_conf}"
 		    end
 		end

Diff for: lib/git_hosting/patches/projects_controller_patch.rb

@@ -108,6 +108,21 @@ def unarchive_with_disable_update
 		GitHostingObserver.set_update_active(@project);
 	    end
 
+	    def settings_with_disable_update
+		# Turn of updates during repository update
+		GitHostingObserver.set_update_active(false);
+
+		# Do actual update
+		settings_without_disable_update
+
+		# Reenable updates to perform a single update
+		if @project.module_enabled?(:repository)
+		    GitHostingObserver.set_update_active(@project);
+		else
+		    GitHostingObserver.set_update_active(:archive);
+		end
+	    end
+
 	    def self.included(base)
 		base.class_eval do
 		    unloadable
@@ -117,6 +132,7 @@ def self.included(base)
 		base.send(:alias_method_chain, :destroy, :disable_update)
 		base.send(:alias_method_chain, :archive, :disable_update)
 		base.send(:alias_method_chain, :unarchive, :disable_update)
+		base.send(:alias_method_chain, :settings, :disable_update)
 	    end
 	end
     end

Diff for: lib/gitolite_conf.rb

@@ -2,6 +2,7 @@ module GitHosting
     class GitoliteConfig
 	DUMMY_REDMINE_KEY="redmine_dummy_key"
 	ARCHIVED_REDMINE_KEY="redmine_archived_project"
+	DISABLED_REDMINE_KEY="redmine_disabled_project"
 	GIT_DAEMON_KEY="daemon"
 	ADMIN_REPO = "gitolite-admin"
 	PRIMARY_CONF_FILE = "gitolite.conf"
@@ -64,6 +65,10 @@ def mark_archived repo_name
 	    add_read_user repo_name, [ARCHIVED_REDMINE_KEY]
 	end
 
+	def mark_disabled repo_name
+	    add_read_user repo_name, [DISABLED_REDMINE_KEY]
+	end
+
 	# Grab admin key (assuming it exists)
 	def get_admin_key
 	    return (repository(ADMIN_REPO).get "RW+").first
@@ -91,6 +96,11 @@ def is_redmine_repo? repo_name
 	    repository(repo_name).rights.detect {|perm, users| users.detect {|key| is_redmine_key? key}} || (repo_has_no_keys? repo_name)
 	end
 
+	# Return true if repository has any redmine keys other than the DUMMY_REDMINE_KEY
+	def has_actual_redmine_keys? repo_name
+	    repository(repo_name).rights.detect {|perm, users| users.detect {|key| GitolitePublicKey::ident_to_user_token(key)}}
+	end
+
 	# Delete all of the redmine keys from a repository
 	# In addition, if there are any redmine keys, delete the GIT_DAEMON_KEY as well,
 	# since we assume this under control of redmine server.
@@ -107,7 +117,7 @@ def repo_has_no_keys? repo_name
 	end
 
 	def is_redmine_key? keyname
-	    (GitolitePublicKey::ident_to_user_token(keyname) || keyname == DUMMY_REDMINE_KEY || keyname == ARCHIVED_REDMINE_KEY) ? true : false
+	    (GitolitePublicKey::ident_to_user_token(keyname) || keyname == DUMMY_REDMINE_KEY || keyname == ARCHIVED_REDMINE_KEY || keyname == DISABLED_REDMINE_KEY) ? true : false
 	end
 
 	def is_daemon_key? keyname