makara 0.3.5

data/lib/makara/connection_wrapper.rb

@@ -0,0 +1,170 @@
+require 'active_support/core_ext/hash/keys'
+
+# Makara::ConnectionWrapper wraps the instance of an underlying connection.
+# The wrapper provides methods for tracking blacklisting and individual makara configurations.
+# Upon creation, the wrapper defines methods in the underlying object giving it access to the
+# Makara::Proxy.
+
+module Makara
+  class ConnectionWrapper
+
+    attr_accessor :initial_error, :config
+
+    # invalid queries caused by connections switching that needs to be replaced
+    SQL_REPLACE = {"SET client_min_messages TO ''".freeze => "SET client_min_messages TO 'warning'".freeze}.freeze
+
+    def initialize(proxy, connection, config)
+      @config = config.symbolize_keys
+      @connection = connection
+      @proxy  = proxy
+
+      if connection.nil?
+        _makara_blacklist!
+      else
+        _makara_decorate_connection(connection)
+      end
+    end
+
+    # the weight of the current node
+    def _makara_weight
+      @config[:weight] || 1
+    end
+
+    # the name of this node
+    def _makara_name
+      @config[:name]
+    end
+
+    # has this node been blacklisted?
+    def _makara_blacklisted?
+      @blacklisted_until.to_i > Time.now.to_i
+    end
+
+    # blacklist this node for @config[:blacklist_duration] seconds
+    def _makara_blacklist!
+      @connection.disconnect! if @connection
+      @connection = nil
+      @blacklisted_until = Time.now.to_i + @config[:blacklist_duration]
+    end
+
+    # release the blacklist
+    def _makara_whitelist!
+      @blacklisted_until = nil
+    end
+
+    # custom error messages
+    def _makara_custom_error_matchers
+      @custom_error_matchers ||= (@config[:connection_error_matchers] || [])
+    end
+
+    def _makara_connected?
+      _makara_connection.present?
+    rescue Makara::Errors::BlacklistConnection
+      false
+    end
+
+    def _makara_connection
+      current = @connection
+
+      if current
+        current
+      else # blacklisted connection or initial error
+        new_connection = @proxy.graceful_connection_for(@config)
+
+        # Already wrapped because of initial failure
+        if new_connection.is_a?(Makara::ConnectionWrapper)
+          _makara_blacklist!
+          raise Makara::Errors::BlacklistConnection.new(self, new_connection.initial_error)
+        else
+          @connection = new_connection
+          _makara_decorate_connection(new_connection)
+          new_connection
+        end
+      end
+    end
+
+    def execute(*args)
+      SQL_REPLACE.each do |find, replace|
+        if args[0] == find
+          args[0] = replace
+        end
+      end
+
+      _makara_connection.execute(*args)
+    end
+
+    # we want to forward all private methods, since we could have kicked out from a private scenario
+    def method_missing(m, *args, &block)
+      if _makara_connection.respond_to?(m)
+        _makara_connection.public_send(m, *args, &block)
+      else # probably private method
+        _makara_connection.__send__(m, *args, &block)
+      end
+    end
+
+
+    class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      def respond_to#{RUBY_VERSION.to_s =~ /^1.8/ ? nil : '_missing'}?(m, include_private = false)
+        _makara_connection.respond_to?(m, true)
+      end
+    RUBY_EVAL
+
+
+    protected
+
+    # once the underlying connection is present we must evaluate extra functionality into it.
+    # all extra functionality is in the format of _makara*
+    def _makara_decorate_connection(con)
+
+      extension = %Q{
+        # the proxy object controlling this connection
+        def _makara
+          @_makara
+        end
+
+        def _makara=(m)
+          @_makara = m
+        end
+
+        # if the proxy has already decided the correct connection to use, yield nil.
+        # if the proxy has yet to decide, yield the proxy
+        def _makara_hijack
+          if _makara.hijacked?
+            yield nil
+          else
+            yield _makara
+          end
+        end
+
+        # for logging, errors, and debugging
+        def _makara_name
+          #{@config[:name].inspect}
+        end
+      }
+
+      # Each method the Makara::Proxy needs to hijack should be redefined in the underlying connection.
+      # The new definition should allow for the proxy to intercept the invocation if required.
+      @proxy.class.hijack_methods.each do |meth|
+        extension << %Q{
+          def #{meth}(*args)
+            _makara_hijack do |proxy|
+              if proxy
+                proxy.#{meth}(*args)
+              else
+                super
+              end
+            end
+          end
+        }
+      end
+
+      # extend the instance
+      con.instance_eval(extension)
+      # set the makara context
+      con._makara = @proxy
+
+      con._makara
+    end
+
+  end
+end

data/lib/makara/context.rb

@@ -0,0 +1,46 @@
+require 'digest/md5'
+
+# Keeps track of the current and previous context (hexdigests)
+# If a new context is needed it can be generated via Makara::Context.generate
+
+module Makara
+  class Context
+    class << self
+
+      def generate(seed = nil)
+        seed ||= "#{Time.now.to_i}#{Thread.current.object_id}#{rand(99999)}"
+        Digest::MD5.hexdigest(seed)
+      end
+
+      def get_previous
+        get_current_thread_local_for(:makara_context_previous)
+      end
+
+      def set_previous(context)
+        set_current_thread_local(:makara_context_previous,context)
+      end
+
+      def get_current
+        get_current_thread_local_for(:makara_context_current)
+      end
+
+      def set_current(context)
+        set_current_thread_local(:makara_context_current,context)
+      end
+
+      protected
+
+      def get_current_thread_local_for(type)
+        t = Thread.current
+        current = t.respond_to?(:thread_variable_get) ? t.thread_variable_get(type) : t[type]
+        current ||= set_current_thread_local(type,generate)
+      end
+
+      def set_current_thread_local(type,context)
+        t = Thread.current
+        t.respond_to?(:thread_variable_set) ? t.thread_variable_set(type,context) : t[type]=context
+      end
+
+    end
+  end
+end

data/lib/makara/error_handler.rb

@@ -0,0 +1,39 @@
+# Base class to handle errors when invoking an underlying connection from a makara proxy.
+# Each concrete implementation of a MakaraProxy can provide it's own ErrorHandler which should inherit
+# from this class.
+
+module Makara
+  class ErrorHandler
+
+
+    def handle(connection)
+      yield
+
+    rescue Exception => e
+
+      if e.class.name =~ /^Makara::/
+        harshly(e)
+      else
+        gracefully(connection, e)
+      end
+
+    end
+
+
+    protected
+
+
+    def gracefully(connection, e)
+      err = Makara::Errors::BlacklistConnection.new(connection, e)
+      ::Makara::Logging::Logger.log("[Makara] Gracefully handling: #{err}")
+      raise err
+    end
+
+
+    def harshly(e)
+      ::Makara::Logging::Logger.log("[Makara] Harshly handling: #{e}")
+      raise e
+    end
+
+  end
+end

data/lib/makara/errors/all_connections_blacklisted.rb

@@ -0,0 +1,13 @@
+module Makara
+  module Errors
+    class AllConnectionsBlacklisted < StandardError
+
+      def initialize(pool, errors)
+        errors = [*errors]
+        messages = errors.empty? ? 'No error details' : errors.map(&:message).join(' -> ')
+        super "[Makara/#{pool.role}] All connections are blacklisted -> " + messages
+      end
+
+    end
+  end
+end

data/lib/makara/errors/blacklist_connection.rb

@@ -0,0 +1,14 @@
+module Makara
+  module Errors
+    class BlacklistConnection < ::StandardError
+
+      attr_reader :original_error
+
+      def initialize(connection, error)
+        @original_error = error
+        super "[Makara/#{connection._makara_name}] #{error.message}"
+      end
+
+    end
+  end
+end

data/lib/makara/errors/no_connections_available.rb

@@ -0,0 +1,14 @@
+module Makara
+  module Errors
+    class NoConnectionsAvailable < ::StandardError
+
+      attr_reader :role
+
+      def initialize(role)
+        @role = role
+        super "[Makara] No connections are available in the #{role} pool"
+      end
+
+    end
+  end
+end

data/lib/makara/logging/logger.rb

@@ -0,0 +1,23 @@
+module Makara
+  module Logging
+    class Logger
+
+      class << self
+
+        def log(msg, format = :error)
+          logger.send(format, msg) if logger
+        end
+
+        def logger
+          @logger
+        end
+
+        def logger=(l)
+          @logger = l
+        end
+
+      end
+
+    end
+  end
+end

data/lib/makara/logging/subscriber.rb

@@ -0,0 +1,38 @@
+module Makara
+  module Logging
+
+    module Subscriber
+      IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
+      def sql(event)
+        name = event.payload[:name]
+        unless IGNORE_PAYLOAD_NAMES.include?(name)
+          name = [current_wrapper_name(event), name].compact.join(' ')
+          event.payload[:name] = name
+        end
+        super(event)
+      end
+
+      protected
+
+      # grabs the adapter used in this event via it's object_id
+      # uses the adapter's connection proxy to modify the name of the event
+      # the name of the used connection will be prepended to the sql log
+      ###
+      ### [Master|Slave] User Load (1.3ms) SELECT * FROM `users`;
+      ###
+      def current_wrapper_name(event)
+        connection_object_id = event.payload[:connection_id]
+        return nil unless connection_object_id
+
+        adapter = ObjectSpace._id2ref(connection_object_id)
+
+        return nil unless adapter
+        return nil unless adapter.respond_to?(:_makara_name)
+
+        "[#{adapter._makara_name}]"
+      end
+    end
+
+  end
+end

data/lib/makara/middleware.rb

@@ -0,0 +1,109 @@
+require 'rack'
+
+# Persists the Makara::Context across requests ensuring the same master pool is used on the subsequent request.
+# Simply sets the cookie with the current context and the status code of this request. The next request then sets
+# the Makara::Context's previous context based on the the previous request. If a redirect is encountered the middleware
+# will defer generation of a new context until a non-redirect request occurs.
+
+module Makara
+  class Middleware
+
+    IDENTIFIER = '_mkra_ctxt'
+
+
+    def initialize(app)
+      @app = app
+    end
+
+
+    def call(env)
+
+      return @app.call(env) if ignore_request?(env)
+
+      Makara::Context.set_previous previous_context(env)
+      Makara::Context.set_current new_context(env)
+
+      status, headers, body = @app.call(env)
+
+      store_context(status, headers)
+
+      [status, headers, body]
+    end
+
+
+    protected
+
+
+    # ignore asset paths
+    # consider allowing a filter proc to be provided in an initializer
+    def ignore_request?(env)
+      if defined?(Rails)
+        if env['PATH_INFO'].to_s =~ /^#{Rails.application.config.assets.prefix}/
+          return true
+        end
+      end
+      false
+    end
+
+
+    # generate a new context based on the request
+    # if the previous request was a redirect, we keep the same context
+    def new_context(env)
+
+      makara_context, makara_status = makara_values(env)
+
+      context = nil
+
+      # if the previous request was a redirect, let's keep that context
+      if makara_status.to_s =~ /^3/ # 300+ redirect
+        context = makara_context
+      end
+
+      context ||= Makara::Context.get_current if env['rack.test']
+      context ||= Makara::Context.generate(env["action_dispatch.request_id"])
+      context
+    end
+
+
+    # pulls the previous context out of the request
+    def previous_context(env)
+      context = makara_values(env).first
+      context ||= Makara::Context.get_previous if env['rack.test']
+      context ||= Makara::Context.generate
+      context
+    end
+
+
+    # retrieve the stored content from the cookie or query
+    # The value contains the hexdigest and status code of the previous
+    # response in the format: $digest--$status
+    def makara_values(env)
+      regex = /#{IDENTIFIER}=([\-a-z0-9A-Z]+)/
+
+      env['HTTP_COOKIE'].to_s =~ regex
+      return $1.split('--') if $1
+
+      env['QUERY_STRING'].to_s =~ regex
+      return $1.split('--') if $1
+
+      [nil, nil]
+    end
+
+
+    # push the current context into the cookie
+    # it should always be for the same path, only
+    # accessible via http and live for a short amount
+    # of time
+    def store_context(status, header)
+
+      cookie_value = {
+        :path => '/',
+        :value => "#{Makara::Context.get_current}--#{status}",
+        :http_only => true,
+        :max_age => '5'
+      }
+
+      Rack::Utils.set_cookie_header!(header, IDENTIFIER, cookie_value)
+    end
+  end
+end