routemaster-drain 2.3.0 → 2.4.0

data/lib/core_ext/forwardable.rb

@@ -0,0 +1,14 @@
+if RUBY_VERSION == '2.4.0'
+  # MRI 2.4.0 has a bug in ext/rubyvm/lib/forwardable/impl.rb
+  # This severaly affects gems like Faraday which extensively use delegation to
+  # provide syntax sugar.
+  #
+  # This patch replaces it with the portable version in lib/forwardable/impl.rb
+  # Source: https://bugs.ruby-lang.org/issues/13107
+  require 'forwardable'
+  module Forwardable
+    def self._compile_method(src, file, line)
+      eval(src, nil, file, line)
+    end
+  end
+end

data/lib/routemaster/api_client.rb

@@ -1,13 +1,28 @@
+require 'core_ext/forwardable'
 require 'base64'
 require 'faraday'
 require 'faraday_middleware'
-require 'hashie'
+require 'typhoeus'
 require 'routemaster/config'
 require 'routemaster/middleware/response_caching'
 require 'routemaster/middleware/error_handling'
 require 'routemaster/middleware/metrics'
 require 'routemaster/responses/future_response'
 
+# Loading the Faraday adapter for Typhoeus requires a little dance
+require 'faraday/adapter/typhoeus'
+require 'typhoeus/adapters/faraday'
+
+# The following requires are not direct dependencies, but loading them early
+# prevents Faraday's magic class loading pixie dust from tripping over itself in
+# multithreaded use cases.
+require 'uri'
+require 'faraday/request/retry'
+require 'faraday_middleware/request/encode_json'
+require 'faraday_middleware/response/parse_json'
+require 'faraday_middleware/response/mashify'
+require 'hashie/mash'
+
 module Routemaster
   class APIClient
     def initialize(middlewares: [],
@@ -20,6 +35,8 @@ module Routemaster
       @response_class = response_class
       @metrics_client = metrics_client
       @source_peer = source_peer
+
+      connection # warm up connection so Faraday does all it's magical file loading in the main thread
     end
 
     # Performs a GET HTTP request for the `url`, with optional
@@ -28,69 +45,77 @@ module Routemaster
     # @return an object that responds to `status` (integer), `headers` (hash),
     # and `body`. The body is a `Hashie::Mash` if the response was JSON, a
     # string otherwise.
-    def get(url, params: {}, headers: {})
-      host = URI.parse(url).host
-      response_wrapper do
-        connection.get(url, params, headers.merge(auth_header(host)))
-      end
+    def get(url, params: {}, headers: {}, options: {})
+      enable_caching = options.fetch(:enable_caching, true)
+
+      _wrapped_response _request(
+        :get, 
+        url: url,
+        params: params,
+        headers: headers.merge(response_cache_opt_headers(enable_caching)))
     end
 
-    def fget(url, params: {}, headers: {})
-      Responses::FutureResponse.new { get(url, params: {}, headers: {}) }
+    # Same as {{get}}, except with 
+    def fget(url, **options)
+      uri = _assert_uri(url)
+      Responses::FutureResponse.new { get(uri, options) }
     end
 
     def post(url, body: {}, headers: {})
-      host = URI.parse(url).host
-      response_wrapper do
-        connection.post do |req|
-          req.url url
-          req.headers = headers.merge(auth_header(host))
-          req.body = body
-        end
-      end
+      _request(:post, url: url, body: body, headers: headers)
     end
 
     def patch(url, body: {}, headers: {})
-      host = URI.parse(url).host
-      response_wrapper do
-        connection.patch do |req|
-          req.url url
-          req.headers = headers.merge(auth_header(host))
-          req.body = body
-        end
-      end
+      _request(:patch, url: url, body: body, headers: headers)
     end
 
     def delete(url, headers: {})
-      host = URI.parse(url).host
-      response_wrapper do
-        connection.delete do |req|
-          req.url url
-          req.headers = headers.merge(auth_header(host))
-        end
-      end
+      _request(:delete, url: url, body: nil, headers: headers)
     end
 
     def discover(url)
       get(url)
     end
 
+    def with_response(response_class)
+      memo = @response_class
+      @response_class = response_class
+      yield self
+    ensure
+      @response_class = memo
+    end
+
     private
 
-    def response_wrapper(&block)
-      response = block.call
+    def _assert_uri(url)
+      return url if url.kind_of?(URI)
+      URI.parse(url)
+    end
+
+    def _request(method, url:, body: nil, headers:, params: {})
+      uri = _assert_uri(url)
+      auth = auth_header(uri.host)
+      connection.public_send(method) do |req|
+        req.url uri.to_s
+        req.params.merge! params
+        req.headers = headers.merge(auth)
+        req.body = body
+      end
+    end
+
+    def _wrapped_response(response)
       @response_class ? @response_class.new(response, client: self) : response
     end
 
     def connection
       @connection ||= Faraday.new do |f|
-        f.request  :json
-        f.request  :retry, max: 2, interval: 100e-3, backoff_factor: 2
+        f.request :json
+        f.request :retry, max: 2, interval: 100e-3, backoff_factor: 2
         f.response :mashify
         f.response :json, content_type: /\bjson/
         f.use Routemaster::Middleware::ResponseCaching, listener: @listener
         f.use Routemaster::Middleware::Metrics, client: @metrics_client, source_peer: @source_peer
-        f.adapter  :net_http_persistent
+        f.adapter :typhoeus
         f.use Routemaster::Middleware::ErrorHandling
 
         @middlewares.each do |middleware|
@@ -107,5 +132,9 @@ module Routemaster
       auth_string = Config.cache_auth.fetch(host, []).join(':')
       { 'Authorization' => "Basic #{Base64.strict_encode64(auth_string)}" }
     end
+
+    def response_cache_opt_headers(value)
+      { Routemaster::Middleware::ResponseCaching::RESPONSE_CACHING_OPT_HEADER => value.to_s }
+    end
   end
 end

data/lib/routemaster/cache.rb

@@ -1,4 +1,6 @@
 require 'routemaster/api_client'
+require 'routemaster/cache_key'
+require 'routemaster/event_index'
 require 'wisper'
 
 module Routemaster
@@ -23,10 +25,14 @@ module Routemaster
 
     # Bust the cache for a given URL
     def bust(url)
-      @redis.del("cache:#{url}")
+      @redis.del(Routemaster::CacheKey.url_key(url))
       _publish(:cache_bust, url)
     end
 
+    def invalidate(url)
+      EventIndex.new(url, cache: @redis).increment
+    end
+
     # This is because wisper makes broadcasting methods private
     def _publish(event, url)
       publish(event, url)

data/lib/routemaster/cache_key.rb

@@ -0,0 +1,7 @@
+module Routemaster
+  class CacheKey
+    def self.url_key(url)
+      "cache:#{url}"
+    end
+  end
+end

data/lib/routemaster/config.rb

@@ -2,26 +2,34 @@ require 'singleton'
 require 'hashie/rash'
 require 'set'
 require 'routemaster/redis_broker'
+require 'routemaster/null_logger'
 
 module Routemaster
   class Config
+    include Singleton
     module Classmethods
       def method_missing(method, *args, &block)
-        new.send(method, *args, &block)
+        instance.send(method, *args, &block)
       end
 
       def respond_to?(method, include_all = false)
-        new.respond_to?(method, include_all)
+        instance.respond_to?(method, include_all)
       end
     end
     extend Classmethods
 
+    attr_writer :logger
+
+    def logger
+      @logger ||= NullLogger.new
+    end
+
     def drain_redis
-      RedisBroker.instance.get(ENV.fetch('ROUTEMASTER_DRAIN_REDIS'))
+      RedisBroker.instance.get(:drain_redis, urls: ENV.fetch('ROUTEMASTER_DRAIN_REDIS').split(','))
     end
 
     def cache_redis
-      RedisBroker.instance.get(ENV.fetch('ROUTEMASTER_CACHE_REDIS'))
+      RedisBroker.instance.get(:cache_redis, urls: ENV.fetch('ROUTEMASTER_CACHE_REDIS').split(','))
     end
 
     #
@@ -62,14 +70,5 @@ module Routemaster
     def drain_tokens
       Set.new(ENV.fetch('ROUTEMASTER_DRAIN_TOKENS').split(','))
     end
-
-    def url_expansions
-      Hashie::Rash.new.tap do |result|
-        ENV.fetch('ROUTEMASTER_URL_EXPANSIONS', '').split(',').each do |entry|
-          host, username, password = entry.split(':')
-          result[Regexp.new(host)] = [username, password]
-        end
-      end
-    end
   end
 end

data/lib/routemaster/dirty/map.rb

@@ -44,7 +44,7 @@ module Routemaster
       # It is possible to call +next+ or +break+ from the block.
       def sweep(limit = 0)
         unswept = []
-        while url = @redis.spop(KEY)
+        while (url = @redis.spop(KEY))
           unswept.push url
           is_swept = !! yield(url)
           unswept.pop if is_swept

data/lib/routemaster/drain.rb

@@ -1,5 +1,5 @@
 module Routemaster
   module Drain
-    VERSION = '2.3.0'
+    VERSION = '2.4.0'
   end
 end

data/lib/routemaster/event_index.rb

@@ -0,0 +1,21 @@
+require 'routemaster/cache_key'
+module Routemaster
+  class EventIndex
+    attr_reader :url, :cache
+
+    def initialize(url, cache: Config.cache_redis)
+      @url = url
+      @cache = cache
+    end
+
+    def increment
+      i = cache.hincrby(CacheKey.url_key(url), 'current_index', 1).to_i
+      Config.logger.debug("DRAIN: Increment #{@url} to #{i}") if Config.logger.debug?
+      i
+    end
+
+    def current
+      (cache.hget(CacheKey.url_key(url), 'current_index') || 0).to_i
+    end
+  end
+end

data/lib/routemaster/jobs.rb

@@ -0,0 +1,2 @@
+require_relative 'jobs/cache'
+require_relative 'jobs/cache_and_sweep'

data/lib/routemaster/jobs/cache_and_sweep.rb

@@ -9,8 +9,9 @@ module Routemaster
       def perform(url)
         Dirty::Map.new.sweep_one(url) do
           begin
-            Cache.new.get(url)
+            Routemaster::Cache.new.get(url)
           rescue Errors::ResourceNotFound
+            nil # nothing to cache
           end
         end
       end

data/lib/routemaster/jobs/job.rb

@@ -1,3 +1,5 @@
+require 'routemaster/jobs'
+
 module Routemaster
   module Jobs
     class Job

data/lib/routemaster/middleware/cache.rb

@@ -2,6 +2,7 @@ require 'routemaster/cache'
 require 'routemaster/config'
 require 'routemaster/jobs/client'
 require 'routemaster/jobs/cache_and_sweep'
+require 'routemaster/event_index'
 
 module Routemaster
   module Middleware
@@ -15,7 +16,7 @@ module Routemaster
 
       def call(env)
         env.fetch('routemaster.dirty', []).each do |url|
-          @cache.bust(url)
+          @cache.invalidate(url)
           @client.enqueue(@queue, Routemaster::Jobs::CacheAndSweep, url)
         end
         @app.call(env)
@@ -23,7 +24,3 @@ module Routemaster
     end
   end
 end
-
-
-
-

data/lib/routemaster/middleware/parse.rb

@@ -15,10 +15,10 @@ module Routemaster
       end
 
       def call(env)
-        if env['CONTENT_TYPE'] != 'application/json'
+        if (env['CONTENT_TYPE'] != 'application/json')
           return [415, {}, []]
         end
-        if payload = _extract_payload(env)
+        if (payload = _extract_payload(env))
           env['routemaster.payload'] = payload
         else
           return [400, {}, []]

data/lib/routemaster/middleware/response_caching.rb

@@ -1,55 +1,69 @@
 require 'wisper'
+require 'routemaster/event_index'
+require 'routemaster/cache_key'
 
 module Routemaster
   module Middleware
     class ResponseCaching
-      KEY_TEMPLATE = 'cache:{url}'
-      BODY_FIELD_TEMPLATE = 'v:{version},l:{locale},body'
-      HEADERS_FIELD_TEMPLATE = 'v:{version},l:{locale},headers'
-      VERSION_REGEX = /application\/json;v=(?<version>\S*)/.freeze
+      BODY_FIELD_TEMPLATE = 'v:{version},l:{locale},body'.freeze
+      HEADERS_FIELD_TEMPLATE = 'v:{version},l:{locale},headers'.freeze
+      VERSION_REGEX = /application\/json;v=(?<version>\S*)/
+      RESPONSE_CACHING_OPT_HEADER = 'X-routemaster_drain.opt_cache'.freeze
 
       def initialize(app, cache: Config.cache_redis, listener: nil)
         @app = app
         @cache = cache
-        @expiry  = Config.cache_expiry
+        @expiry = Config.cache_expiry
         @listener = listener
       end
 
       def call(env)
         @cache.del(cache_key(env)) if %i(patch delete).include?(env.method)
         return @app.call(env) if env.method != :get
-
-        fetch_from_cache(env) || fetch_from_service(env)
+        fetch_from_cache(env) || fetch_from_service(env, event_index(env))
       end
 
       private
 
-      def fetch_from_service(env)
+      def fetch_from_service(env, event_index)
         @app.call(env).on_complete do |response_env|
           response = response_env.response
 
-          if response.success?
-            @cache.multi do |multi|
-              multi.hset(cache_key(env), body_cache_field(env), response.body)
-              multi.hset(cache_key(env), headers_cache_field(env), Marshal.dump(response.headers))
-              multi.expire(cache_key(env), @expiry)
+          if response.success? && cache_enabled?(env)
+            namespaced_key = "#{@cache.namespace}:#{cache_key(env)}"
+            @cache.redis.node_for(namespaced_key).multi do |node|
+              if Config.logger.debug?
+                Config.logger.debug("DRAIN: Saving #{url(env)} with a event index of #{event_index}")
+              end
+
+              node.hmset(namespaced_key,
+                         body_cache_field(env), response.body,
+                         headers_cache_field(env), Marshal.dump(response.headers),
+                         :most_recent_index, event_index)
+              node.expire(namespaced_key, @expiry)
             end
+
             @listener._publish(:cache_miss, url(env)) if @listener
           end
         end
       end
 
       def fetch_from_cache(env)
-        body = @cache.hget(cache_key(env), body_cache_field(env))
-        headers = @cache.hget(cache_key(env), headers_cache_field(env))
-
-        if body && headers
-          @listener._publish(:cache_hit, url(env)) if @listener
-          Faraday::Response.new(status: 200,
-                                body: body,
-                                response_headers: Marshal.load(headers),
-                                request: {})
+        return nil unless cache_enabled?(env)
+        body, headers, most_recent_index, current_index = currently_cached_content(env)
+
+        unless most_recent_index.to_i == current_index.to_i && body && headers
+          Config.logger.debug("DRAIN: Cache miss #{url(env)} - index_recent: #{most_recent_index.to_i}") if Config.logger.debug?
+          return nil
         end
+
+        Config.logger.debug("DRAIN: Cache hit #{url(env)} - index_recent: #{most_recent_index.to_i}") if Config.logger.debug?
+        @listener._publish(:cache_hit, url(env)) if @listener
+
+        Faraday::Response.new(status: 200,
+                              body: body,
+                              response_headers: Marshal.load(headers),
+                              request: {})
       end
 
       def body_cache_field(env)
@@ -65,7 +79,7 @@ module Routemaster
       end
 
       def cache_key(env)
-        KEY_TEMPLATE.gsub('{url}', url(env))
+        CacheKey.url_key(url(env))
       end
 
       def url(env)
@@ -73,12 +87,28 @@ module Routemaster
       end
 
       def version(env)
-        (env.request_headers['Accept'] || "")[VERSION_REGEX, 1]
+        (env.request_headers['Accept'] || '')[VERSION_REGEX, 1]
       end
 
       def locale(env)
         env.request_headers['Accept-Language']
       end
+
+      def cache_enabled?(env)
+        env.request_headers[RESPONSE_CACHING_OPT_HEADER].to_s == 'true'
+      end
+
+      def event_index(env)
+        Routemaster::EventIndex.new(url(env)).current
+      end
+
+      def currently_cached_content(env)
+        @cache.hmget(cache_key(env),
+                     body_cache_field(env),
+                     headers_cache_field(env),
+                     :most_recent_index,
+                     :current_index)
+      end
     end
   end
 end