Add a Cache::Adapter class to handle different caching system :)

Author: root

Diff for: lib/redmine_git_hosting/cache.rb

@@ -20,18 +20,17 @@ def max_cache_size
 
 
       def set_cache(repo_id, out_value, primary_key, secondary_key = nil)
-        logger.debug("Inserting cache entry for repository '#{repo_id}'")
-        logger.debug(compose_key(primary_key, secondary_key))
         command = compose_key(primary_key, secondary_key)
-        set_cache_entry(command, out_value, repo_id)
+        adapter.apply_cache_limit(max_cache_elements) if adapter.set_cache(command, out_value, repo_id)
       end
 
 
-      def check_cache(primary_key, secondary_key = nil)
-        cached = get_cache_entry(primary_key, secondary_key)
+      def get_cache(primary_key, secondary_key = nil)
+        command = compose_key(primary_key, secondary_key)
+        cached  = adapter.get_cache(command)
 
         if cached
-          if valid_cache_entry?(cached)
+          if valid_cache_entry?(cached.created_at)
             # Update updated_at flag
             cached.touch unless cached.command_output.nil?
             out = cached.command_output
@@ -52,51 +51,31 @@ def check_cache(primary_key, secondary_key = nil)
       def clear_obsolete_cache_entries
         return if max_cache_time < 0  # No expiration needed
         limit = Time.now - max_cache_time
-        do_clear_obsolete_cache_entries(limit)
+        adapter.clear_obsolete_cache_entries(limit)
       end
 
 
       # Clear the cache entries for given repository / git_cache_id
       def clear_cache_for_repository(repo_id)
-        do_clear_cache_for_repository(repo_id)
+        adapter.clear_cache_for_repository(repo_id)
       end
 
 
-      private
-
-
-        def set_cache_entry(command, output, repo_id)
-          begin
-            GitCache.create(
-              command:         command,
-              command_output:  output,
-              repo_identifier: repo_id
-            )
-          rescue => e
-            logger.error("Could not insert in cache, this is the error : '#{e.message}'")
-          else
-            apply_cache_limit
-          end
-        end
+      def adapter
+        @adapter ||= Cache::Adapter.factory
+      end
 
 
-        def get_cache_entry(primary_key, secondary_key)
-          GitCache.find_by_command(compose_key(primary_key, secondary_key))
-        end
+      private
 
 
-        def valid_cache_entry?(cached)
+        def valid_cache_entry?(cached_entry_date)
           current_time = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
-          expired = (current_time.to_i - cached.created_at.to_i < max_cache_time)
+          expired = (current_time.to_i - cached_entry_date.to_i > max_cache_time)
           (!expired || max_cache_time < 0) ? true : false
         end
 
 
-        def apply_cache_limit
-          GitCache.find(:last, order: 'created_at DESC').destroy if max_cache_elements >= 0 && GitCache.count > max_cache_elements
-        end
-
-
         def compose_key(key1, key2)
           if key2 && !key2.blank?
             key1 + "\n" + key2
@@ -105,23 +84,6 @@ def compose_key(key1, key2)
           end
         end
 
-
-        def do_clear_obsolete_cache_entries(limit)
-          deleted = GitCache.delete_all(['created_at < ?', limit])
-          logger.info("Removed '#{deleted}' expired cache entries among all repositories")
-        end
-
-
-        def do_clear_cache_for_repository(repo_id)
-          deleted = GitCache.delete_all(['repo_identifier = ?', repo_id])
-          logger.info("Removed '#{deleted}' expired cache entries for repository '#{repo_id}'")
-        end
-
-
-        def logger
-          RedmineGitHosting.logger
-        end
-
     end
 
   end

Diff for: lib/redmine_git_hosting/cache/abstract_cache.rb

@@ -0,0 +1,37 @@
+module RedmineGitHosting::Cache
+  class AbstractCache
+
+    def set_cache(command, output, repo_id)
+      raise NotImplementedError
+    end
+
+
+    def get_cache(command)
+      raise NotImplementedError
+    end
+
+
+    def clear_obsolete_cache_entries(limit)
+      raise NotImplementedError
+    end
+
+
+    def clear_cache_for_repository(repo_id)
+      raise NotImplementedError
+    end
+
+
+    def apply_cache_limit(max_cache_elements)
+      raise NotImplementedError
+    end
+
+
+    private
+
+
+      def logger
+        RedmineGitHosting.logger
+      end
+
+  end
+end

Diff for: lib/redmine_git_hosting/cache/adapter.rb

@@ -0,0 +1,13 @@
+module RedmineGitHosting::Cache
+  class Adapter
+
+    class << self
+
+      def factory
+        Database.new
+      end
+
+    end
+
+  end
+end

Diff for: lib/redmine_git_hosting/cache/database.rb

@@ -0,0 +1,42 @@
+module RedmineGitHosting::Cache
+  class Database < AbstractCache
+
+    def set_cache(command, output, repo_id)
+      logger.debug("Inserting cache entry for repository '#{repo_id}'")
+      begin
+        GitCache.create(
+          command:         command,
+          command_output:  output,
+          repo_identifier: repo_id
+        )
+        true
+      rescue => e
+        logger.error("Could not insert in cache, this is the error : '#{e.message}'")
+        false
+      end
+    end
+
+
+    def get_cache(command)
+      GitCache.find_by_command(command)
+    end
+
+
+    def clear_obsolete_cache_entries(limit)
+      deleted = GitCache.delete_all(['created_at < ?', limit])
+      logger.info("Removed '#{deleted}' expired cache entries among all repositories")
+    end
+
+
+    def clear_cache_for_repository(repo_id)
+      deleted = GitCache.delete_all(['repo_identifier = ?', repo_id])
+      logger.info("Removed '#{deleted}' expired cache entries for repository '#{repo_id}'")
+    end
+
+
+    def apply_cache_limit(max_cache_elements)
+      GitCache.find(:last, order: 'created_at DESC').destroy if max_cache_elements >= 0 && GitCache.count > max_cache_elements
+    end
+
+  end
+end

Diff for: lib/redmine_git_hosting/shell_redirector.rb

@@ -35,7 +35,7 @@ def logger
       # *options[:write_stdin]* will derive caching key from data that block writes to io stream.
       #
       def execute(cmd_str, repo_id, options = {}, &block)
-        if !options[:write_stdin] && out = RedmineGitHosting::Cache.check_cache(cmd_str)
+        if !options[:write_stdin] && out = RedmineGitHosting::Cache.get_cache(cmd_str)
           # Simple case -- have cached result that depends only on cmd_str
           block.call(out)
           retio = out
@@ -153,7 +153,7 @@ def binmode
 
     def close_write
       # Ok -- now have all the extra args...  Check cache
-      out = RedmineGitHosting::Cache.check_cache(@my_cmd_str, @my_extra_args)
+      out = RedmineGitHosting::Cache.get_cache(@my_cmd_str, @my_extra_args)
       if out
         # Match in the cache!
         @state = STRING_IO