motel-activerecord 1.0.0

data/lib/motel/errors.rb

@@ -0,0 +1,28 @@
+module Motel
+
+  class ExistingTenantError < StandardError
+    def initialize(msg = "Existing tenant")
+      super(msg)
+    end
+  end
+
+  class NonexistentTenantError < StandardError
+    def initialize(msg = "Nonexistent tenant")
+      super(msg)
+    end
+  end
+
+  class NoCurrentTenantError < StandardError
+    def initialize(msg = "No current tenant")
+      super(msg)
+    end
+  end
+
+  class AnonymousTenantError < StandardError
+    def initialize(msg = "Anonymous tenant is not allowed")
+      super(msg)
+    end
+  end
+
+end
+

data/lib/motel/lobby.rb

@@ -0,0 +1,47 @@
+require 'rack'
+
+module Motel
+
+  class Lobby
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      name = tenant_name(request)
+
+      if name
+        if ActiveRecord::Base.motel.tenant?(name)
+          ActiveRecord::Base.motel.current_tenant = name
+          @app.call(env)
+        else
+          path = ActiveRecord::Base.motel.nonexistent_tenant_page
+          file = File.expand_path(path) if path
+          body = (File.exists?(file.to_s)) ? File.read(file) : "Nonexistent #{name} tenant"
+          [404, {"Content-Type" => "text/html", "Content-Length" => body.size.to_s}, [body]]
+        end
+      else
+        ActiveRecord::Base.motel.current_tenant = nil
+        @app.call(env)
+      end
+    end
+
+    private
+
+      def tenant_name(request)
+        if ActiveRecord::Base.motel.admission_criteria
+          regex = Regexp.new(ActiveRecord::Base.motel.admission_criteria)
+          name = request.path.match(regex)
+          name[1] if name
+        else
+         request.host.split('.').first
+        end
+      end
+
+  end
+
+end
+

data/lib/motel/manager.rb

@@ -0,0 +1,69 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
+require 'active_record'
+
+module Motel
+  module Manager
+
+    mattr_accessor :nonexistent_tenant_page
+    mattr_accessor :admission_criteria
+    mattr_accessor :default_tenant
+    mattr_accessor :current_tenant
+
+    class << self
+
+      def tenants_source_configurations(config)
+        source_type = config[:source] || 'default'
+        source_class = "Motel::Sources::#{source_type.to_s.camelize}".constantize
+
+        source_instance = source_class.new(config)
+
+        ActiveRecord::Base.connection_handler.tenants_source = source_instance
+      end
+
+      def tenants
+        tenants_source.tenants
+      end
+
+      def tenant(name)
+        tenants_source.tenant(name)
+      end
+
+      def tenant?(name)
+        active_tenants.include?(name) || tenants_source.tenant?(name)
+      end
+
+      def add_tenant(name, spec)
+        tenants_source.add_tenant(name, spec)
+        tenant?(name)
+      end
+
+      def update_tenant(name, spec)
+        ActiveRecord::Base.remove_connection(name)
+        tenants_source.update_tenant(name, spec)
+        tenant(name)
+      end
+
+      def delete_tenant(name)
+        ActiveRecord::Base.remove_connection(name)
+        tenants_source.delete_tenant(name)
+        !tenant?(name)
+      end
+
+      def active_tenants
+        ActiveRecord::Base.connection_handler.active_tenants
+      end
+
+      def determines_tenant
+        ENV['TENANT'] || current_tenant || default_tenant
+      end
+
+      def tenants_source
+        ActiveRecord::Base.connection_handler.tenants_source
+      end
+
+    end
+
+  end
+end
+

data/lib/motel/multi_tenant.rb

@@ -0,0 +1,53 @@
+module Motel
+  module MultiTenant
+    extend ActiveSupport::Concern
+
+    included do
+
+      mattr_accessor :motel, instance_writer: false
+      self.default_connection_handler = ConnectionAdapters::ConnectionHandler.new
+      self.motel = Manager
+
+    end
+
+    module ClassMethods
+
+      def establish_connection(config)
+        resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(motel.tenants)
+        spec = resolver.spec(config)
+        connection_handler.establish_connection (ENV['TENANT'] || self.name), spec
+      end
+
+      def connection_pool
+        connection_handler.retrieve_connection_pool(current_tenant)
+      end
+
+      def retrieve_connection
+        connection_handler.retrieve_connection(current_tenant)
+      end
+
+      def connected?
+        connection_handler.connected?(current_tenant)
+      end
+
+      def remove_connection(tenant_name = current_tenant)
+        connection_handler.remove_connection(tenant_name)
+      end
+
+      def arel_engine
+        ActiveRecord::Base
+      end
+
+      def current_tenant
+        motel.determines_tenant or raise Motel::NoCurrentTenantError
+      end
+
+    end
+  end
+
+end
+
+ActiveSupport.on_load(:active_record) do
+  include Motel::MultiTenant
+end
+

data/lib/motel/railtie.rb

@@ -0,0 +1,63 @@
+require 'active_support/ordered_options'
+require 'motel/manager'
+require 'rails'
+
+module Motel
+
+  class Railtie < Rails::Railtie
+    INIT_TO_DELETE = %w(active_record.initialize_database active_record.set_reloader_hooks)
+
+    config.motel = ActiveSupport::OrderedOptions.new
+
+    rake_tasks do
+      namespace :db do
+        task :load_config do
+          Motel::Manager.tenants_source_configurations(
+            Rails.application.config.motel.tenants_source_configurations
+          )
+
+          Motel::Manager.current_tenant = "ActiveRecord::Base"
+
+          ActiveRecord::Tasks::DatabaseTasks.database_configuration = Motel::Manager.tenants
+          ActiveRecord::Tasks::DatabaseTasks.env = Motel::Manager.determines_tenant
+        end
+      end
+    end
+
+    ActiveRecord::Railtie.initializers.delete_if do |i|
+      INIT_TO_DELETE.include?(i.name)
+    end
+
+    initializer "motel.general_configuration" do
+      motel_config = Rails.application.config.motel
+
+      Motel::Manager.nonexistent_tenant_page = motel_config.nonexistent_tenant_page || 'public/404.html'
+      Motel::Manager.admission_criteria = motel_config.admission_criteria
+      Motel::Manager.default_tenant = motel_config.default_tenant
+      Motel::Manager.current_tenant = motel_config.current_tenant
+      Motel::Manager.tenants_source_configurations(motel_config.tenants_source_configurations)
+    end
+
+    initializer "motel.configure_middleware" do |app|
+      unless Rails.application.config.motel.disable_middleware
+        app.config.middleware.insert_before ActiveRecord::Migration::CheckPending, Lobby
+      end
+    end
+
+    initializer "active_record.set_reloader_hooks" do |app|
+      hook = app.config.reload_classes_only_on_change ? :to_prepare : :to_cleanup
+
+      ActiveSupport.on_load(:active_record) do
+        ActionDispatch::Reloader.send(hook) do
+          if ActiveRecord::Base.motel.active_tenants.any?
+            ActiveRecord::Base.clear_reloadable_connections!
+            ActiveRecord::Base.clear_cache!
+          end
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/motel/sources.rb

@@ -0,0 +1,3 @@
+require 'motel/sources/default'
+require 'motel/sources/database'
+require 'motel/sources/redis'

data/lib/motel/sources/database.rb

@@ -0,0 +1,120 @@
+require 'active_record'
+
+module Motel
+  module Sources
+
+    class Database
+
+      attr_accessor :source_spec, :table_name
+
+      def initialize(config = {})
+        @source_spec = config[:source_spec]
+        @table_name  = config[:table_name]
+      end
+
+      def tenants
+        query_result.inject({}) do |hash, tenant|
+          name = tenant.delete('name')
+
+          tenant.each do |field, value|
+            if table[field].respond_to? :column
+              tenant[field] = table[field].column.type_cast(value)
+            end
+          end
+
+          hash[name] = tenant
+          hash
+        end
+      end
+
+      def tenant(name)
+        tenants[name]
+      end
+
+      def tenant?(name)
+        tenants.key?(name)
+      end
+
+      def add_tenant(name, spec)
+        raise ExistingTenantError if tenant?(name)
+
+        spec = spec.merge(:name => name.to_s)
+        spec.delete_if{ |c,v| v.nil? }
+
+        sql = <<-SQL
+          INSERT INTO #{table_name} (#{spec.keys.map{|c| "\`#{c}\`"}.join(',')})
+          VALUES (#{spec.values.map(&:inspect).join(',')})
+        SQL
+
+        connection_pool.with_connection { |conn| conn.execute(sql) }
+      end
+
+      def update_tenant(name, spec)
+        raise NonexistentTenantError unless tenant?(name)
+
+        spec = spec.merge(:name => name.to_s)
+        spec.delete_if{ |c,v| v.nil? }
+
+        sql = <<-SQL
+          UPDATE #{table_name}
+          SET #{spec.map{|c, v| "\`#{c}\` = \"#{v}\""}.join(',')}
+          WHERE name = "#{name}"
+        SQL
+
+        connection_pool.with_connection { |conn| conn.execute(sql) }
+      end
+
+      def delete_tenant(name)
+        if tenant?(name)
+          sql = <<-SQL
+            DELETE FROM #{table_name} WHERE name = "#{name}"
+          SQL
+
+          connection_pool.with_connection { |conn| conn.execute(sql) }
+        end
+      end
+
+      def connection
+        connection_pool.connection
+      end
+
+      private
+
+        def table
+          @table ||= Arel::Table.new(table_name, self)
+        end
+
+        def query
+          @query ||= table.project('*')
+        end
+
+        def query_result
+          connection_pool.with_connection do |conn|
+            conn.select_all(query.to_sql)
+          end
+        end
+
+        def spec
+          @spec ||= begin
+            resolver = Motel::ConnectionAdapters::ConnectionSpecification::Resolver.new
+            resolver.spec(source_spec)
+          end
+        end
+
+        def connection_handler
+          @connection_handler ||= begin
+            handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+            handler.establish_connection self.class, spec
+            handler
+          end
+        end
+
+        def connection_pool
+          connection_handler.retrieve_connection_pool self.class
+        end
+
+    end
+
+  end
+end
+

data/lib/motel/sources/default.rb

@@ -0,0 +1,54 @@
+require 'active_record'
+
+module Motel
+  module Sources
+
+    class Default
+
+      attr_accessor :tenants
+
+      alias :configurations= :tenants=
+
+      def initialize(config = {})
+        @tenants = config[:configurations] || {}
+      end
+
+      def tenant(name)
+        tenants[name]
+      end
+
+      def tenant?(name)
+        tenants.key?(name)
+      end
+
+      def add_tenant(name, spec)
+        raise ExistingTenantError if tenant?(name)
+
+        tenants[name] = keys_to_string(spec)
+      end
+
+      def update_tenant(name, spec)
+        raise NonexistentTenantError unless tenant?(name)
+
+        spec = keys_to_string(spec)
+        tenants[name].merge!(spec)
+      end
+
+      def delete_tenant(name)
+        tenants.delete(name)
+      end
+
+      private
+
+        def keys_to_string(hash)
+          hash = hash.inject({}) do |h, (k, v)|
+            h[k.to_s] = v
+            h
+          end
+        end
+
+    end
+
+  end
+end
+