keymap 0.1.0

data/lib/keymap/connection_adapters/abstract/connection_specification.rb

@@ -0,0 +1,159 @@
+require 'uri'
+
+module Keymap
+  class Base
+    class ConnectionSpecification #:nodoc:
+      attr_reader :config, :adapter_method
+
+      def initialize (config, adapter_method)
+        @config, @adapter_method = config, adapter_method
+      end
+
+      ##
+      # Builds a ConnectionSpecification from user input
+      class Resolver # :nodoc:
+
+        attr_reader :config, :configurations
+
+        def initialize(config, configurations)
+          @config = config
+          @configurations = configurations
+        end
+
+        def spec
+          case config
+            when nil
+              raise AdapterNotSpecified unless defined?(Keymap.env)
+              resolve_string_connection Keymap.env
+            when Symbol, String
+              resolve_string_connection config.to_s
+            when Hash
+              resolve_hash_connection config
+            else
+              # type code here
+          end
+        end
+
+        private
+
+        def resolve_string_connection(spec) # :nodoc:
+          hash = configurations.fetch(spec) do |k|
+            connection_url_to_hash(k)
+          end
+
+          raise(AdapterNotSpecified, "#{spec} database is not configured") unless hash
+
+          resolve_hash_connection hash
+        end
+
+        def resolve_hash_connection(spec) # :nodoc:
+          spec = spec.symbolize_keys
+
+          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
+
+          begin
+            require "keymap/connection_adapters/#{spec[:adapter]}_adapter"
+          rescue LoadError => e
+            raise LoadError, "Please install the #{spec[:adapter]} adapter: `gem install keymap-#{spec[:adapter]}-adapter` (#{e.message})", e.backtrace
+          end
+
+          adapter_method = "#{spec[:adapter]}_connection"
+
+          ConnectionSpecification.new(spec, adapter_method)
+        end
+
+        def connection_url_to_hash(url) # :nodoc:
+          config = URI.parse url
+          adapter = config.scheme
+          spec = {:adapter => adapter,
+                  :username => config.user,
+                  :password => config.password,
+                  :port => config.port,
+                  :database => config.path.sub(%r{^/}, ""),
+                  :host => config.host}
+          spec.reject! { |_, value| !value }
+          if config.query
+            options = Hash[config.query.split("&").map { |pair| pair.split("=") }].symbolize_keys
+            spec.merge!(options)
+          end
+          spec
+        end
+
+      end
+    end
+
+    ##
+    # :singleton-method:
+    # The connection handler
+    class_attribute :connection_handler, :instance_writer => false
+    self.connection_handler = Keymap::ConnectionAdapters::ConnectionHandler.new
+
+    def connection
+      self.class.connection
+    end
+
+    def self.establish_connection(spec = ENV["DATABASE_URL"])
+      resolver = Keymap::Base::ConnectionSpecification::Resolver.new spec, configurations
+      spec = resolver.spec
+
+      unless respond_to?(spec.adapter_method)
+        raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
+      end
+
+      remove_connection
+      connection_handler.establish_connection name, spec
+    end
+
+    class << self
+      # Returns the connection currently associated with the class. This can
+      # also be used to "borrow" the connection to do database work unrelated
+      # to any of the specific Active Records.
+      def connection
+        retrieve_connection
+      end
+
+      def connection_id
+        Thread.current['Keymap::Base.connection_id']
+      end
+
+      def connection_id=(connection_id)
+        Thread.current['Keymap::Base.connection_id'] = connection_id
+      end
+
+      # Returns the configuration of the associated connection as a hash:
+      #
+      #  ActiveRecord::Base.connection_config
+      #  # => {:pool=>5, :timeout=>5000, :database=>"db/development.sqlite3", :adapter=>"sqlite3"}
+      #
+      # Please use only for reading.
+      def connection_config
+        connection_pool.spec.config
+      end
+
+      def connection_pool
+        connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
+      end
+
+      def retrieve_connection
+        connection_handler.retrieve_connection(self)
+      end
+
+      # Returns true if Keymap is connected.
+      def connected?
+        connection_handler.connected?(self)
+      end
+
+      def remove_connection(klass = self)
+        connection_handler.remove_connection(klass)
+      end
+
+      def clear_active_connections!
+        connection_handler.clear_active_connections!
+      end
+
+      delegate :clear_reloadable_connections!,
+               :clear_all_connections!, :verify_active_connections!, :to => :connection_handler
+    end
+
+  end
+end

data/lib/keymap/connection_adapters/abstract/transaction_management.rb

@@ -0,0 +1,39 @@
+require 'keymap/errors'
+
+module Keymap
+  module ConnectionAdapters # :nodoc:
+    module TransactionManagement
+
+      # Runs the given block in a database transaction, and returns the result
+      # of the block.
+      def transaction(options = {})
+        transaction_open = false
+        @_current_transaction_records ||= []
+        begin
+          if block_given?
+            begin_db_transaction
+            transaction_open = true
+            @_current_transaction_records.push([])
+            yield
+          end
+        rescue Exception => database_transaction_rollback
+          if transaction_open && !outside_transaction?
+            transaction_open = false
+            rollback_db_transaction
+          end
+          raise unless database_transaction_rollback.is_a?(Rollback)
+        end
+      ensure
+        if transaction_open
+          begin
+            commit_db_transaction
+          rescue Exception => database_transaction_rollback
+            rollback_db_transaction
+            raise
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/keymap/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,139 @@
+require 'monitor'
+require 'active_support/callbacks'
+require 'active_support/dependencies/autoload'
+require 'keymap/connection_adapters/abstract/transaction_management'
+
+module Keymap
+
+  module ConnectionAdapters # :nodoc:
+
+    extend ActiveSupport::Autoload
+
+    autoload_under 'abstract' do
+      autoload :ConnectionPool
+      autoload :ConnectionHandler, 'keymap/connection_adapters/abstract/connection_pool'
+      autoload :ConnectionManagement, 'keymap/connection_adapters/abstract/connection_pool'
+      autoload :ConnectionSpecification
+    end
+
+    class AbstractAdapter
+
+      include ActiveSupport::Callbacks
+      include TransactionManagement
+      include MonitorMixin
+
+      define_callbacks :checkout, :checkin
+      attr_accessor :pool
+      attr_reader :last_use, :in_use, :logger
+      alias :in_use? :in_use
+
+      def initialize(connection, logger = nil, pool = nil) #:nodoc:
+        super()
+
+        @active = nil
+        @connection = connection
+        @logger = logger
+        @pool = pool
+
+        @in_use = false
+        @last_use = false
+      end
+
+      def lease
+        synchronize do
+          unless in_use
+            @in_use = true
+            @last_use = Time.now
+          end
+        end
+      end
+
+      def expire
+        @in_use = false
+      end
+
+      # Returns the human-readable name of the adapter. Use mixed case - one
+      # can always use downcase if needed.
+      def adapter_name
+        'Abstract'
+      end
+
+      # CONNECTION MANAGEMENT ====================================
+
+      # Checks whether the connection to the database is still active. This includes
+      # checking whether the kv-store is actually capable of responding, i.e. whether
+      # the connection isn't stale.
+      def active?
+        @active
+      end
+
+      # Disconnects from the database if already connected, and establishes a
+      # new connection with the database.
+      def reconnect!
+        @active = true
+      end
+
+      # Disconnects from the kv-store if already connected. Otherwise, this
+      # method does nothing.
+      def disconnect!
+        @active = false
+      end
+
+      # Reset the state of this connection, directing the kv-store to clear
+      # transactions and other connection-related server-side state. Usually a
+      # implementation-dependent operation.
+      #
+      # The default implementation does nothing; the implementation should be
+      # overridden by concrete adapters.
+      def reset!
+        # this should be overridden by concrete adapters
+      end
+
+      ###
+      # Clear any caching the kv-store adapter may be doing. This is kv-store
+      # specific.
+      def clear_cache!
+        # this should be overridden by concrete adapters
+      end
+
+      # Returns true if its required to reload the connection between requests for development mode.
+      def requires_reloading?
+        false
+      end
+
+      # Checks whether the connection to the kv-store is still active (i.e. not stale).
+      # This is done under the hood by calling <tt>active?</tt>. If the connection
+      # is no longer active, then this method will reconnect to the kv-store.
+      def verify!
+        reconnect! unless active?
+      end
+
+      # Provides access to the underlying kv-store driver for this adapter. For
+      # example, this method returns a Redis object in case of RedisAdapter.
+      #
+      # This is useful for when you need to call a proprietary method.
+      def raw_connection
+        @connection
+      end
+
+      # Begins the transaction (and turns off auto-committing).
+      def begin_db_transaction()
+      end
+
+      # Commits the transaction (and turns on auto-committing).
+      def commit_db_transaction()
+      end
+
+      # Rolls back the transaction (and turns on auto-committing). Must be
+      # done if the transaction block raises an exception or returns false.
+      def rollback_db_transaction()
+      end
+
+      # Check the connection back in to the connection pool
+      def close
+        pool.checkin self
+      end
+    end
+
+  end
+end

data/lib/keymap/connection_adapters/redis_adapter.rb

@@ -0,0 +1,113 @@
+require 'keymap/connection_adapters/abstract_adapter'
+require 'redis'
+
+module Keymap
+
+  class Base
+    def self.redis_connection(config)
+      config = config.symbolize_keys
+      config[:port] ||= 6379
+      ConnectionAdapters::RedisAdapter.new(nil, nil, config)
+    end
+  end
+
+  module ConnectionAdapters
+
+    class RedisAdapter < AbstractAdapter
+
+      attr_reader :config
+
+      def initialize(connection, pool, config)
+        super(nil)
+        @config = config
+        reconnect!
+      end
+
+      def adapter_name
+        'redis'
+      end
+
+      def active?
+        return false unless @connection
+        @connection.ping == "PONG"
+      end
+
+      def reconnect!
+        disconnect!
+        connect
+        super
+      end
+
+      alias :reset! :reconnect!
+
+      # Disconnects from the database if already connected.
+      # Otherwise, this method does nothing.
+      def disconnect!
+        super
+        unless @connection.nil?
+          @connection.quit
+          @connection = nil
+        end
+      end
+
+      private
+
+      def connect
+        @connection = Redis.new(config)
+      end
+
+      public
+
+      def begin_db_transaction
+        raw_connection.multi
+      end
+
+      def commit_db_transaction
+        raw_connection.exec
+      end
+
+      def rollback_db_transaction
+        raw_connection.discard
+      end
+
+      # Retrieves the hash whose name is identified by key.
+      def hash (key)
+        coll = KeyStoreHash.new
+        coll.connection = raw_connection
+        coll.key = key
+        coll
+        #
+        # Perhaps there is a more experienced ruby developer who could help with this.
+        # I'd rather do the following but could not figure out how to get it to work:
+        #
+        #def create_getter(connection, key)
+        #  lambda { |field| connection.hget key, field }
+        #end
+        #
+        #def create_setter(connection, key)
+        #  lambda { |field, value| connection.hset key, field, value }
+        #end
+        #
+        #coll.class.send :define_method, "[]", create_getter(raw_connection, key)
+        #coll.class.send :define_method, "[]=", create_setter(raw_connection, key)
+        #coll
+      end
+    end
+
+    private
+
+    class KeyStoreHash < Hash
+
+      attr_accessor :connection, :key
+
+      def [] (field)
+        connection.hget key, field
+      end
+
+      def []=(field, value)
+        connection.hset key, field, value
+      end
+    end
+
+  end
+end