Bypass Cache if git_cache_id is nil

Author: root

Diff for: lib/redmine_git_hosting/patches/git_adapter_patch.rb

@@ -47,15 +47,23 @@ def git_cmd_with_git_hosting(args, options = {}, &block)
 
           cmd_str = full_args.map { |e| shell_quote e.to_s }.join(' ')
 
-          RedmineGitolite::GitHosting.logger.debug { "Send GitCommand : #{cmd_str}" }
-
           # Compute string from repo_path that should be same as: repo.git_cache_id
           # If only we had access to the repo (we don't).
-          repo_id = Repository::Git.repo_path_to_git_cache_id(repo_path)
-
-          # Insert cache between shell execution and caller
-          # repo_path argument used to identify cache entries
-          RedmineGitolite::Cache.execute(cmd_str, repo_id, options, &block)
+          RedmineGitolite::GitHosting.logger.debug { "Lookup for git_cache_id with repository path '#{repo_path}' ... " }
+
+          git_cache_id = Repository::Git.repo_path_to_git_cache_id(repo_path)
+
+          if !git_cache_id.nil?
+            # Insert cache between shell execution and caller
+            # repo_path argument used to identify cache entries
+            RedmineGitolite::GitHosting.logger.debug { "Found git_cache_id ('#{git_cache_id}'), call cache... " }
+            RedmineGitolite::GitHosting.logger.debug { "Send GitCommand : #{cmd_str}" }
+            RedmineGitolite::Cache.execute(cmd_str, git_cache_id, options, &block)
+          else
+            RedmineGitolite::GitHosting.logger.debug { "Unable to find git_cache_id, bypass cache... " }
+            RedmineGitolite::GitHosting.logger.debug { "Send GitCommand : #{cmd_str}" }
+            Redmine::Scm::Adapters::AbstractAdapter.shellout(cmd_str, options, &block)
+          end
         end
 
       end

Diff for: lib/redmine_git_hosting/patches/repository_git_patch.rb

@@ -49,6 +49,7 @@ def repo_path_to_git_cache_id(repo_path)
           return @@cached_id if @@cached_path == repo_path
 
           repo = Repository::Git.find_by_path(repo_path, :loose => true)
+
           if repo
             # Cache translated id path, return id
             @@cached_path = repo_path

Diff for: lib/redmine_gitolite/cache.rb

@@ -32,22 +32,17 @@ def self.logger
     # Primary interface: execute given command and send IO to block
     # options[:write_stdin] will derive caching key from data that block writes to io stream
     def self.execute(cmd_str, repo_id, options = {}, &block)
-      if repo_id.nil?
-        logger.error { "repo_id is nil, exit!" }
-        return false
-      end
-
       if max_cache_time == 0 || options[:uncached]
         # Disabled cache, simply launch shell, don't redirect
         logger.warn { "Cache is disabled : '#{repo_id}'" }
         options.delete(:uncached)
-        retio = options.empty? ? Redmine::Scm::Adapters::AbstractAdapter.shellout(cmd_str, &block) : Redmine::Scm::Adapters::AbstractAdapter.shellout(cmd_str, options, &block)
+        retio = Redmine::Scm::Adapters::AbstractAdapter.shellout(cmd_str, options, &block)
         status = $?
       elsif !options[:write_stdin] && out = self.check_cache(cmd_str)
         # Simple case -- have cached result that depends only on cmd_str
         block.call(out)
-        status = nil
         retio = out
+        status = nil
       else
         # Create redirector stream and call block
         redirector = self.new(cmd_str, repo_id, options)
@@ -56,9 +51,10 @@ def self.execute(cmd_str, repo_id, options = {}, &block)
       end
 
       if status && status.exitstatus.to_i != 0
-        logger.error { "Git exited with non-zero status : #{$?.exitstatus}" }
-        raise Redmine::Scm::Adapters::GitAdapter::ScmCommandAborted, "Git exited with non-zero status : #{$?.exitstatus}"
+        logger.error { "Git exited with non-zero status : #{status.exitstatus}" }
+        raise Redmine::Scm::Adapters::GitAdapter::ScmCommandAborted, "Git exited with non-zero status : #{status.exitstatus}"
       end
+
       return retio
     end