cell 0.1.1 → 0.1.2

data/lib/cell/migration.rb

@@ -1,21 +1,95 @@
 #
-# Alright, here's how this works:
+# This is the messiest part of Cell, I think by necessity.
 #
-# A migration has two execution modes, global and targeted.
-
-# "global" is ran with a "db:migrate", which means no Tenant is activated.
-# "targeted" is ran once over each tenant, via "cell:db:migrate".
+# A migration has two execution modes, global and targeted, with correspond to "db:migrate" and
+# "cell:db:migrate"
+#
+# "global" is ran with a "db:migrate", which means no Tenant is activated.  DDL commands here are
+# directed to either 'public' or 'cell_prototype'
+#
+# "targeted" is ran with a tenant activated (cell:db:migrate), and all DDL commands are directed to
+# the current tenant's schema.
 #
-# In global mode:
-#   Each migration is ran twice: once with no explicit schema set, then again
-#   with "tenant_prototype" activated.
+# In 'rails db:migrate' (global mode), we actually execute each migration twice: once with a
+# pass_context set to :global, where ONLY commands in a 'global {}' block are executed, and then
+# with pass_context set to :prototype, where ONLY commands outside of a 'global {}' block are
+# executed.
+#
+# ContextTracker keeps up with this.
 
+require 'cell/meta'
 require 'cell/schema'
 require 'cell/clone_schema'
-require 'cell/with_schema'
+
 
 module Cell
   module Migration
+
+    # OK, ContextTracker keeps up with:
+    #   * The context in which this migration is being ran, e.g. the :global first pass, the
+    #     :prototype second pass, OR the :targeted per tenant pass.
+    #   * If it's in a global block or not, which determines if actions are actually executed
+    #   * If force_execution is set, which is for the benefit of playing back CommandRecorder
+    #     commands.
+    module ContextTracker
+      mattr_accessor :pass_context
+      mattr_accessor :global_block
+      mattr_accessor :force_execution
+
+      def execute_ddl?
+        force_execution ||
+        (pass_context == :global    &&  global_block) ||
+        (pass_context == :prototype && !global_block) ||
+        (pass_context == :target    && !global_block)
+      end
+
+      # When the CommandRecorder's commands are executed, they're rewritten to go through
+      # force_call, because the "effective set of commands" have already been determined by the
+      # CommandRecorder run.
+      def force_call(*args, &block)
+        saved, self.force_execution = self.force_execution, true
+        send(*args, &block)
+      ensure
+        self.force_execution = saved
+      end
+
+      def with_context(context, search_path, exclusive: false)
+        Cell::Meta::with_schema(search_path, exclusive: exclusive) do
+          begin
+            saved, self.pass_context = self.pass_context, context
+            yield
+          ensure
+            self.pass_context = saved
+          end
+        end
+      end
+
+      def global
+        saved, self.global_block = self.global_block, true
+        yield
+      ensure
+        self.global_block = saved
+      end
+    end
+
+
+    # This module intercepts create_table and drop_table, and updates the list of global tables
+    # in ::ActiveRecord::InternalMetadata['cell.global'].
+    module MetadataIntercept
+      def create_table(name, *args, &block)
+        super.tap do
+          ::Cell::Meta.add_global_table(name) if pass_context == :global
+        end
+      end
+
+      def drop_table(name, *args, &block)
+        super.tap do
+          ::Cell::Meta.remove_global_table(name) if pass_context == :global
+        end
+      end
+    end
+
+    # We intercept every method given, and only execute it if appropriate according to execute_ddl?
     def self.intercept(methods)
       methods.each do |method|
         define_method(method) do |*args, &block|
@@ -24,7 +98,8 @@ module Cell
       end
     end
 
-    # This sucks.
+    # This sucks.  In the future, we may want to pull these from
+    # SchemaStatements
     intercept %i(add_belongs_to add_column add_foreign_key add_index
                  add_index_sort_order add_reference add_timestamps
                  change_column change_column_default change_column_null
@@ -38,21 +113,12 @@ module Cell
               %i(enable_extension disable_extension truncate) +
               %i(execute)
 
-    attr_accessor :pass_context
-    attr_accessor :global_block
-
-    def execute_ddl?
-      (pass_context == :global    &&  global_block) ||
-      (pass_context == :prototype && !global_block) ||
-      (pass_context == :target    && !global_block)
-    end
-
     def global_schema
-      Cell::Schema.global_schema
+      Cell::Meta.global_schema
     end
 
     def prototype_schema
-      Cell::Schema.prototype_schema
+      Cell::Meta.prototype_schema
     end
 
     def tenant_schema
@@ -60,28 +126,16 @@ module Cell
     end
 
     def target
-      Cell::Tenant.current
+      Cell::Model.current
     end
 
     def targeted?
       !! target
     end
 
-    def with_context(context, search_path)
-      Cell::WithSchema::with_schema(search_path, connection: connection) do
-        begin
-          saved_context = self.pass_context
-          self.pass_context = context
-          yield
-        ensure
-          self.pass_context = saved_context
-        end
-      end
-    end
-
-
+    # This is our super-special initialization function.
     def initialize_cell!
-      CloneSchema.install_function!(connection)
+      CloneSchema.install_function!
       execute "CREATE SCHEMA #{connection.quote_schema_name(prototype_schema)}"
     end
 
@@ -95,20 +149,53 @@ module Cell
           super
         end
       else
-        with_context(:target, tenant_schema) do
+        with_context(:target, tenant_schema, exclusive: true) do
           super
         end
       end
     end
 
-    def global
-      saved = self.global_block
-      self.global_block = true
-      yield
-    ensure
-      self.global_block = saved
+    ActiveSupport.on_load(:active_record) do
+      ActiveRecord::Migration.prepend(::Cell::Migration::MetadataIntercept)
+      ActiveRecord::Migration.prepend(::Cell::Migration::ContextTracker)
+      ActiveRecord::Migration.prepend(::Cell::Migration)
     end
 
-    ActiveRecord::Migration.prepend(self)
+
+    # Patches to CommandRecorder, which let us roll back.
+    module CommandRecorderFilter
+      # This maybe should've been attr_reader in CommandRecorder
+      def commands=(*)
+        # If this is actually used, we're fucked.
+        fail "The problem with monkey patching is..."
+      end
+
+      def commands
+        @commands.select do |command|
+          command[0]
+        end.map do |command|
+          [:force_call, [command[1], *command[2]], command[3]]
+        end
+      end
+
+      # saves the state of a recorded command with the context it was in.
+      def add_command(command)
+        @commands << [execute_ddl?, *command]
+      end
+
+      # We override #record to proxy through add_command
+      def record(*command, &block)
+        if @reverting
+          add_command inverse_of(*command, &block)
+        else
+          add_command (command << block)
+        end
+      end
+
+      ActiveSupport.on_load(:active_record) do
+        ::ActiveRecord::Migration::CommandRecorder.prepend(::Cell::Migration::ContextTracker)
+        ::ActiveRecord::Migration::CommandRecorder.prepend(::Cell::Migration::CommandRecorderFilter)
+      end
+    end
   end
 end

data/lib/cell/model_extensions.rb

@@ -0,0 +1,85 @@
+# These are added to ActiveRecord::Base, regardless if they're the tenant model or not.
+
+# There are two big tricks here:
+#  1. Assigning a "tenant" attribute to every model that is loaded from the db, or created while a
+#     tenant is active.
+#  2. Making sure the object is validated and saved with the proper tenant activated, even if the
+#     tenant has changed since the object was created
+#
+# So you can load an object from "tenant_a", switch to "tenant_b", and if you save or validate the
+# object, it'll do so while switched to "tenant_a", and then restore.
+
+require 'cell/meta'
+
+module Cell
+  module ModelExtensions
+
+    # Say we have a model 'u', that is from an old Tenant, loading an association like 'u.books'
+    # should swap into u.tenant while fetching.
+    module AssociationExtensions
+      def load_target
+        owner._activate_tenant do
+          super
+        end
+      end
+    end
+
+
+    module ClassMethods
+      def global_model?
+        ::Cell::Meta.global_model?(self)
+      end
+
+      # When a model's schema is lazy-loaded, we want to make sure our view of the DB allows us to
+      # get introspection data.
+      def load_schema!
+        ::Cell::Meta.with_structural_schema do
+          return super
+        end
+      end
+    end
+
+    attr_reader :tenant
+
+    def _assign_tenant
+      unless self.class.global_model?
+        @tenant = Cell::Model.current
+      end
+    end
+
+    def _activate_tenant(&block)
+      if tenant && tenant != ::Cell::Model.current
+        tenant.use(&block)
+      else
+        yield
+      end
+    end
+
+    # undocumented, but makes sure validations are ran in the context of the object's tenant, e.g.,
+    # uniqueness.
+    def run_validations!
+      _activate_tenant do
+        super
+      end
+    end
+
+    def self.prepended(cls)
+      class << cls
+        prepend ClassMethods
+      end
+
+      cls.after_initialize :_assign_tenant
+      cls.around_save :_activate_tenant
+    end
+
+    def self.install!
+      ActiveSupport.on_load(:active_record) do
+        ::ActiveRecord::Base.prepend(::Cell::ModelExtensions)
+        ::ActiveRecord::Associations::Association.prepend(::Cell::ModelExtensions::AssociationExtensions)
+        ::ActiveRecord::Associations::CollectionAssociation.prepend(::Cell::ModelExtensions::AssociationExtensions)
+      end
+    end
+  end
+end
+
+Cell::ModelExtensions.install!

data/lib/cell/railtie.rb

@@ -6,12 +6,26 @@ module Cell
 
     console do
       require 'cell/console'
-      Cell::Console.configure!
     end
 
-    initializer "cell.sanity_check" do
+    config.after_initialize do
+      require 'cell/tenant'
       require 'cell/sanity_check'
-      Cell::SanityCheck.sanity_check!
+      require 'cell/model_extensions'
+      require 'cell/migration'
+      require 'cell/active_job'
     end
   end
+
+
+  def self.const_missing(name)
+    return super unless name == :Model
+
+    Rails.application.eager_load!
+    unless const_defined?(:Model)
+      fail "Eager loaded models to find model, didn't pan out." +
+           "Make sure one of your models has `prepend Cell::Tenant`"
+    end
+    ::Cell::Model
+  end
 end

data/lib/cell/sanity_check.rb

@@ -2,19 +2,16 @@ require 'active_record/connection_adapters/postgresql_adapter'
 
 module Cell
   module SanityCheck
-
-    module_function
-    def check_active_record_adapter!
+    def self.check_active_record_adapter!
       pg_base_adapter = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-      whitelist = ["PostgreSQLAdapter"]
+      whitelist = []
       adapter_name = ActiveRecord::Base.connection.adapter_name
 
       unless ActiveRecord::Base.connection.is_a?(pg_base_adapter) ||
              whitelist.include?(adapter_name)
         msg <<~EOD
-          Cell uses PostgreSQL-specific features that cannot be represented
-          with your adapter.  If your adapter is a PostgreSQL spin-off, please
-          open a pull request.
+          Cell uses PostgreSQL-specific features that cannot be represented with your adapter.  If
+          your adapter is a PostgreSQL spin-off, please open a pull request.
 
           Whitelist: #{whitelist.inspect}
           ActiveRecord adapter: #{adapter_name}
@@ -24,13 +21,12 @@ module Cell
     end
 
 
-    def check_schema_format!
+    def self.check_schema_format!
       if Rails.application.config.active_record.schema_format != :sql
         msg = <<~EOD
-          Cell uses PostgreSQL-specific features that cannot be represented
-          using a schema_format other than :sql.  You need a definititive
-          structure.sql instead of a schema.rb.  You can configure this by
-          adding the following line to your application.rb:
+          Cell uses PostgreSQL-specific features that cannot be represented using a schema_format
+          other than :sql.  You need a definititive structure.sql instead of a schema.rb.  You can
+          configure this by adding the following line to your application.rb:
 
             Rails.application.config.active_record.schema_format = :sql
         EOD
@@ -38,18 +34,16 @@ module Cell
       end
     end
 
-    def check_dump_schemas!
+    def self.check_dump_schemas!
       dump_schemas = Rails.application.config.active_record.dump_schemas
       unless dump_schemas.to_s.match(/\bcell_prototype\b/)
         msg = <<~EOD
-          Cell stores tenant templates in a PostgreSQL schema called
-          "cell_prototype".
+          Cell stores tenant templates in a PostgreSQL schema called "cell_prototype".
 
-          Rails will not dump this schema by default with `db:structure:dump`
-          without explicitly setting `dump_schemas`.
+          Rails will not dump this schema by default with `db:structure:dump` without explicitly
+          setting `dump_schemas`.
 
-          You can configure this properly by adding a line like the following
-          in application.rb:
+          You can configure this properly by adding a line like the following in application.rb:
 
             Rails.application.config.active_record.dump_schemas = "public,cell_prototype"
         EOD
@@ -57,10 +51,14 @@ module Cell
       end
     end
 
-    def sanity_check!
-      check_active_record_adapter!
-      check_schema_format!
-      check_dump_schemas!
+    def self.sanity_check!
+      ActiveSupport.on_load(:active_record) do
+        Cell::SanityCheck.check_active_record_adapter!
+        Cell::SanityCheck.check_schema_format!
+        Cell::SanityCheck.check_dump_schemas!
+      end
     end
   end
 end
+
+::Cell::SanityCheck.sanity_check!

data/lib/cell/schema.rb

@@ -8,16 +8,6 @@ module Cell
     MAX_SCHEMA_NAME_LENGTH = 63 # PostgreSQL baked-in default
     MAX_CELL_ID_SIZE = MAX_SCHEMA_NAME_LENGTH - SCHEMA_PREFIX.size
 
-    module_function \
-    def global_schema
-      @global_schema ||= ActiveRecord::Base.connection.schema_search_path
-    end
-
-    module_function \
-    def prototype_schema
-      'cell_prototype'
-    end
-
     module ClassMethods
       def schema_name_for_cell_id(cell_id)
         SCHEMA_PREFIX + cell_id.to_s.gsub(/[^a-z0-9_]/i, '-')
@@ -32,9 +22,8 @@ module Cell
     def create_schema!
       con = self.class.connection
       con.transaction do
-        Cell::CloneSchema.clone_schema(con, Cell::Schema.prototype_schema,
-                                       schema_name)
-        Cell::CloneSchema.copy_schema_migrations_to(schema_name, connection: con)
+        Cell::CloneSchema.clone_schema(Cell::Meta.prototype_schema, schema_name)
+        Cell::CloneSchema.copy_schema_migrations_to(schema_name)
       end
     end
 

data/lib/cell/tasks/cell.rake

@@ -9,9 +9,8 @@ def wrappable_task?(task)
   fail ArgumentError unless task.name.start_with?('db:')
 
   case task.name
-    when /^db:test\b/, /^db:structure\b/, /^db:schema\b/, /^db:setup\b/,
-         /^db:purge\b/, /^db:reset\b/, /^db:load_config\b/, /^db:create\b/,
-         /^db:drop\b/
+    when /^db:test\b/, /^db:structure\b/, /^db:schema\b/, /^db:setup\b/, /^db:purge\b/,
+         /^db:reset\b/, /^db:load_config\b/, /^db:create\b/, /^db:drop\b/
       false
     else
       true
@@ -20,32 +19,40 @@ end
 
 
 def using_each_tenant(&block)
-  # We have to get the model that included Cell::Tenant
-  require Rails.root.join('config/environment')
-
   tenants = if ENV['T']
     ENV['T'].split(/\s*,\s*/).map do |tenant_id|
-      Cell::Tenant.cell_find(tenant_id).tap do |r|
+      ::Cell::Model.cell_find(tenant_id).tap do |r|
         fail "Unable to load tenant: #{tenant_id}" if r.nil?
       end
     end
   else
-    ::Cell::Tenant.respond_to?(:find_each) ? ::Cell::Tenant.find_each
-                                           : ::Cell::Tenant.each
+    ::Cell::Model.respond_to?(:find_each) ? ::Cell::Model.find_each : ::Cell::Model.each
   end
 
   tenants.each do |t|
-    Cell::Tenant.use(t, &block)
+    Cell::Model.use(t, &block)
+  end
+end
+
+namespace :cell do
+  task :eager => 'environment' do
+    Rails.application.eager_load!
   end
 end
 
 
 db_tasks.each do |db_task|
   if wrappable_task?(db_task)
+    # We need to have the model the user has chosen to be Cell::Model to have
+    # been loaded.  The easy way is to punt and eager_load all rake tasks, but
+    # we'll try to selectively do it for certain tasks by adding the
+    # dependency.
+    task db_task => 'cell:eager'
+
     if db_task.comment
       desc "run `#{db_task.name}' for all tenants, or each in $T=t1,t2,..."
     end
-    task "cell:#{db_task.name}" => ['environment', 'db:load_config'] do |t|
+    task "cell:#{db_task.name}" => 'cell:eager' do |t|
       Rails.application.eager_load!
       using_each_tenant do |tenant|
         puts "Running #{db_task.name} for tenant '#{tenant.cell_id}'"

data/lib/cell/tenant.rb

@@ -0,0 +1,55 @@
+require 'cell/context'
+require 'cell/schema'
+require 'cell/url_options'
+
+module Cell
+  module Tenant
+    class << self
+      attr_accessor :cls
+    end
+
+    module ClassMethods
+      def cell_id_column
+        :id
+      end
+
+      def cell_find(cell_id, finder_method: :find_by)
+        send(finder_method, cell_id_column => cell_id)
+      end
+
+      def cell_find!(cell_id)
+        cell_find(cell_id, finder_method: :find_by!)
+      end
+    end
+
+    def cell_id
+      send(self.class.cell_id_column)
+    end
+
+    def cell_id_changed?
+      !! previous_changes[self.class.cell_id_column]
+    end
+
+    def cell_id_change_set
+      fail "cell_id was not changed" unless cell_id_changed?
+      previous_changes[self.class.cell_id_column]
+    end
+
+    def self.included(model)
+      fail "Use `prepend` instead of `include`."
+    end
+
+    def self.prepended(model)
+      model.extend(ClassMethods)
+
+      if ::Cell.const_defined?(:Model)
+        ::Cell.send(:remove_const, :Model)
+      end
+      ::Cell.const_set(:Model, model)
+
+      model.prepend(::Cell::Schema)
+      model.prepend(::Cell::Context)
+      model.prepend(::Cell::UrlOptions)
+    end
+  end
+end

data/lib/cell/url_options.rb

@@ -0,0 +1,26 @@
+module Cell
+  module UrlOptions
+    def self.prepended(cls)
+      cls.after_set  :change_url_options, if: :has_cell_host?
+      cls.around_use :change_url_options, if: :has_cell_host?
+    end
+
+    def has_cell_host?
+      respond_to?(:cell_host)
+    end
+
+    private
+    def change_url_options(&block)
+      saved = Rails.application.routes.default_url_options[:host]
+      Rails.application.routes.default_url_options[:host] = cell_host
+
+      if block_given?
+        begin
+          yield
+        ensure
+          Rails.application.routes.default_url_options[:host] = saved
+        end
+      end
+    end
+  end
+end

data/lib/cell/version.rb

@@ -1,3 +1,3 @@
 module Cell
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/cell.rb

@@ -1,7 +1,2 @@
 require 'cell/version'
-require 'cell/configure'
-
-if defined?(Rails)
-  require 'cell/migration'
-  require 'cell/railtie'
-end
+require 'cell/railtie' if defined?(Rails)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cell
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Mike Owens
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-08 00:00:00.000000000 Z
+date: 2016-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -78,14 +78,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
 description: 
 email:
 - mike@meter.md
@@ -103,22 +103,20 @@ files:
 - bin/test
 - cell.gemspec
 - lib/cell.rb
+- lib/cell/active_job.rb
 - lib/cell/clone_schema.rb
-- lib/cell/configure.rb
 - lib/cell/console.rb
 - lib/cell/context.rb
-- lib/cell/data_directory.rb
+- lib/cell/meta.rb
 - lib/cell/migration.rb
-- lib/cell/model.rb
+- lib/cell/model_extensions.rb
 - lib/cell/railtie.rb
 - lib/cell/sanity_check.rb
 - lib/cell/schema.rb
-- lib/cell/sidekiq.rb
 - lib/cell/tasks/cell.rake
+- lib/cell/tenant.rb
+- lib/cell/url_options.rb
 - lib/cell/version.rb
-- lib/cell/with_schema.rb
-- lib/dump/tenant_routing_manager.rb
-- lib/dump/tenant_url_options.rb
 homepage: https://github.com/metermd/cell
 licenses:
 - MIT