ros-apartment 2.3.0.alpha1

data/lib/apartment/elevators/subdomain.rb

@@ -0,0 +1,62 @@
+require 'apartment/elevators/generic'
+require 'public_suffix'
+
+module Apartment
+  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, ignore_private: true).trd || '').split('.')
+      end
+    end
+  end
+end

data/lib/apartment/migrator.rb

@@ -0,0 +1,51 @@
+require 'apartment/tenant'
+
+module Apartment
+  module Migrator
+
+    extend self
+
+    # Migrate to latest
+    def migrate(database)
+      Tenant.switch(database) do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+
+        migration_scope_block = -> (migration) { ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope) }
+
+        if activerecord_below_5_2?
+          ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, version, &migration_scope_block)
+        else
+          ActiveRecord::Base.connection.migration_context.migrate(version, &migration_scope_block)
+        end
+      end
+    end
+
+    # Migrate up/down to a specific version
+    def run(direction, database, version)
+      Tenant.switch(database) do
+        if activerecord_below_5_2?
+          ActiveRecord::Migrator.run(direction, ActiveRecord::Migrator.migrations_paths, version)
+        else
+          ActiveRecord::Base.connection.migration_context.run(direction, version)
+        end
+      end
+    end
+
+    # rollback latest migration `step` number of times
+    def rollback(database, step = 1)
+      Tenant.switch(database) do
+        if activerecord_below_5_2?
+          ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
+        else
+          ActiveRecord::Base.connection.migration_context.rollback(step)
+        end
+      end
+    end
+
+    private
+
+    def activerecord_below_5_2?
+      ActiveRecord.version.release < Gem::Version.new('5.2.0')
+    end
+  end
+end

data/lib/apartment/railtie.rb

@@ -0,0 +1,67 @@
+require 'rails'
+require 'apartment/tenant'
+require 'apartment/reloader'
+
+module Apartment
+  class Railtie < Rails::Railtie
+
+    #
+    #   Set up our default config options
+    #   Do this before the app initializers run so we don't override custom settings
+    #
+    config.before_initialize do
+      Apartment.configure do |config|
+        config.excluded_models = []
+        config.use_schemas = true
+        config.tenant_names = []
+        config.seed_after_create = false
+        config.prepend_environment = false
+        config.append_environment = false
+      end
+
+      ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
+    end
+
+    #   Hook into ActionDispatch::Reloader to ensure Apartment 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
+      next if ARGV.any? { |arg| arg =~ /\Aassets:(?:precompile|clean)\z/ }
+
+      begin
+        Apartment.connection_class.connection_pool.with_connection do
+          Apartment::Tenant.init
+        end
+      rescue ::ActiveRecord::NoDatabaseError
+        # Since `db:create` and other tasks invoke this block from Rails 5.2.0,
+        # we need to swallow the error to execute `db:create` properly.
+      end
+    end
+
+    #
+    #   Ensure rake tasks are loaded
+    #
+    rake_tasks do
+      load 'tasks/apartment.rake'
+      require 'apartment/tasks/enhancements' if Apartment.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?
+
+      # Apartment::Reloader is middleware to initialize things properly on each request to dev
+      initializer 'apartment.init' do |app|
+        app.config.middleware.use Apartment::Reloader
+      end
+
+      # Overrides reload! to also call Apartment::Tenant.init as well so that the reloaded classes have the proper table_names
+      console do
+        require 'apartment/console'
+      end
+    end
+  end
+end

data/lib/apartment/reloader.rb

@@ -0,0 +1,21 @@
+module Apartment
+  class Reloader
+
+    #   Middleware used in development to init Apartment for each request
+    #   Necessary due to code reload (annoying).  When models are reloaded, they no longer have the proper table_name
+    #   That is prepended with the schema (if using postgresql schemas)
+    #   I couldn't figure out how to properly hook into the Rails reload process *after* files are reloaded
+    #   so I've used this in the meantime.
+    #
+    #   Also see apartment/console for the re-definition of reload! that re-init's Apartment
+    #
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Tenant.init
+      @app.call(env)
+    end
+  end
+end

data/lib/apartment/tasks/enhancements.rb

@@ -0,0 +1,57 @@
+# Require this file to append Apartment rake tasks to ActiveRecord db rake tasks
+# Enabled by default in the initializer
+
+module Apartment
+  class RakeTaskEnhancer
+
+    module TASKS
+      ENHANCE_BEFORE = %w(db:drop)
+      ENHANCE_AFTER  = %w(db:migrate db:rollback db:migrate:up db:migrate:down db:migrate:redo db:seed)
+      freeze
+    end
+
+    # This is a bit convoluted, but helps solve problems when using Apartment within an engine
+    # See spec/integration/use_within_an_engine.rb
+
+    class << self
+      def enhance!
+        return unless should_enhance?
+
+        # insert task before
+        TASKS::ENHANCE_BEFORE.each do |name|
+          task = Rake::Task[name]
+          enhance_before_task(task)
+        end
+
+        # insert task after
+        TASKS::ENHANCE_AFTER.each do |name|
+          task = Rake::Task[name]
+          enhance_after_task(task)
+        end
+
+      end
+
+      def should_enhance?
+        Apartment.db_migrate_tenants
+      end
+
+      def enhance_before_task(task)
+        task.enhance([inserted_task_name(task)])
+      end
+
+      def enhance_after_task(task)
+        task.enhance do
+          Rake::Task[inserted_task_name(task)].invoke
+        end
+      end
+
+      def inserted_task_name(task)
+        task.name.sub(/db:/, 'apartment:')
+      end
+
+    end
+
+  end
+end
+
+Apartment::RakeTaskEnhancer.enhance!

data/lib/apartment/tenant.rb

@@ -0,0 +1,66 @@
+require 'forwardable'
+
+module Apartment
+  #   The main entry point to Apartment functions
+  #
+  module Tenant
+
+    extend self
+    extend Forwardable
+
+    def_delegators :adapter, :create, :drop, :switch, :switch!, :current, :each, :reset, :set_callback, :seed, :current_tenant, :default_tenant, :environmentify
+
+    attr_writer :config
+
+    #   Initialize Apartment config options such as excluded_models
+    #
+    def init
+      adapter.process_excluded_models
+    end
+
+    #   Fetch the proper multi-tenant adapter based on Rails config
+    #
+    #   @return {subclass of Apartment::AbstractAdapter}
+    #
+    def adapter
+      Thread.current[:apartment_adapter] ||= begin
+        adapter_method = "#{config[:adapter]}_adapter"
+
+        if defined?(JRUBY_VERSION)
+          if config[:adapter] =~ /mysql/
+            adapter_method = 'jdbc_mysql_adapter'
+          elsif config[:adapter] =~ /postgresql/
+            adapter_method = 'jdbc_postgresql_adapter'
+          end
+        end
+
+        begin
+          require "apartment/adapters/#{adapter_method}"
+        rescue LoadError
+          raise "The adapter `#{adapter_method}` is not yet supported"
+        end
+
+        unless respond_to?(adapter_method)
+          raise AdapterNotFound, "database configuration specifies nonexistent #{config[:adapter]} adapter"
+        end
+
+        send(adapter_method, config)
+      end
+    end
+
+    #   Reset config and adapter so they are regenerated
+    #
+    def reload!(config = nil)
+      Thread.current[:apartment_adapter] = nil
+      @config = config
+    end
+
+    private
+
+    #   Fetch the rails database configuration
+    #
+    def config
+      @config ||= Apartment.connection_config
+    end
+  end
+end

data/lib/apartment/version.rb

@@ -0,0 +1,3 @@
+module Apartment
+  VERSION = "2.3.0.alpha1"
+end

data/lib/generators/apartment/install/USAGE

@@ -0,0 +1,5 @@
+Description:
+  Creates an initializer for apartment.
+
+Example:
+  `rails generate apartment:install`

data/lib/generators/apartment/install/install_generator.rb

@@ -0,0 +1,10 @@
+module Apartment
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    def copy_files
+      template "apartment.rb", File.join("config", "initializers", "apartment.rb")
+    end
+
+  end
+end

data/lib/generators/apartment/install/templates/apartment.rb

@@ -0,0 +1,109 @@
+# You can have Apartment route to the appropriate Tenant by adding some Rack middleware.
+# Apartment can support many different "Elevators" that can take care of this routing to your data.
+# Require whichever Elevator you're using below or none if you have a custom one.
+#
+# require 'apartment/elevators/generic'
+# require 'apartment/elevators/domain'
+require 'apartment/elevators/subdomain'
+# require 'apartment/elevators/first_subdomain'
+# require 'apartment/elevators/host'
+
+#
+# Apartment Configuration
+#
+Apartment.configure do |config|
+
+  # Add any models that you do not want to be multi-tenanted, but remain in the global (public) namespace.
+  # A typical example would be a Customer or Tenant model that stores each Tenant's information.
+  #
+  # config.excluded_models = %w{ Tenant }
+
+  # In order to migrate all of your Tenants you need to provide a list of Tenant names to Apartment.
+  # You can make this dynamic by providing a Proc object to be called on migrations.
+  # This object should yield either:
+  # - an array of strings representing each Tenant name.
+  # - a hash which keys are tenant names, and values custom db config (must contain all key/values required in database.yml)
+  #
+  # config.tenant_names = lambda{ Customer.pluck(:tenant_name) }
+  # config.tenant_names = ['tenant1', 'tenant2']
+  # config.tenant_names = {
+  #   'tenant1' => {
+  #     adapter: 'postgresql',
+  #     host: 'some_server',
+  #     port: 5555,
+  #     database: 'postgres' # this is not the name of the tenant's db
+  #                          # but the name of the database to connect to before creating the tenant's db
+  #                          # mandatory in postgresql
+  #   },
+  #   'tenant2' => {
+  #     adapter:  'postgresql',
+  #     database: 'postgres' # this is not the name of the tenant's db
+  #                          # but the name of the database to connect to before creating the tenant's db
+  #                          # mandatory in postgresql
+  #   }
+  # }
+  # config.tenant_names = lambda do
+  #   Tenant.all.each_with_object({}) do |tenant, hash|
+  #     hash[tenant.name] = tenant.db_configuration
+  #   end
+  # end
+  #
+  config.tenant_names = lambda { ToDo_Tenant_Or_User_Model.pluck :database }
+
+  # PostgreSQL:
+  #   Specifies whether to use PostgreSQL schemas or create a new database per Tenant.
+  #
+  # MySQL:
+  #   Specifies whether to switch databases by using `use` statement or re-establish connection.
+  #
+  # The default behaviour is true.
+  #
+  # config.use_schemas = true
+
+  #
+  # ==> PostgreSQL only options
+
+  # Apartment can be forced to use raw SQL dumps instead of schema.rb for creating new schemas.
+  # Use this when you are using some extra features in PostgreSQL that can't be represented in
+  # schema.rb, like materialized views etc. (only applies with use_schemas set to true).
+  # (Note: this option doesn't use db/structure.sql, it creates SQL dump by executing pg_dump)
+  #
+  # config.use_sql = false
+
+  # There are cases where you might want some schemas to always be in your search_path
+  # e.g when using a PostgreSQL extension like hstore.
+  # Any schemas added here will be available along with your selected Tenant.
+  #
+  # config.persistent_schemas = %w{ hstore }
+
+  # <== PostgreSQL only options
+  #
+
+  # By default, and only when not using PostgreSQL schemas, Apartment will prepend the environment
+  # to the tenant name to ensure there is no conflict between your environments.
+  # This is mainly for the benefit of your development and test environments.
+  # Uncomment the line below if you want to disable this behaviour in production.
+  #
+  # config.prepend_environment = !Rails.env.production?
+
+  # When using PostgreSQL schemas, the database dump will be namespaced, and
+  # apartment will substitute the default namespace (usually public) with the
+  # name of the new tenant when creating a new tenant. Some items must maintain
+  # a reference to the default namespace (ie public) - for instance, a default
+  # uuid generation. Uncomment the line below to create a list of namespaced
+  # items in the schema dump that should *not* have their namespace replaced by
+  # the new tenant
+  #
+  # config.pg_excluded_names = ["uuid_generate_v4"]
+end
+
+# Setup a custom Tenant switching middleware. The Proc should return the name of the Tenant that
+# you want to switch to.
+# Rails.application.config.middleware.use Apartment::Elevators::Generic, lambda { |request|
+#   request.host.split('.').first
+# }
+
+# Rails.application.config.middleware.use Apartment::Elevators::Domain
+Rails.application.config.middleware.use Apartment::Elevators::Subdomain
+# Rails.application.config.middleware.use Apartment::Elevators::FirstSubdomain
+# Rails.application.config.middleware.use Apartment::Elevators::Host