cell 0.1.2 → 0.2.0

data/lib/cell/ext/migration.rb

@@ -0,0 +1,198 @@
+#
+# This is the messiest part of Cell, I think by necessity.
+#
+# 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 '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'
+
+
+module Cell
+  module Ext
+    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)
+          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
+            Meta.add_global_table(name) if pass_context == :global
+          end
+        end
+
+        def drop_table(name, *args, &block)
+          super.tap do
+            Meta.remove_global_table(name) if pass_context == :global
+          end
+        end
+      end
+
+      # We intercept these methods, and only execute if appropriate according to execute_ddl?
+      def self.intercept(methods)
+        methods.each do |method|
+          define_method(method) do |*args, &block|
+            super(*args, &block) if execute_ddl?
+          end
+        end
+      end
+
+      # 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
+                   change_table change_table_comment create_join_table
+                   create_table drop_join_table drop_table
+                   initialize_schema_migrations_table remove_belongs_to
+                   remove_column remove_columns remove_foreign_key remove_index
+                   remove_reference remove_timestamps rename_column
+                   rename_column_indexes rename_index rename_table
+                   rename_table_indexes table_alias_for table_comment) +
+                %i(enable_extension disable_extension truncate) +
+                %i(execute)
+
+      def global_schema
+        Meta.global_schema
+      end
+
+      def prototype_schema
+        Meta.prototype_schema
+      end
+
+      def tenant_schema
+        target.schema_name
+      end
+
+      def target
+        Model.current
+      end
+
+      def targeted?
+        !! target
+      end
+
+      # This is our super-special initialization function.
+      def initialize_cell!
+        CloneSchema.install_function!
+        execute "CREATE SCHEMA #{connection.quote_schema_name(prototype_schema)}"
+      end
+
+      def exec_migration(con, direction)
+        if ! targeted?
+          with_context(:global, global_schema) do
+            super
+          end
+
+          with_context(:prototype, prototype_schema) do
+            super
+          end
+        else
+          with_context(:target, tenant_schema, exclusive: true) do
+            super
+          end
+        end
+      end
+
+      # 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
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Migration.prepend(Cell::Ext::Migration::ContextTracker)
+  ActiveRecord::Migration.prepend(Cell::Ext::Migration::MetadataIntercept)
+  ActiveRecord::Migration.prepend(Cell::Ext::Migration)
+
+  ActiveRecord::Migration::CommandRecorder.prepend(Cell::Ext::Migration::ContextTracker)
+  ActiveRecord::Migration::CommandRecorder.prepend(Cell::Ext::Migration::CommandRecorderFilter)
+end

data/lib/cell/meta.rb

@@ -32,7 +32,8 @@ module Cell
     end
 
     def self.global_schema
-      @global_schema ||= ActiveRecord::Base.connection.schema_search_path
+      # This could be racy?
+      @global_schema ||= ::ActiveRecord::Base.connection.schema_search_path
     end
 
     def self.prototype_schema
@@ -40,7 +41,7 @@ module Cell
     end
 
     def self.structural_schema
-      "#{prototype_schema}, #{global_schema}"
+      "#{prototype_schema},#{global_schema}"
     end
 
     def self.with_global_schema(&block)

data/lib/cell/railtie.rb

@@ -11,21 +11,20 @@ module Cell
     config.after_initialize do
       require 'cell/tenant'
       require 'cell/sanity_check'
-      require 'cell/model_extensions'
-      require 'cell/migration'
-      require 'cell/active_job'
+      require 'cell/ext/active_record'
+      require 'cell/ext/migration'
+      require 'cell/ext/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`"
+      fail "Eager loaded models to find one that uses `include Cell::Tenant`.  Didn't pan out."
     end
-    ::Cell::Model
+
+    Model
   end
 end

data/lib/cell/sanity_check.rb

@@ -3,7 +3,7 @@ require 'active_record/connection_adapters/postgresql_adapter'
 module Cell
   module SanityCheck
     def self.check_active_record_adapter!
-      pg_base_adapter = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      pg_base_adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
       whitelist = []
       adapter_name = ActiveRecord::Base.connection.adapter_name
 
@@ -18,6 +18,8 @@ module Cell
         EOD
         fail msg
       end
+    rescue ActiveRecord::NoDatabaseError
+      # Not our problem
     end
 
 
@@ -43,7 +45,7 @@ module Cell
           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 by adding a line like the following in application.rb:
 
             Rails.application.config.active_record.dump_schemas = "public,cell_prototype"
         EOD
@@ -51,14 +53,11 @@ module Cell
       end
     end
 
-    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!
+ActiveSupport.on_load(:active_record) do
+  Cell::SanityCheck.check_active_record_adapter!
+  Cell::SanityCheck.check_schema_format!
+  Cell::SanityCheck.check_dump_schemas!
+end

data/lib/cell/schema.rb

@@ -8,29 +8,26 @@ module Cell
     MAX_SCHEMA_NAME_LENGTH = 63 # PostgreSQL baked-in default
     MAX_CELL_ID_SIZE = MAX_SCHEMA_NAME_LENGTH - SCHEMA_PREFIX.size
 
-    module ClassMethods
-      def schema_name_for_cell_id(cell_id)
-        SCHEMA_PREFIX + cell_id.to_s.gsub(/[^a-z0-9_]/i, '-')
-      end
+    def self.schema_name_for_cell_id(cell_id)
+      SCHEMA_PREFIX + cell_id.to_s.gsub(/[^a-z0-9_]/i, '-')
     end
 
     def schema_name
-      self.class.schema_name_for_cell_id(cell_id)
+      Schema.schema_name_for_cell_id(cell_id)
     end
 
     private
     def create_schema!
       con = self.class.connection
       con.transaction do
-        Cell::CloneSchema.clone_schema(Cell::Meta.prototype_schema, schema_name)
-        Cell::CloneSchema.copy_schema_migrations_to(schema_name)
+        CloneSchema.clone_schema(Meta.prototype_schema, schema_name)
+        CloneSchema.copy_schema_migrations_to(schema_name)
       end
     end
 
     def destroy_schema!
       con = self.class.connection
-      con.execute \
-        "DROP SCHEMA #{con.quote_schema_name(schema_name)} CASCADE"
+      con.execute "DROP SCHEMA #{con.quote_schema_name(schema_name)} CASCADE"
     end
 
     def update_schema!
@@ -38,13 +35,11 @@ module Cell
       src = self.class.schema_name_for_cell_id(src)
 
       con = self.class.connection
-      con.execute \
-        "ALTER SCHEMA #{con.quote_schema_name(src)} RENAME " +
-         "TO #{con.quote_schema_name(schema_name)}"
+      con.execute "ALTER SCHEMA #{con.quote_schema_name(src)} RENAME " +
+                  "TO #{con.quote_schema_name(schema_name)}"
     end
 
     def self.prepended(cls)
-      cls.extend(ClassMethods)
       cls.after_create_commit  :create_schema!
       cls.after_update_commit  :update_schema!, if: :cell_id_changed?
       cls.after_destroy_commit :destroy_schema!

data/lib/cell/tenant.rb

@@ -4,10 +4,6 @@ require 'cell/url_options'
 
 module Cell
   module Tenant
-    class << self
-      attr_accessor :cls
-    end
-
     module ClassMethods
       def cell_id_column
         :id
@@ -35,21 +31,26 @@ module Cell
       previous_changes[self.class.cell_id_column]
     end
 
-    def self.included(model)
-      fail "Use `prepend` instead of `include`."
+    def self.append_features(cls)
+      cls.prepend(self)
     end
 
-    def self.prepended(model)
-      model.extend(ClassMethods)
+    def self.extend_object(cls)
+      cls.prepend(self)
+    end
 
-      if ::Cell.const_defined?(:Model)
-        ::Cell.send(:remove_const, :Model)
-      end
-      ::Cell.const_set(:Model, model)
+    def self.prepended(model)
+      Cell.assign_model(model)
 
+      model.extend(ClassMethods)
       model.prepend(::Cell::Schema)
       model.prepend(::Cell::Context)
       model.prepend(::Cell::UrlOptions)
     end
   end
+
+  def self.assign_model(model)
+    remove_const(:Model) if const_defined?(:Model)
+    const_set(:Model, model)
+  end
 end

data/lib/cell/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cell
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Mike Owens
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-05 00:00:00.000000000 Z
+date: 2018-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,76 +16,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.0.0.1
+        version: 5.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 5.0.0.1
+        version: 5.2.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.4
+        version: 1.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.4
+        version: 1.1.3
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.9.0
+        version: '5.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.9.0
+        version: '5.11'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '12.3'
 description: 
 email:
 - mike@meter.md
@@ -103,13 +97,13 @@ files:
 - bin/test
 - cell.gemspec
 - lib/cell.rb
-- lib/cell/active_job.rb
 - lib/cell/clone_schema.rb
 - lib/cell/console.rb
 - lib/cell/context.rb
+- lib/cell/ext/active_job.rb
+- lib/cell/ext/active_record.rb
+- lib/cell/ext/migration.rb
 - lib/cell/meta.rb
-- lib/cell/migration.rb
-- lib/cell/model_extensions.rb
 - lib/cell/railtie.rb
 - lib/cell/sanity_check.rb
 - lib/cell/schema.rb
@@ -138,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Provides isolation and tenancy for Rails

data/lib/cell/active_job.rb

@@ -1,32 +0,0 @@
-module Cell
-  module ActiveJob
-    KEY = :'Cell.tenant'
-
-    def serialize
-      if (current_id = ::Cell::Model.current&.cell_id)
-        super.merge(KEY => current_id)
-      else
-        super
-      end
-    end
-
-    def deserialize(job_data)
-      if job_data.key?(KEY)
-        self.cell_tenant = ::Cell::Model.cell_find(job_data[KEY])
-      end
-      super
-    end
-
-    def self.prepended(cls)
-      cls.send(:attr_accessor, :cell_tenant)
-      cls.around_perform do |job, block|
-        ::Cell::Model.use(job.cell_tenant, &block)
-      end
-    end
-  end
-end
-
-
-if defined?(::ActiveJob)
-  ::ActiveJob::Base.prepend(::Cell::ActiveJob)
-end