innkeeper 0.1.0

data/lib/innkeeper/adapters/mysql2_adapter.rb

@@ -0,0 +1,47 @@
+require 'innkeeper/adapters/abstract_adapter'
+require 'digest'
+
+module Innkeeper
+  module Adapters
+    class Mysql2Adapter < AbstractAdapter
+      def switch_tenant(config)
+        difference = current_difference_from(config)
+
+        if difference[:host]
+          connection_switch!(config)
+        else
+          simple_switch(config) if difference[:database]
+        end
+      end
+
+      def create_tenant!(config)
+        Innkeeper.connection.create_database(config[:database], config)
+      end
+
+      def simple_switch(config)
+        Innkeeper.connection.execute("use `#{config[:database]}`")
+      rescue ActiveRecord::StatementInvalid => exception
+        raise_connect_error!(config[:database], exception)
+      end
+
+      def connection_specification_name(config)
+        if Innkeeper.pool_per_config
+          "_innkeeper_#{config.hash}".to_sym
+        else
+          host_hash = Digest::MD5.hexdigest(config[:host] || config[:url] || "127.0.0.1")
+          "_innkeeper_#{host_hash}_#{config[:adapter]}".to_sym
+        end
+      end
+
+      private
+        def database_exists?(database)
+          result = Innkeeper.connection.exec_query(<<-SQL).try(:first)
+            SELECT 1 AS `exists`
+            FROM INFORMATION_SCHEMA.SCHEMATA
+            WHERE SCHEMA_NAME = #{Innkeeper.connection.quote(database)}
+          SQL
+          result.present? && result['exists'] == 1
+        end
+    end
+  end
+end

data/lib/innkeeper/adapters/postgresql_adapter.rb

@@ -0,0 +1,112 @@
+require 'innkeeper/adapters/abstract_adapter'
+require 'digest'
+
+module Innkeeper
+  module Adapters
+    class PostgresqlAdapter < AbstractAdapter
+      # -- ABSTRACT OVERRIDES --
+      def drop(tenant)
+        raise NotImplementedError,
+          "Please use either drop_database or drop_schema for PG adapter"
+      end
+      # -- END ABSTRACT OVERRIDES --
+
+      def drop_database(tenant)
+        # Innkeeper.connection.select_all "select pg_terminate_backend(pg_stat_activity.pid) from pg_stat_activity where datname='#{tenant}' AND state='idle';"
+        self.class.superclass.instance_method(:drop).bind(self).call(tenant)
+      end
+
+      def drop_schema(tenant)
+        previous_tenant = @current
+
+        config = config_for(tenant)
+        difference = current_difference_from(config)
+
+        if difference[:host] || difference[:database]
+          connection_switch!(config)
+        end
+
+        schema = first_schema(config[:schema_search_path]) if config[:schema_search_path]
+
+        Innkeeper.connection.execute(%{DROP SCHEMA "#{schema}" CASCADE}) if schema
+
+        @current = tenant
+      rescue ActiveRecord::StatementInvalid => exception
+        raise TenantNotFound, "Error while dropping schema #{schema} for tenant #{tenant}: #{exception.message}"
+      ensure
+        switch!(previous_tenant) rescue reset
+      end
+
+      def switch_tenant(config)
+        current_config = config_for(@current)
+        difference = config.select{ |k, v| current_config[k] != v }
+
+        # PG doesn't have the ability to switch DB without reconnecting
+        if difference[:host] || difference[:database]
+          connection_switch!(config)
+        else
+          simple_switch(config) if difference[:schema_search_path]
+        end
+      end
+
+      def simple_switch(config)
+        return unless config[:schema_search_path]
+
+        tenant = first_schema(config[:schema_search_path])
+
+        unless Innkeeper.connection.schema_exists?(tenant)
+          raise Innkeeper::TenantNotFound, "Could not find schema #{tenant}"
+        end
+
+        Innkeeper.connection.schema_search_path = config[:schema_search_path]
+      end
+
+      def create_tenant!(config)
+        unless database_exists?(config[:database])
+          Innkeeper.connection.create_database(config[:database], config)
+          connection_switch!(config, without_keys: [:schema_search_path])
+        end
+
+        schema = first_schema(config[:schema_search_path]) if config[:schema_search_path]
+
+        if schema && !schema_exists?(schema)
+          Innkeeper.connection.execute(%{CREATE SCHEMA "#{schema}"})
+        end
+      end
+
+      def connection_specification_name(config)
+        if Innkeeper.pool_per_config
+          "_innkeeper_#{config.hash}".to_sym
+        else
+          host_hash = Digest::MD5.hexdigest(config[:host] || config[:url] || "127.0.0.1")
+          "_innkeeper_#{host_hash}_#{config[:adapter]}_#{config[:database]}".to_sym
+        end
+      end
+
+      private
+        def database_exists?(database)
+          result = Innkeeper.connection.exec_query(<<-SQL).try(:first)
+            SELECT EXISTS(
+              SELECT 1
+              FROM pg_catalog.pg_database
+              WHERE datname = #{Innkeeper.connection.quote(database)}
+            )
+          SQL
+
+          result.present? && result['exists']
+        end
+
+        def schema_exists?(schema)
+          Innkeeper.connection.schema_exists?(schema)
+        end
+
+        def first_schema(search_path)
+          strip_quotes(search_path.split(",").first)
+        end
+
+        def strip_quotes(string)
+          string[0] == '"' ? string[1..-2] : string
+        end
+    end
+  end
+end

data/lib/innkeeper/console.rb

@@ -0,0 +1,12 @@
+# A workaraound to get `reload!` to also call Innkeeper::Tenant.init
+# This is unfortunate, but I haven't figured out how to hook into the reload process *after* files are reloaded
+
+# reloads the environment
+def reload!(print=true)
+  puts "Reloading..." if print
+  # This triggers the to_prepare callbacks
+  ActionDispatch::Callbacks.new(Proc.new {}).call({})
+  # Manually init Innkeeper again once classes are reloaded
+  Innkeeper::Tenant.init
+  true
+end

data/lib/innkeeper/deprecation.rb

@@ -0,0 +1,10 @@
+require 'active_support/deprecation'
+
+module Innkeeper
+  module Deprecation
+
+    def self.warn(message)
+      ActiveSupport::Deprecation.warn message
+    end
+  end
+end

data/lib/innkeeper/elevators/domain.rb

@@ -0,0 +1,20 @@
+require 'innkeeper/elevators/generic'
+
+module Innkeeper
+  module Elevators
+    #   Provides a rack based tenant switching solution based on domain
+    #   Assumes that tenant name should match domain
+    #   Parses request host for second level domain
+    #   eg. example.com       => example
+    #       www.example.bc.ca => example
+    #
+    class Domain < Generic
+
+      def parse_tenant_name(request)
+        return nil if request.host.blank?
+
+        request.host.match(/(www\.)?(?<sld>[^.]*)/)["sld"]
+      end
+    end
+  end
+end

data/lib/innkeeper/elevators/generic.rb

@@ -0,0 +1,32 @@
+require 'rack/request'
+require 'innkeeper/tenant'
+
+module Innkeeper
+  module Elevators
+    #   Provides a rack based tenant switching solution based on request
+    #
+    class Generic
+
+      def initialize(app, processor = nil)
+        @app = app
+        @processor = processor || method(:parse_tenant_name)
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        database = @processor.call(request)
+
+        if database
+          Innkeeper::Tenant.switch(database) { @app.call(env) }
+        else
+          @app.call(env)
+        end
+      end
+
+      def parse_tenant_name(request)
+        raise "Override"
+      end
+    end
+  end
+end

data/lib/innkeeper/elevators/host_hash.rb

@@ -0,0 +1,22 @@
+require 'innkeeper/elevators/generic'
+
+module Innkeeper
+  module Elevators
+    #   Provides a rack based tenant switching solution based on hosts
+    #   Uses a hash to find the corresponding tenant name for the host
+    #
+    class HostHash < Generic
+      def initialize(app, hash = {}, processor = nil)
+        super app, processor
+        @hash = hash
+      end
+
+      def parse_tenant_name(request)
+        raise TenantNotFound,
+          "Cannot find tenant for host #{request.host}" unless @hash.has_key?(request.host)
+
+        @hash[request.host]
+      end
+    end
+  end
+end

data/lib/innkeeper/elevators/subdomain.rb

@@ -0,0 +1,62 @@
+require 'innkeeper/elevators/generic'
+require 'public_suffix'
+
+module Innkeeper
+  module Elevators
+    #   Provides a rack based tenant switching solution based on subdomains
+    #   Assumes that tenant name should match subdomain
+    #
+    class Subdomain < Generic
+      def self.excluded_subdomains
+        @excluded_subdomains ||= []
+      end
+
+      def self.excluded_subdomains=(arg)
+        @excluded_subdomains = arg
+      end
+
+      def parse_tenant_name(request)
+        request_subdomain = subdomain(request.host)
+
+        # If the domain acquired is set to be excluded, set the tenant to whatever is currently
+        # next in line in the schema search path.
+        tenant = if self.class.excluded_subdomains.include?(request_subdomain)
+          nil
+        else
+          request_subdomain
+        end
+
+        tenant.presence
+      end
+
+    protected
+
+      # *Almost* a direct ripoff of ActionDispatch::Request subdomain methods
+
+      # Only care about the first subdomain for the database name
+      def subdomain(host)
+        subdomains(host).first
+      end
+
+      def subdomains(host)
+        host_valid?(host) ? parse_host(host) : []
+      end
+
+      def host_valid?(host)
+        !ip_host?(host) && domain_valid?(host)
+      end
+
+      def ip_host?(host)
+        !/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/.match(host).nil?
+      end
+
+      def domain_valid?(host)
+        PublicSuffix.valid?(host, ignore_private: true)
+      end
+
+      def parse_host(host)
+        (PublicSuffix.parse(host).trd || '').split('.')
+      end
+    end
+  end
+end

data/lib/innkeeper/migrator.rb

@@ -0,0 +1,33 @@
+require 'innkeeper/tenant'
+
+module Innkeeper
+  module Migrator
+
+    extend self
+
+    # Migrate to latest
+    def migrate(database)
+      Tenant.switch(database) do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+
+        ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, version) do |migration|
+          ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope)
+        end
+      end
+    end
+
+    # Migrate up/down to a specific version
+    def run(direction, database, version)
+      Tenant.switch(database) do
+        ActiveRecord::Migrator.run(direction, ActiveRecord::Migrator.migrations_paths, version)
+      end
+    end
+
+    # rollback latest migration `step` number of times
+    def rollback(database, step = 1)
+      Tenant.switch(database) do
+        ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
+      end
+    end
+  end
+end

data/lib/innkeeper/railtie.rb

@@ -0,0 +1,56 @@
+require 'rails'
+require 'innkeeper/tenant'
+require 'innkeeper/resolvers/database'
+
+module Innkeeper
+  class Railtie < Rails::Railtie
+
+    def self.prep
+      Innkeeper.configure do |config|
+        config.excluded_models = []
+        config.force_reconnect_on_switch = false
+        config.tenant_names = []
+        config.seed_after_create = false
+        config.tenant_resolver = Innkeeper::Resolvers::Database
+      end
+
+      ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
+    end
+
+    #
+    #   Set up our default config options
+    #   Do this before the app initializers run so we don't override custom settings
+    #
+    config.before_initialize{ prep }
+
+    #   Hook into ActionDispatch::Reloader to ensure Innkeeper is properly initialized
+    #   Note that this doens't entirely work as expected in Development, because this is called before classes are reloaded
+    #   See the middleware/console declarations below to help with this. Hope to fix that soon.
+    #
+    config.to_prepare do
+      unless ARGV.any? { |arg| arg =~ /\Aassets:(?:precompile|clean)\z/ }
+        Innkeeper::Tenant.init
+        Innkeeper.connection_class.clear_active_connections!
+      end
+    end
+
+    #
+    #   Ensure rake tasks are loaded
+    #
+    rake_tasks do
+      load 'tasks/innkeeper.rake'
+      require 'innkeeper/tasks/enhancements' if Innkeeper.db_migrate_tenants
+    end
+
+    #
+    #   The following initializers are a workaround to the fact that I can't properly hook into the rails reloader
+    #   Note this is technically valid for any environment where cache_classes is false, for us, it's just development
+    #
+    if Rails.env.development?
+      # Overrides reload! to also call Innkeeper::Tenant.init as well so that the reloaded classes have the proper table_names
+      console do
+        require 'innkeeper/console'
+      end
+    end
+  end
+end

data/lib/innkeeper/resolvers/abstract.rb

@@ -0,0 +1,15 @@
+module Innkeeper
+  module Resolvers
+    class Abstract
+      attr_accessor :init_config
+
+      def initialize(init_config)
+        @init_config = init_config.freeze
+      end
+
+      def resolve
+        raise "Cannot use abstract class directly"
+      end
+    end
+  end
+end

data/lib/innkeeper/resolvers/database.rb

@@ -0,0 +1,11 @@
+require 'innkeeper/resolvers/abstract'
+
+module Innkeeper
+  module Resolvers
+    class Database < Abstract
+      def resolve(tenant)
+        init_config.dup.tap{ |c| c[:database] = tenant }
+      end
+    end
+  end
+end