Adding discovery document caching to Service interface

lib/google/api_client/service.rb

@@ -18,6 +18,7 @@ require 'google/api_client/service/resource'
 require 'google/api_client/service/request'
 require 'google/api_client/service/result'
 require 'google/api_client/service/batch'
+require 'google/api_client/service/simple_file_store'
 
 module Google
   class APIClient
@@ -33,6 +34,8 @@ module Google
       include Google::APIClient::Service::StubGenerator
       extend Forwardable
 
+      DEFAULT_CACHE_FILE = 'discovery.cache'
+
       # Cache for discovered APIs.
       @@discovered = {}
 
@@ -81,6 +84,10 @@ module Google
       #   `true` if gzip enabled, `false` otherwise.
       # @option options [Faraday::Connection] :connection
       #   A custom connection to be used for all requests.
+      # @option options [ActiveSupport::Cache::Store, :default] :discovery_cache
+      #   A cache store to place the discovery documents for loaded APIs.
+      #   Avoids unnecessary roundtrips to the discovery service.
+      #   :default loads the default local file cache store.
       def initialize(api_name, api_version, options = {})
         @api_name = api_name.to_s
         if api_version.nil?
@@ -109,11 +116,32 @@ module Google
 
         @options = options
 
-        # Cache discovered APIs in memory.
+        # Initialize cache store. Default to SimpleFileStore if :cache_store
+        # is not provided and we have write permissions.
+        if options.include? :cache_store
+          @cache_store = options[:cache_store]
+        else
+          cache_exists = File.exist?(DEFAULT_CACHE_FILE)
+          if (cache_exists && File.writable?(DEFAULT_CACHE_FILE)) ||
+             (!cache_exists && File.writable?(Dir.pwd))
+            @cache_store = Google::APIClient::Service::SimpleFileStore.new(
+              DEFAULT_CACHE_FILE)
+          end
+        end
+
+        # Attempt to read API definition from memory cache.
         # Not thread-safe, but the worst that can happen is a cache miss.
         unless @api = @@discovered[[api_name, api_version]]
-          @@discovered[[api_name, api_version]] = @api = @client.discovered_api(
-            api_name, api_version)
+          # Attempt to read API definition from cache store, if there is one.
+          # If there's a miss or no cache store, call discovery service.
+          if !@cache_store.nil?
+            @api = @cache_store.fetch("%s/%s" % [api_name, api_version]) do
+              @client.discovered_api(api_name, api_version)
+            end
+          else
+            @api = @client.discovered_api(api_name, api_version)
+          end
+          @@discovered[[api_name, api_version]] = @api
         end
 
         generate_call_stubs(self, @api)
@@ -151,6 +179,16 @@ module Google
       # @return [Faraday::Connection]
       attr_accessor :connection
 
+      ##
+      # The cache store used for storing discovery documents.
+      # If the user requested :default, use SimpleFileStore with default file
+      # name.
+      #
+      # @return [ActiveSupport::Cache::Store,
+      #          Google::APIClient::Service::SimpleFileStore,
+      #          nil]
+      attr_reader :cache_store
+
       ##
       # Prepares a Google::APIClient::BatchRequest object to make batched calls.
       # @param [Array] calls

lib/google/api_client/service/simple_file_store.rb

@@ -0,0 +1,151 @@
+# Copyright 2013 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Google
+  class APIClient
+    class Service
+
+      # Simple file store to be used in the event no ActiveSupport cache store
+      # is provided. This is not thread-safe, and does not support a number of
+      # features (such as expiration), but it's useful for the simple purpose of
+      # caching discovery documents to disk.
+      # Implements the basic cache methods of ActiveSupport::Cache::Store in a
+      # limited fashion.
+      class SimpleFileStore
+
+        # Creates a new SimpleFileStore.
+        #
+        # @param [String] file_path
+        #   The path to the cache file on disk.
+        # @param [Object] options
+        #   The options to be used with this SimpleFileStore. Not implemented.
+        def initialize(file_path, options = nil)
+          @file_path = file_path.to_s
+        end
+
+        # Returns true if a key exists in the cache.
+        #
+        # @param [String] name
+        #   The name of the key. Will always be converted to a string.
+        # @param [Object] options
+        #   The options to be used with this query. Not implemented.
+        def exist?(name, options = nil)
+          read_file
+          @cache.nil? ? nil : @cache.include?(name.to_s)
+        end
+
+        # Fetches data from the cache and returns it, using the given key.
+        # If the key is missing and no block is passed, returns nil.
+        # If the key is missing and a block is passed, executes the block, sets
+        # the key to its value, and returns it.
+        #
+        # @param [String] name
+        #   The name of the key. Will always be converted to a string.
+        # @param [Object] options
+        #   The options to be used with this query. Not implemented.
+        # @yield [String]
+        #   optional block with the default value if the key is missing
+        def fetch(name, options = nil)
+          read_file
+          if block_given?
+            entry = read(name.to_s, options)
+            if entry.nil?
+              value = yield name.to_s
+              write(name.to_s, value)
+              return value
+            else
+              return entry
+            end
+          else
+            return read(name.to_s, options)
+          end
+        end
+
+        # Fetches data from the cache, using the given key.
+        # Returns nil if the key is missing.
+        #
+        # @param [String] name
+        #   The name of the key. Will always be converted to a string.
+        # @param [Object] options
+        #   The options to be used with this query. Not implemented.
+        def read(name, options = nil)
+          read_file
+          @cache.nil? ? nil : @cache[name.to_s]
+        end
+
+        # Writes the value to the cache, with the key.
+        #
+        # @param [String] name
+        #   The name of the key. Will always be converted to a string.
+        # @param [Object] value
+        #   The value to be written.
+        # @param [Object] options
+        #   The options to be used with this query. Not implemented.
+        def write(name, value, options = nil)
+          read_file
+          @cache = {} if @cache.nil?
+          @cache[name.to_s] = value
+          write_file
+          return nil
+        end
+
+        # Deletes an entry in the cache.
+        # Returns true if an entry is deleted.
+        #
+        # @param [String] name
+        #   The name of the key. Will always be converted to a string.
+        # @param [Object] options
+        #   The options to be used with this query. Not implemented.
+        def delete(name, options = nil)
+          read_file
+          return nil if @cache.nil?
+          if @cache.include? name.to_s
+            @cache.delete name.to_s
+            write_file
+            return true
+          else
+            return nil
+          end
+        end
+
+        protected
+
+        # Read the entire cache file from disk.
+        # Will avoid reading if there have been no changes.
+        def read_file
+          if !File.exists? @file_path
+            @cache = nil
+          else
+            # Check for changes after our last read or write.
+            if @last_change.nil? || File.mtime(@file_path) > @last_change
+              File.open(@file_path) do |file|
+                @cache = Marshal.load(file)
+                @last_change = file.mtime
+              end
+            end
+          end
+          return @cache
+        end
+
+        # Write the entire cache contents to disk.
+        def write_file
+          File.open(@file_path, 'w') do |file|
+            Marshal.dump(@cache, file)
+          end
+          @last_change = File.mtime(@file_path)
+        end
+      end
+    end
+  end
+end