cell 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85f49de6468edae5eac2de24fde919be5eb2af39
-  data.tar.gz: d369c389371266a1cbb0d36268ae76608e9c19e8
+  metadata.gz: 688c58ded30105abbc900e3b92d524549b860812
+  data.tar.gz: e176f9fc293ad7027e53052a09561e26e11f1091
 SHA512:
-  metadata.gz: 6f1f93638f278f5797a2c76d5f4d74a9e8c139462417afad7b38d7ca34f51734c6edd047c3afea25f43082ddb6c99f0148b5002f54f1911b021c7aeb9f373d25
-  data.tar.gz: fc16f2aa775623f1904a11a61edc06a11cbc1d2a4fe3d814f2684f462733d7c64919a9ffe9b841f5b987aa63483b3ef8d7b8ce494f40fdcf2aceb12c011fb4c9
+  metadata.gz: ec3f3baee67fa98496dabaf50554f5bcfe4b230d0ae6c5d5eba21d00635e5cfeaed3156e233cce8e31289ae73a012df07090649c93e7d7b23bbc8aa95384901d
+  data.tar.gz: 89ef969c710585e9afb2b43ae8ef8eecc343213586e38eaae9a6a463aef45fdf4033f044781243e949fec595821c8ac2f0466c8e00d3af30ef65c182e227ed16

data/.gitignore

@@ -3,3 +3,4 @@ log/*.log
 pkg/
 test/dummy/log/*.log
 test/dummy/tmp/
+Gemfile.lock

data/README.md

@@ -1,42 +1,38 @@
 # Cell
 
-Cell provides tenancy and customer isolation for Rails.  It tries to be a
-simpler and more thorough implementation of things like Apartment.
+Cell provides tenancy and customer isolation for Rails.  It tries to be a simpler and more thorough
+implementation of things like Apartment.
 
-The core of Cell was written years ago for Rails 1.2, before Apartment was
-available, and has been developed inside an application ever since.  We've
-aggressively moved it along with the ecosystem, and it still feels more modern
-than other implementations we've used.  We're in the process of making it a
-more generalized gem.  Things are a bit messy now.
+The core of Cell was written years ago for Rails 1.2, before Apartment was available, and has been
+developed inside an application ever since.  We've aggressively moved it along with the ecosystem,
+and it still feels more modern than other implementations we've used.  We're in the process of
+making it a more generalized gem.  Things are a bit messy now.
 
-Cell tries to hook into Rails at the highest level available (e.g., ActiveJob
-instead of a particular job adapter), except for one place: PostgreSQL.  I
-think PostgreSQL is the only widely deployed database with the features required
-to make a reasonable implementation (namely: schemas, roles, row and column
-level security.)
+Cell tries to hook into Rails at the highest level available (e.g., ActiveJob instead of a
+particular job adapter), except for one place: PostgreSQL.  I think PostgreSQL is the only widely
+deployed database with the features required to make a reasonable implementation (namely: schemas,
+roles, row and column level security.)
 
-**Cell aggressively uses Ruby 2.3, PostgreSQL 9.6 and Rails 5**.  This means
-it's probably more appropriate for greenfield projects than bolting on to an
-existing application on an older stack.
+**Cell aggressively uses Ruby 2.3, PostgreSQL 9.6 and Rails 5**.  This means it's probably more
+appropriate for greenfield projects than bolting on to an existing application on an older stack.
 
-Cell moves forward quickly: Don't expect to be able to hang back on an old
-version of Rails and get new features in Cell.  We version accordingly not to
-break things, but we don't back-port to old Rubies, old PostgreSQLs, or old
-Rails versions.
+Cell moves forward quickly: Don't expect to be able to hang back on an old version of Rails and get
+new features in Cell.  We version accordingly not to break things, but we don't back-port to old
+Rubies, old PostgreSQLs, or old Rails versions.  We'll totally change how it works overnight.
 
-The aforementioned Apartment gem looks like perfectly viable solution for
-projects with other constraints.
+The aforementioned Apartment gem looks like perfectly viable solution for projects with other
+constraints.
 
 What it handles:
 
-  [x] ActiveRecord (including migrations and global tables)
-  [ ] ActionController (An integration point for you)
-  [ ] ActiveJob (we're transitioning a Sidekiq adapter to ActiveJob)
-  [ ] ActionMailer (Your URIs will work)
-  [ ] ActionView (Caching is automatically keyed on the Cell)
-  [ ] Redis (optional, via redis-namespace)
-  [x] Data Directories
-  [x] Rake (e.g., tasks which run over each Cell)
+  - [x] ActiveRecord models
+  - [x] Migrations: including shared and global tables
+  - [ ] ActionController: An integration point for you
+  - [x] ActiveJob: Jobs are executed in the proper context
+  - [ ] ActionMailer: Your URIs will work
+  - [ ] ActionView: Caching is automatically keyed on the Cell
+  - [ ] Redis: optional, via redis-namespace
+  - [x] Rake: tasks which run over each Cell
 
 The rest of this README will be updated as the code is extracted.
 
@@ -48,38 +44,118 @@ Add this line to your application's Gemfile:
 gem 'cell'
 ```
 
-And then execute:
+## Tests
 
-    $ bundle
+The application Cell was ripped out of had heavy test-coverage of the functionality Cell provides,
+but at the wrong level (e.g., our model, not the Cell behavior which this became).  It's proven
+impossible to extract anything workable out of these into this gem, but we're working on starting
+from scratch.
 
-Or install it yourself as:
+# How it Works
 
-    $ gem install cell
+The most complicated interaction Cell has with Rails exist with ActiveRecord and its migrations.
+First, what happens in your PostgreSQL database:
 
-## Tests
+Global tables are generated in the default schema, which we'll just call "public", and they stay
+there.  This is what you're used to.
+
+Per-tenant tables are redirected to a schema called "cell_prototype".
+
+Both of these are versioned by 'public.schema_migrations'.  e.g., the prototype and public schemas
+are always considered to be the same version.
+
+When you create a new tenant, the `cell_prototype` schema is copied to a new schema for the tenant,
+and the tenant gets its own 'schema_migrations' table, copied from global.
+
+When you 'db:migrate', un-ran migrations start populating public and cell_prototype, but not
+tenants.
+
+To update existing tenants after a 'db:migrate', you need to run 'cell:db:migrate', which will run
+the migrations needed to bring each tenant up to date.  There are an entire suite of `cell:` rake
+tasks that just run the normal task over each tenant.  Check out `rake -T | grep cell:`
 
-The application Cell was ripped out of had heavy test-coverage of the
-functionality Cell provides, but at the wrong level (e.g., our model, not the
-Cell behavior which this became).  It's proven impossible to extract anything
-workable out of these into this gem, but we're working on starting from
-scratch.
+Cell activates a tenant by adjusting 'schema_search_path'.  The way to use this is
+`YourModel.use {|block }`.  Note that `Cell::Model` ends up aliased to `YourModel`, so
+`Cell::Model.find(...).use` works as well.
 
+There are a lot of tricks Cell has to use re: thread safety and the query cache to make this act
+normally.
+
+In the development mode console, Cell will activate the first tenant for you before you get a REPL.
 
 ## Usage
 
-FIXME: Write this!
+First, read the [How it Works](#how-it-works) section.  You need to know what's going on in case
+something breaks.
+
+Please don't use cell unless you're OK with the idea of digging into the code when things go wrong.
+It's not a drop-in thing yet.
+
+Feel free to open PRs or tickets, though, but I'd rather see "We ended up having to use something
+else because Cell doesn't handle this" than "Cell must handle this".
+
+I'm now committed to keeping the following section up-to-date, as the only source of piss-poor
+documentation.
+
+First, use `cell` in your `Gemfile` as stated earlier.
+
+First, you need a migration that does the following, and only the following:
 
-## Development
+```ruby
+class InitializeCell < ActiveRecord::Migration[5.0]
+  def change
+    initialize_cell!
+  end
+end
+```
+
+Then you need a migration that creates your tenanted model:
+```ruby
+class CreateAccounts < ActiveRecord::Migration[5.0]
+  def change
+    global do
+      create_table :accounts do |t|
+        # ...
+      end
+    end
+  end
+end
+```
+
+We do the configuration in the model so it can be updated if you're running the (very useful)
+clusterfuck that is Spring: your settings will update in development.
+
+```ruby
+class Account < ApplicationRecord
+  extend Cell::Tenant
+end
+```
+
+From there on out, most of the weird shit dealing with Cell will be in migrations.  By default, it
+assumes everything you do in a migration is per-tenant.  If you want to escape this, or create
+shared/global tables, you need to wrap it in a global block.
+
+```ruby
+class TestMigration < ActiveRecord::Migration[5.0]
+  def change
+    # This will exist in each tenant
+    create_table :users do |t|
+      t.string :name, null: false
+    end
+
+    # This is global, and will be shared across all tenants
+    global do
+      create_table :capabilities do |t|
+        t.string :name, null: false
+      end
+    end
+  end
+end
+```
 
-After checking out the repo, run `bin/setup` to install dependencies.
-You can also run `bin/console` for an interactive prompt that will allow you
-to experiment.
+`rake db:migrate` updates the global and prototype schema, `rake cell:db:migrate` will run the
+non-global blocks across all existing tenants.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To
-release a new version, update the version number in `version.rb`, and then
-run `bundle exec rake release`, which will create a git tag for the version,
-push git commits and tags, and push the `.gem` file to
-[rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/Rakefile

@@ -1,7 +1,8 @@
 begin
   require 'bundler/setup'
-rescue LoadError
+rescue LoadError => e
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  puts e.backtrace
 end
 
 require 'rdoc/task'

data/cell.gemspec

@@ -33,5 +33,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "minitest", "~> 5.9.0"
   spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake",    "~> 10.0"
+  spec.add_development_dependency "rake",    "~> 11.0"
 end

data/lib/cell/active_job.rb

@@ -0,0 +1,32 @@
+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

data/lib/cell/clone_schema.rb

@@ -1,39 +1,41 @@
 require 'active_record/schema_migration'
-require 'cell/with_schema'
+require 'cell/meta'
 
 module Cell
   module CloneSchema
-    module_function
-    def clone_schema(con, src, dst)
-      sql = <<~SQL
-        SELECT public.clone_schema(#{con.quote(src)}, #{con.quote(dst)}, true);
+    def self.connection
+      ::ActiveRecord::Base.connection
+    end
+
+
+    def self.clone_schema(src, dst)
+      connection.execute <<~SQL
+        SELECT public.clone_schema(#{connection.quote(src)}, #{connection.quote(dst)}, TRUE)
       SQL
-      con.execute(sql)
     end
 
 
-    def copy_schema_migrations_to(dst, connection:)
-      Cell::WithSchema.with_schema(dst, exclusive: true,
-                                        connection: connection) do
+    def self.copy_schema_migrations_to(dst)
+      Cell::Meta.with_schema(dst, exclusive: true) do
         ::ActiveRecord::SchemaMigration.create_table
       end
 
-      con = connection
-      sql = "INSERT INTO #{con.quote_schema_name(dst)}.schema_migrations " +
-            "SELECT * from schema_migrations"
-      con.execute(sql)
+      connection.execute <<~SQL
+        INSERT INTO #{connection.quote_schema_name(dst)}.schema_migrations
+          SELECT * from schema_migrations
+      SQL
     end
 
 
-    def install_function!(con)
+    def self.install_function!
       @created ||= begin
-        con.execute(function_definition)
+        connection.execute(function_definition)
         true
       end
     end
 
 
-    def function_definition
+    def self.function_definition
       File.read(__FILE__).split(/^__END__$/, 2)[-1]
     end
   end

data/lib/cell/console.rb

@@ -1,25 +1,19 @@
 module Cell
   module Console
-    module_function
-
-    def default_console_tenant
-      return nil unless Rails.env.development? || (ENV['T'] && ENV['T'] != '')
-      Rails.application.eager_load!
-
-      if ENV['T']
-        Cell::Tenant.cell_find(ENV['T']).tap do |r|
-          fail "Couldn't locate tenant: #{ENV['T']}" if r.nil?
-        end
-      elsif Rails.env.development?
-        Cell::Tenant.first
+    def self.default_console_tenant
+      if ENV['T'].present?
+        Cell::Model.cell_find!(ENV['T'])
+      elsif Rails.env.development? && ENV['T'] != ''
+        Cell::Model.first
       end
     end
 
-    def configure!
+    def self.configure!
       if (t = default_console_tenant)
-        ::Cell::Tenant.use(t)
+        ::Cell::Model.set!(t)
       end
     end
-
   end
 end
+
+::Cell::Console.configure!

data/lib/cell/context.rb

@@ -1,46 +1,65 @@
-# TenantContextManager allows switching the "active" tenant
-require 'cell/with_schema'
+require 'cell/meta'
+require 'active_support/callbacks'
 
 module Cell
   module Context
     THREAD_KEY = :'Cell.cell_id'
 
     module ClassMethods
+      def self.extended(cls)
+        cls.include ActiveSupport::Callbacks
+        cls.define_callbacks :set_tenant, :use_tenant
+      end
+
+      def after_set(*args, &block)
+        set_callback(:set_tenant, :after, *args, &block)
+      end
+
+      def around_use(*args, &block)
+        set_callback(:use_tenant, :around, *args, &block)
+      end
+
       def current
         Thread.current[THREAD_KEY]
       end
 
-      def use(tenant, exclusive: false)
-        unless tenant.nil? || tenant.is_a?(Cell::Tenant)
-          fail ArgumentError, "Invalid tenant: #{tenant.inspect}"
-        end
+      def set!(tenant, exclusive: false)
+        ::Cell::Meta.with_schema(tenant.schema_name, exclusive: exclusive)
+        set_current(tenant)
+        tenant.run_callbacks :set_tenant
+        tenant
+      end
 
-        connection = Cell::Tenant.connection
+      def use(tenant, exclusive: false)
+        fail ArgumentError, "block required" unless block_given?
+        saved_tenant = current
 
-        if block_given?
-          saved_tenant = current
-          begin
-            ::Cell::WithSchema.with_schema(tenant.schema_name,
-                                           exclusive: exclusive,
-                                           connection: connection) do
-              set_current(tenant)
-              yield Cell::Tenant.current
+        if tenant
+          ::Cell::Meta.with_schema(tenant.schema_name, exclusive: exclusive) do
+            set_current(tenant)
+            tenant.run_callbacks :use_tenant do
+              yield Cell::Model.current
             end
-          ensure
-            set_current(saved_tenant)
           end
         else
-          ::Cell::WithSchema.with_schema(tenant.schema_name,
-                                         exclusive: exclusive,
-                                         connection: connection)
-          set_current(tenant)
-          tenant
+          ::Cell::Meta.with_global_schema do
+            set_current(nil)
+            yield nil
+          end
         end
+
+        tenant
+      ensure
+        set_current(saved_tenant)
       end
 
       private
-      def set_current(value)
-        Thread.current[THREAD_KEY] = value
+      def set_current(tenant)
+        unless tenant.nil? || tenant.is_a?(Cell::Model)
+          fail ArgumentError, "Invalid tenant: #{tenant.inspect}"
+        end
+
+        Thread.current[THREAD_KEY] = tenant
       end
     end
 
@@ -48,14 +67,16 @@ module Cell
       self.class.use(self, *args, &block)
     end
 
+    def set!(tenant)
+      Cell::Model.set!(tenant)
+    end
+
     def current?
       self.class.current == self
     end
 
     def self.prepended(cls)
-      class << cls
-        prepend ClassMethods
-      end
+      cls.extend(ClassMethods)
     end
   end
 end

data/lib/cell/meta.rb

@@ -0,0 +1,87 @@
+require 'cell/schema'
+require 'active_record/internal_metadata'
+
+module Cell
+  module Meta
+    GLOBAL_KEY = 'Cell.global'
+
+    def self.connection
+      ::ActiveRecord::Base.connection
+    end
+
+    def self.with_schema(new_path, exclusive: false)
+      saved_path = connection.schema_search_path
+      active_path = exclusive ? new_path : "#{new_path},#{saved_path}"
+
+      set_schema_search_path(active_path)
+
+      if block_given?
+        begin
+          yield
+        ensure
+          set_schema_search_path(saved_path)
+        end
+      end
+    end
+
+    def self.set_schema_search_path(path)
+      if path != connection.schema_search_path
+        connection.schema_search_path = path
+        connection.clear_query_cache
+      end
+    end
+
+    def self.global_schema
+      @global_schema ||= ActiveRecord::Base.connection.schema_search_path
+    end
+
+    def self.prototype_schema
+      'cell_prototype'
+    end
+
+    def self.structural_schema
+      "#{prototype_schema}, #{global_schema}"
+    end
+
+    def self.with_global_schema(&block)
+      with_schema(global_schema, exclusive: true, &block)
+    end
+
+    def self.with_prototype_schema(&block)
+      with_schema(prototype_schema, exclusive: true, &block)
+    end
+
+    def self.with_structural_schema(&block)
+      with_schema(structural_schema, exclusive: true, &block)
+    end
+
+    def self.global_tables
+      with_global_schema do
+        (::ActiveRecord::InternalMetadata[GLOBAL_KEY] || '').split(',')
+      end
+    end
+
+    def self.set_global_tables(tables)
+      with_global_schema do
+        table_string = tables.map(&:to_s).sort.uniq.join(',')
+        ::ActiveRecord::InternalMetadata[GLOBAL_KEY] = table_string
+      end
+    end
+
+    def self.add_global_table(name)
+      set_global_tables(global_tables + [name.to_s])
+    end
+
+    def self.remove_global_table(name)
+      set_global_tables(global_tables - [name.to_s])
+    end
+
+    def self.global_model?(m)
+      @model_map ||= global_tables.map do |k|
+        [k, true]
+      end.to_h
+
+      @model_map[m.table_name] || false
+    end
+  end
+end