motel-activerecord 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d99bb0326610a2417b22820a6f19fe41267d345
+  data.tar.gz: 5758e9d8179ff47709fe4b3f4633e55842a386ed
+SHA512:
+  metadata.gz: 19f4d633c32fe7a15744f7c3c3599a2adb43c5e04bd1f6be0ce7e1c6d8f12ecf1303707c68f8b58bd5e8ce59fc6906a633b336cfafbc59d60771dc4a3f3ce9f3
+  data.tar.gz: e1900055fe03cb927f8daaf1d6ad4eaf887fe941dbacbe6e371f2ffcd0d6c2e7d0db139ebcf0e69740f7b97d06032a3bad297b24fbbb7c0f3588662583ff6ee7

data/README.md

@@ -0,0 +1,225 @@
+Motel ActiveRecord
+===================
+
+Motel is a gem that adds functionality to ActiveRecord to use
+connections to multiple databases, one for each tenant.
+
+# Features
+
+* Adds multi-tenant functionality to ActiveRecord.
+* Multiple databases, one for each tenant.
+* Tenant connection details are stored keying them by the name on a database or redis server.
+* Use with or without Rails.
+
+# Installing
+
+```ruby
+gem install motel-activerecord
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'motel-activerecord'
+```
+
+and run `bundle install` from your shell.
+
+# Supported Ruby and Rails versions
+The gem motel-activerecord supports MRI Ruby 2.0 or greater and Rails 4.0 or greater.
+ 
+# Configuration
+
+## Use with Rails
+
+In your app/application.rb file write this:
+
+### Specifying database as a source of tenants
+
+```ruby
+config.motel.tenants_source_configurations = {
+  source:      :database,
+  source_spec: { adapter: 'sqlite3', database: 'db/tenants.sqlite3' },
+  table_name:  'tenant'
+}
+```
+
+You can specify the source by providing a hash of the
+connection specification. Example:
+
+```ruby
+source_spec: {adapter: 'sqlite3', database: 'db/tenants.sqlite3'}
+```
+
+Table name where are stored the connection details of tenants:
+
+```ruby
+table_name: 'tenant'
+```
+
+Note: The columns of the table must contain connection details and
+thad are according with the information needed to connect to a database,
+including the name column to store the tenant name. Example columns 
+are showed below:
+
+|Name       |Type       |
+| ----------|:---------:|
+| name      | String    |
+| adapter   | String    |
+| sockect   | String    |
+| port      | Integer   |
+| pool      | Integer   |
+| host      | Integer   |
+| username  | Integer   |
+| password  | Integer   |
+| database  | Integer   |
+| url       | String    |
+
+
+### Specifying a redis-server as a source of tenants
+
+```ruby
+config.motel.tenants_source_configurations = {
+  source:   :redis,
+  host:     127.0.0.1,
+  port:     6380,
+  password: 'redis_password'
+}
+```
+To connect to Redis listening on a Unix socket, try use 'path'
+option.
+
+### Default source of tenants
+
+Also you can use the gem without specify a source configuration. 
+
+If you want to assing dirently the tenants specificactions you can do it:
+
+```ruby
+config.motel.tenants_source_configurations = {
+  tenant: { 'foo' => { adapter: 'sqlite3', database: 'db/foo.sqlite3' }}
+}
+```
+
+Assing tenants from database.yml file:
+
+```ruby
+config.motel.tenants_source_configurations = {
+  tenant: Rails.application.config.database_configuration
+}
+```
+
+Note: The methods like `add_tenant`, `update_tenant` and 
+`delete_tenant` dosen't store permanently tenants.
+
+### More configurations
+
+You can assign a default tenant if the current tenant is null:
+
+```ruby
+config.motel.default_tenant = 'my_default_tenant'
+```
+
+Tenants switching is done via the subdomain of the url, you can
+specify a criteria to identify the tenant providing a regex as a 
+string. Example, to get the tenant `foo` from the following url
+`http://www.example.com/foo/index` you should write:
+
+```ruby
+config.motel.admission_criteria = '\/(\w*)\/'
+```
+
+To disable automatic switching between tenants by url you must
+disable the middleware:
+
+```ruby
+config.motel.disable_middleware = true
+```
+
+Path of the html page to show if tenant doesn't exist. Default is
+`public/404.html`.
+
+```ruby
+config.motel.nonexistent_tenant_page = 'new_path'
+```
+
+## Use without Rails
+
+### Specifying the source of tenants
+
+You can set the source of the tenants in the same way as with Rails, use the method `tenants_source_configurations` of `ActiveRecord::Base.motel`:
+
+```ruby
+ActiveRecord::Base.motel.tenants_source_configurations({
+  source:      :database,
+  source_spec: { adapter: 'sqlite3', database: 'db/tenants.sqlite3' },
+  table_name:  'tenant'
+})
+```
+
+# Available methods
+
+Set a tenats source configurations
+```ruby
+ActiveRecord::Base.motel.tenants_source_configurations(config)
+```
+
+Set the admission criterio for the middleware
+```ruby
+ActiveRecord::Base.motel.admission_criterio
+```
+
+Set a default tenant
+```ruby
+ActiveRecord::Base.motel.default_tenant
+```
+
+Set the html page to show if tenant doesn't exist
+```ruby
+ActiveRecord::Base.motel.nonexistent_tenant_page
+```
+
+Set a current tenant
+```ruby
+ActiveRecord::Base.motel.current_tenant
+```
+
+Retrieve the connection details of all tenants
+```ruby
+ActiveRecord::Base.motel.tenants
+```
+
+Retrieve a tenant
+```ruby
+ActiveRecord::Base.motel.tenant(name)
+```
+
+Determine if a tenant exists
+```ruby
+ActiveRecord::Base.motel.tenant?(name)
+```
+
+Add tenant
+```ruby
+ActiveRecord::Base.motel.add_tenant(name, spec)
+```
+
+Update tenant
+```ruby
+ActiveRecord::Base.motel.update_tenant(name, spec)
+```
+
+Delete tenant
+```ruby
+ActiveRecord::Base.motel.delete_tenant(name)
+```
+
+Retrieve the names of the tenants of active connections
+```ruby
+ActiveRecord::Base.motel.active_tenants
+```
+
+Determine the tenant to use for the connection
+```ruby
+ActiveRecord::Base.motel.determines_tenant
+```

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/motel-activerecord.rb

@@ -0,0 +1,10 @@
+require 'motel/connection_adapters'
+require 'motel/lobby'
+require 'motel/manager'
+require 'motel/sources'
+require 'motel/multi_tenant'
+require 'motel/errors'
+require 'motel/version'
+
+require 'motel/railtie' if defined? Rails
+

data/lib/motel/connection_adapters.rb

@@ -0,0 +1,3 @@
+require 'motel/connection_adapters/connection_handler'
+require 'motel/connection_adapters/connection_specification'
+

data/lib/motel/connection_adapters/connection_handler.rb

@@ -0,0 +1,96 @@
+require 'active_record'
+
+module Motel
+  module ConnectionAdapters
+
+    class ConnectionHandler < ActiveRecord::ConnectionAdapters::ConnectionHandler
+
+      attr_accessor :tenants_source
+
+      def initialize(tenants_source = Sources::Default.new)
+        @owner_to_pool = ThreadSafe::Cache.new(:initial_capacity => 2) do |h,k|
+          h[k] = ThreadSafe::Cache.new(:initial_capacity => 2)
+        end
+        @class_to_pool = ThreadSafe::Cache.new(:initial_capacity => 2) do |h,k|
+          h[k] = ThreadSafe::Cache.new
+        end
+
+        @tenants_source = tenants_source
+      end
+
+      def establish_connection(tenant_name, spec = nil)
+        spec ||= connection_especification(tenant_name)
+        @class_to_pool.clear
+        owner_to_pool[tenant_name] = ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec)
+      end
+
+      def retrieve_connection(tenant_name)
+        pool = retrieve_connection_pool(tenant_name)
+
+        unless pool.connection
+          establish_connection tenant_name
+          pool = retrieve_connection_pool(tenant_name)
+        end
+
+        pool.connection
+      end
+
+      def retrieve_connection_pool(tenant_name)
+        class_to_pool[tenant_name] ||= begin
+          pool = pool_for(tenant_name)
+
+          class_to_pool[tenant_name] = pool
+        end
+      end
+
+      def remove_connection(tenant_name)
+        if pool = owner_to_pool.delete(tenant_name)
+          @class_to_pool.clear
+          pool.automatic_reconnect = false
+          pool.disconnect!
+          pool.spec.config
+        end
+      end
+
+      def connected?(tenant_name)
+        conn = retrieve_connection_pool(tenant_name)
+        conn && conn.connected?
+      end
+
+      def pool_for(tenant_name)
+        owner_to_pool.fetch(tenant_name) {
+          establish_connection tenant_name
+        }
+      end
+
+      def pool_from_any_process_for(tenant_name)
+        owner_to_pool = @owner_to_pool.values.find { |v| v[tenant_name] }
+        owner_to_pool && owner_to_pool[tenant_name]
+      end
+
+      def active_tenants
+         owner_to_pool.keys
+      end
+
+      private
+
+        def connection_especification(tenant_name)
+          unless tenants_source.tenant?(tenant_name)
+            raise NonexistentTenantError, "Nonexistent #{tenant_name} tenant"
+          end
+
+          resolver = ConnectionSpecification::Resolver.new
+          spec = resolver.spec(tenants_source.tenant(tenant_name))
+
+          unless ActiveRecord::Base.respond_to?(spec.adapter_method)
+            raise ActiveRecord::AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
+          end
+
+          spec
+        end
+
+    end
+
+  end
+end
+

data/lib/motel/connection_adapters/connection_specification.rb

@@ -0,0 +1,2 @@
+require 'motel/connection_adapters/connection_specification/resolver'
+

data/lib/motel/connection_adapters/connection_specification/resolver.rb

@@ -0,0 +1,92 @@
+require 'uri'
+require 'active_record'
+require 'active_support/core_ext/hash/keys'
+
+module Motel
+  module ConnectionAdapters
+    module ConnectionSpecification
+      class Resolver
+
+        attr_accessor :configurations
+
+        def initialize(configurations = nil)
+          @configurations = configurations || {}
+        end
+
+        def spec(config)
+          spec = resolve(config).symbolize_keys
+
+          raise(ActiveRecord::AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
+
+          path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
+          begin
+            require path_to_adapter
+          rescue Gem::LoadError => e
+            raise Gem::LoadError, "Specified '#{spec[:adapter]}' for database adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRecord)."
+          rescue LoadError => e
+            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql', 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
+          end
+
+          adapter_method = "#{spec[:adapter]}_connection"
+          ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(spec, adapter_method)
+        end
+
+        private
+
+          def resolve(config)
+            case config
+            when nil
+              raise ActiveRecord::AdapterNotSpecified
+            when String, Symbol
+              resolve_string_connection config.to_s
+            when Hash
+              resolve_hash_connection config
+            end
+          end
+
+          def resolve_hash_connection(spec)
+            if url = spec.delete("url")
+              connection_hash = resolve_string_connection(url)
+              spec.merge!(connection_hash)
+            end
+            spec
+          end
+
+          def resolve_string_connection(spec)
+            hash = configurations.fetch(spec) do |k|
+              connection_url_to_hash(k)
+            end
+
+            resolve_hash_connection hash
+          end
+
+          def connection_url_to_hash(url)
+            config = URI.parse url
+            adapter = config.scheme
+            adapter = "postgresql" if adapter == "postgres"
+            spec = { :adapter => adapter,
+                     :username => config.user,
+                     :password => config.password,
+                     :port => config.port,
+                     :database => config.path.sub(%r{^/},""),
+                     :host => config.host }
+
+            spec.reject!{ |_,value| value.blank? }
+
+            uri_parser = URI::Parser.new
+
+            spec.map { |key,value| spec[key] = uri_parser.unescape(value) if value.is_a?(String) }
+
+            if config.query
+              options = Hash[config.query.split("&").map{ |pair| pair.split("=") }].symbolize_keys
+
+              spec.merge!(options)
+            end
+
+            spec
+          end
+
+      end
+    end
+  end
+end