cell 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43577669f0896218fdfe8736d9ff54e35babd8fb
-  data.tar.gz: 6d43c4a530cbb084b5463e4a6b7e44b91e9a35e8
+  metadata.gz: 85f49de6468edae5eac2de24fde919be5eb2af39
+  data.tar.gz: d369c389371266a1cbb0d36268ae76608e9c19e8
 SHA512:
-  metadata.gz: 6efa21a6ff9fb27cc92d920dbb7e8a6f688286fc5cbff29cf5a5bb0e4d8460908ff15becc8de4f758010fd3331b89cad946b8dc7a1752cd8524c9a4acdc4e88c
-  data.tar.gz: 826e2b22a7aed96372b3d855e1b67c08ca98777733d9e7cfd4381b475aba62b41aecf08f2daec4f3a625529dc97262a4934e90b7fbadc6a7892f1809fb2ca5fe
+  metadata.gz: 6f1f93638f278f5797a2c76d5f4d74a9e8c139462417afad7b38d7ca34f51734c6edd047c3afea25f43082ddb6c99f0148b5002f54f1911b021c7aeb9f373d25
+  data.tar.gz: fc16f2aa775623f1904a11a61edc06a11cbc1d2a4fe3d814f2684f462733d7c64919a9ffe9b841f5b987aa63483b3ef8d7b8ce494f40fdcf2aceb12c011fb4c9

data/.gitignore

@@ -1,9 +1,5 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
+.bundle/
+log/*.log
+pkg/
+test/dummy/log/*.log
+test/dummy/tmp/

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Mike Owens
+Copyright (c) 2016 Mike Owens, meter.md llc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,8 +1,44 @@
 # Cell
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/cell`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+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.
+
+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 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.
+
+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)
+
+The rest of this README will be updated as the code is extracted.
 
 ## Installation
 
@@ -20,22 +56,38 @@ Or install it yourself as:
 
     $ gem install cell
 
+## Tests
+
+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.
+
+
 ## Usage
 
-TODO: Write usage instructions here
+FIXME: Write this!
 
 ## Development
 
-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.
+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.
 
-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).
+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
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/cell.
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/metermd/cell.
 
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,2 +1,29 @@
-require "bundler/gem_tasks"
-task :default => :spec
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Testface'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/bin/test

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.expand_path('../../test', __FILE__))
+
+require 'bundler/setup'
+require 'rails/test_unit/minitest_plugin'
+
+Rails::TestUnitReporter.executable = 'bin/test'
+
+exit Minitest.run(ARGV)

data/cell.gemspec

@@ -1,6 +1,5 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$:.push File.expand_path("../lib", __FILE__)
+
 require 'cell/version'
 
 Gem::Specification.new do |spec|
@@ -26,6 +25,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  # The parts of the Rails stack we care about
+  spec.add_dependency "rails",   "~> 5.0.0", ">= 5.0.0.1"
+
+  # Our hard dependency on PostgreSQL
+  spec.add_dependency "pg", "~> 0.18.4"
+
+  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",    "~> 10.0"
 end

data/lib/cell/clone_schema.rb

@@ -0,0 +1,233 @@
+require 'active_record/schema_migration'
+require 'cell/with_schema'
+
+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);
+      SQL
+      con.execute(sql)
+    end
+
+
+    def copy_schema_migrations_to(dst, connection:)
+      Cell::WithSchema.with_schema(dst, exclusive: true,
+                                        connection: connection) 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)
+    end
+
+
+    def install_function!(con)
+      @created ||= begin
+        con.execute(function_definition)
+        true
+      end
+    end
+
+
+    def function_definition
+      File.read(__FILE__).split(/^__END__$/, 2)[-1]
+    end
+  end
+end
+
+# The following function was written by Melvin Davidson, originally based on
+# the work of Emanuel '3manuek', posted at:
+#   https://wiki.postgresql.org/wiki/Clone_schema
+__END__
+-- Function: clone_schema(text, text)
+
+-- DROP FUNCTION clone_schema(text, text);
+
+CREATE OR REPLACE FUNCTION public.clone_schema(
+    source_schema text,
+    dest_schema text,
+    include_recs boolean)
+  RETURNS void AS
+$BODY$
+
+--  This function will clone all sequences, tables, data, views & functions from any existing schema to a new one
+-- SAMPLE CALL:
+-- SELECT clone_schema('public', 'new_schema', TRUE);
+
+DECLARE
+  src_oid          oid;
+  tbl_oid          oid;
+  func_oid         oid;
+  object           text;
+  buffer           text;
+  srctbl           text;
+  default_         text;
+  column_          text;
+  qry              text;
+  dest_qry         text;
+  v_def            text;
+  seqval           bigint;
+  sq_last_value    bigint;
+  sq_max_value     bigint;
+  sq_start_value   bigint;
+  sq_increment_by  bigint;
+  sq_min_value     bigint;
+  sq_cache_value   bigint;
+  sq_log_cnt       bigint;
+  sq_is_called     boolean;
+  sq_is_cycled     boolean;
+  sq_cycled        char(10);
+
+BEGIN
+
+-- Check that source_schema exists
+  SELECT oid INTO src_oid
+    FROM pg_namespace
+   WHERE nspname = quote_ident(source_schema);
+  IF NOT FOUND
+    THEN
+    RAISE NOTICE 'source schema % does not exist!', source_schema;
+    RETURN ;
+  END IF;
+
+  -- Check that dest_schema does not yet exist
+  PERFORM nspname
+    FROM pg_namespace
+   WHERE nspname = quote_ident(dest_schema);
+  IF FOUND
+    THEN
+    RAISE NOTICE 'dest schema % already exists!', dest_schema;
+    RETURN ;
+  END IF;
+
+  EXECUTE 'CREATE SCHEMA ' || quote_ident(dest_schema) ;
+
+  -- Create sequences
+  -- TODO: Find a way to make this sequence's owner is the correct table.
+  FOR object IN
+    SELECT sequence_name::text
+      FROM information_schema.sequences
+     WHERE sequence_schema = quote_ident(source_schema)
+  LOOP
+    EXECUTE 'CREATE SEQUENCE ' || quote_ident(dest_schema) || '.' || quote_ident(object);
+    srctbl := quote_ident(source_schema) || '.' || quote_ident(object);
+
+    EXECUTE 'SELECT last_value, max_value, start_value, increment_by, min_value, cache_value, log_cnt, is_cycled, is_called
+              FROM ' || quote_ident(source_schema) || '.' || quote_ident(object) || ';'
+              INTO sq_last_value, sq_max_value, sq_start_value, sq_increment_by, sq_min_value, sq_cache_value, sq_log_cnt, sq_is_cycled, sq_is_called ;
+
+    IF sq_is_cycled
+      THEN
+        sq_cycled := 'CYCLE';
+    ELSE
+        sq_cycled := 'NO CYCLE';
+    END IF;
+
+    EXECUTE 'ALTER SEQUENCE '   || quote_ident(dest_schema) || '.' || quote_ident(object)
+            || ' INCREMENT BY ' || sq_increment_by
+            || ' MINVALUE '     || sq_min_value
+            || ' MAXVALUE '     || sq_max_value
+            || ' START WITH '   || sq_start_value
+            || ' RESTART '      || sq_min_value
+            || ' CACHE '        || sq_cache_value
+            || sq_cycled || ' ;' ;
+
+    buffer := quote_ident(dest_schema) || '.' || quote_ident(object);
+    IF include_recs
+        THEN
+            EXECUTE 'SELECT setval( ''' || buffer || ''', ' || sq_last_value || ', ' || sq_is_called || ');' ;
+    ELSE
+            EXECUTE 'SELECT setval( ''' || buffer || ''', ' || sq_start_value || ', ' || sq_is_called || ');' ;
+    END IF;
+
+  END LOOP;
+
+-- Create tables
+  FOR object IN
+    SELECT TABLE_NAME::text
+      FROM information_schema.tables
+     WHERE table_schema = quote_ident(source_schema)
+       AND table_type = 'BASE TABLE'
+
+  LOOP
+    buffer := quote_ident(dest_schema) || '.' || quote_ident(object);
+    EXECUTE 'CREATE TABLE ' || buffer || ' (LIKE ' || quote_ident(source_schema) || '.' || quote_ident(object)
+        || ' INCLUDING ALL)';
+
+    IF include_recs
+      THEN
+      -- Insert records from source table
+      EXECUTE 'INSERT INTO ' || buffer || ' SELECT * FROM ' || quote_ident(source_schema) || '.' || quote_ident(object) || ';';
+    END IF;
+
+    FOR column_, default_ IN
+      SELECT column_name::text,
+             REPLACE(column_default::text, source_schema, dest_schema)
+        FROM information_schema.COLUMNS
+       WHERE table_schema = dest_schema
+         AND TABLE_NAME = object
+         AND column_default LIKE 'nextval(%' || quote_ident(source_schema) || '%::regclass)'
+    LOOP
+      EXECUTE 'ALTER TABLE ' || buffer || ' ALTER COLUMN ' || column_ || ' SET DEFAULT ' || default_;
+    END LOOP;
+
+  END LOOP;
+
+--  add FK constraint
+  FOR qry IN
+    SELECT 'ALTER TABLE ' || quote_ident(dest_schema) || '.' || quote_ident(rn.relname)
+                          || ' ADD CONSTRAINT ' || quote_ident(ct.conname) || ' ' || pg_get_constraintdef(ct.oid) || ';'
+      FROM pg_constraint ct
+      JOIN pg_class rn ON rn.oid = ct.conrelid
+     WHERE connamespace = src_oid
+       AND rn.relkind = 'r'
+       AND ct.contype = 'f'
+
+    LOOP
+      EXECUTE qry;
+
+    END LOOP;
+
+
+-- Create views
+  FOR object IN
+    SELECT table_name::text,
+           view_definition
+      FROM information_schema.views
+     WHERE table_schema = quote_ident(source_schema)
+
+  LOOP
+    buffer := dest_schema || '.' || quote_ident(object);
+    SELECT view_definition INTO v_def
+      FROM information_schema.views
+     WHERE table_schema = quote_ident(source_schema)
+       AND table_name = quote_ident(object);
+
+    EXECUTE 'CREATE OR REPLACE VIEW ' || buffer || ' AS ' || v_def || ';' ;
+
+  END LOOP;
+
+-- Create functions
+  FOR func_oid IN
+    SELECT oid
+      FROM pg_proc
+     WHERE pronamespace = src_oid
+
+  LOOP
+    SELECT pg_get_functiondef(func_oid) INTO qry;
+    SELECT replace(qry, source_schema, dest_schema) INTO dest_qry;
+    EXECUTE dest_qry;
+
+  END LOOP;
+
+  RETURN;
+
+END;
+
+$BODY$
+  LANGUAGE plpgsql VOLATILE
+  COST 100;

data/lib/cell/configure.rb

@@ -0,0 +1,70 @@
+require 'cell/context'
+require 'cell/model'
+require 'cell/schema'
+
+module Cell
+  class Configuration
+    attr_accessor :model
+    attr_accessor :identifier
+    attr_accessor :data_directory
+    attr_accessor :sidekiq
+
+    def initialize(model, &block)
+      @model          = model
+      @identifier     = :id
+      @data_directory = nil
+      @sidekiq        = false
+
+      yield self
+      commit!(model)
+    end
+
+    def commit!(model)
+      fail "model class not specified" if model.nil? || ! model.is_a?(Class)
+
+      configure_model!(model)
+      configure_data_directory!(model)
+      configure_sidekiq!(model)
+    end
+
+    private
+
+    def configure_model!(model)
+      ->(identifier) do
+        model.define_singleton_method(:cell_id_column) do
+          identifier
+        end
+      end.call(self.identifier)
+
+      Cell.const_set(:Tenant, model)
+      model.prepend(::Cell::Model)
+      model.prepend(::Cell::Schema)
+      model.prepend(::Cell::Context)
+    end
+
+    def configure_data_directory!(model)
+      if self.data_directory
+        ->(data_directory) do
+          model.define_singleton_method(:data_directory_root) do
+            data_directory
+          end
+        end.call(self.data_directory.to_s)
+        model.prepend(::Cell::DataDirectory)
+      end
+    end
+
+    def configure_sidekiq!(model)
+      if self.sidekiq
+        require 'cell/sidekiq'
+        ::Cell::Sidekiq.configure!
+      end
+    end
+  end
+  private_constant :Configuration
+
+  module_function
+  def configure(model = nil, &block)
+    fail ArgumentError, "model or block required" if model.nil? && !block_given?
+    Configuration.new(model || block.binding.receiver, &block)
+  end
+end

data/lib/cell/console.rb

@@ -0,0 +1,25 @@
+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
+      end
+    end
+
+    def configure!
+      if (t = default_console_tenant)
+        ::Cell::Tenant.use(t)
+      end
+    end
+
+  end
+end

data/lib/cell/context.rb

@@ -0,0 +1,61 @@
+# TenantContextManager allows switching the "active" tenant
+require 'cell/with_schema'
+
+module Cell
+  module Context
+    THREAD_KEY = :'Cell.cell_id'
+
+    module ClassMethods
+      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
+
+        connection = Cell::Tenant.connection
+
+        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
+            end
+          ensure
+            set_current(saved_tenant)
+          end
+        else
+          ::Cell::WithSchema.with_schema(tenant.schema_name,
+                                         exclusive: exclusive,
+                                         connection: connection)
+          set_current(tenant)
+          tenant
+        end
+      end
+
+      private
+      def set_current(value)
+        Thread.current[THREAD_KEY] = value
+      end
+    end
+
+    def use(*args, &block)
+      self.class.use(self, *args, &block)
+    end
+
+    def current?
+      self.class.current == self
+    end
+
+    def self.prepended(cls)
+      class << cls
+        prepend ClassMethods
+      end
+    end
+  end
+end

data/lib/cell/data_directory.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+
+module Cell
+  module DataDirectory
+    module ClassMethods
+      def data_directory_root
+        fail NotImplementedError
+      end
+
+      def data_directory_for_cell_id(cell_id)
+        cell_id = cell_id.to_s.gsub(/[^a-z0-9_]/i, '-')
+        File.join(data_directory_root, cell_id)
+      end
+    end
+
+    def data_directory
+      self.class.data_directory_for_cell_id(cell_id)
+    end
+
+    private
+    def create_data_directory!
+      FileUtils.mkdir_p(data_directory)
+    end
+
+    def update_data_directory!
+      src, dst = cell_id_change_set
+      FileUtils.mv(self.class.data_directory_for_cell_id(src), data_directory)
+    end
+
+    def destroy_data_directory!
+      FileUtils.rm_rf(data_directory)
+    end
+
+    def self.prepended(cls)
+      cls.extend(ClassMethods)
+
+      cls.after_create_commit  :create_data_directory!
+      cls.after_update_commit  :update_data_directory!, if: :cell_id_changed?
+      cls.after_destroy_commit :destroy_data_directory!
+    end
+  end
+end

data/lib/cell/migration.rb

@@ -0,0 +1,114 @@
+#
+# Alright, here's how this works:
+#
+# 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".
+#
+# In global mode:
+#   Each migration is ran twice: once with no explicit schema set, then again
+#   with "tenant_prototype" activated.
+
+require 'cell/schema'
+require 'cell/clone_schema'
+require 'cell/with_schema'
+
+module Cell
+  module Migration
+    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.
+    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)
+
+    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
+    end
+
+    def prototype_schema
+      Cell::Schema.prototype_schema
+    end
+
+    def tenant_schema
+      target.schema_name
+    end
+
+    def target
+      Cell::Tenant.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
+
+
+    def initialize_cell!
+      CloneSchema.install_function!(connection)
+      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) do
+          super
+        end
+      end
+    end
+
+    def global
+      saved = self.global_block
+      self.global_block = true
+      yield
+    ensure
+      self.global_block = saved
+    end
+
+    ActiveRecord::Migration.prepend(self)
+  end
+end

data/lib/cell/model.rb

@@ -0,0 +1,37 @@
+require 'cell/schema'
+require 'cell/data_directory'
+
+module Cell
+  module Model
+    class << self
+      attr_accessor :cls
+    end
+
+    module ClassMethods
+      def cell_id_column
+        fail NotImplementedError
+      end
+
+      def cell_find(cell_id)
+        find_by(cell_id_column => cell_id)
+      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.prepended(cls)
+      cls.extend(ClassMethods)
+    end
+  end
+end

data/lib/cell/railtie.rb

@@ -0,0 +1,17 @@
+module Cell
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'cell/tasks/cell.rake'
+    end
+
+    console do
+      require 'cell/console'
+      Cell::Console.configure!
+    end
+
+    initializer "cell.sanity_check" do
+      require 'cell/sanity_check'
+      Cell::SanityCheck.sanity_check!
+    end
+  end
+end

data/lib/cell/sanity_check.rb

@@ -0,0 +1,66 @@
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module Cell
+  module SanityCheck
+
+    module_function
+    def check_active_record_adapter!
+      pg_base_adapter = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      whitelist = ["PostgreSQLAdapter"]
+      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.
+
+          Whitelist: #{whitelist.inspect}
+          ActiveRecord adapter: #{adapter_name}
+        EOD
+        fail msg
+      end
+    end
+
+
+    def 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:
+
+            Rails.application.config.active_record.schema_format = :sql
+        EOD
+        fail msg
+      end
+    end
+
+    def 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".
+
+          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:
+
+            Rails.application.config.active_record.dump_schemas = "public,cell_prototype"
+        EOD
+        fail msg
+      end
+    end
+
+    def sanity_check!
+      check_active_record_adapter!
+      check_schema_format!
+      check_dump_schemas!
+    end
+  end
+end

data/lib/cell/schema.rb

@@ -0,0 +1,64 @@
+require 'shellwords'
+require 'cell/clone_schema'
+require 'active_record/schema_migration'
+
+module Cell
+  module Schema
+    SCHEMA_PREFIX = 't_'
+    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, '-')
+      end
+    end
+
+    def schema_name
+      self.class.schema_name_for_cell_id(cell_id)
+    end
+
+    private
+    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)
+      end
+    end
+
+    def destroy_schema!
+      con = self.class.connection
+      con.execute \
+        "DROP SCHEMA #{con.quote_schema_name(schema_name)} CASCADE"
+    end
+
+    def update_schema!
+      src, dst = cell_id_change_set
+      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)}"
+    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!
+    end
+  end
+end

data/lib/cell/sidekiq.rb

@@ -0,0 +1,58 @@
+# This middleware passes along a tenant_id from client to server if a tenant
+# is active when a job is spun off.  The server process then activates the
+# proper tenant if it's detected, so jobs are processed under the context of the
+# same tenant that started the job on the client.
+
+
+require 'sidekiq'
+
+module Cell
+  module Sidekiq
+    KEY = 'Cell.cell_id'
+
+    class ClientMiddleware
+      def call(worker, msg, queue, redis_pool)
+        if (current_id = ::Cell.current&.cell_id)
+          msg[KEY] = current_id
+        end
+
+        yield
+        true
+      end
+    end
+
+    class ServerMiddleware
+      def call(worker, msg, queue, &block)
+        if msg.key?(KEY)
+          ::Cell::Tenant.use(::Cell::Tenant.cell_find(msg[KEY]), &block)
+        else
+          ::Cell::Tenant.use(nil, &block)
+        end
+
+        true
+      end
+    end
+
+    module_function
+    def configure!
+      ::Sidekiq.configure_client do |config|
+        config.client_middleware do |chain|
+          chain.add ClientMiddleware
+        end
+      end
+
+      ::Sidekiq.configure_server do |config|
+        # The server can also act as a client by creating more jobs, so we
+        # should configure the client inside the server block.
+        config.client_middleware do |chain|
+          chain.add ClientMiddleware
+        end
+
+        config.server_middleware do |chain|
+          chain.add ServerMiddleware
+        end
+      end
+
+    end
+  end
+end

data/lib/cell/tasks/cell.rake

@@ -0,0 +1,56 @@
+def db_tasks
+  Rake::Task.tasks.select do |t|
+    t.name.start_with?('db:')
+  end
+end
+
+
+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/
+      false
+    else
+      true
+  end
+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|
+        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
+  end
+
+  tenants.each do |t|
+    Cell::Tenant.use(t, &block)
+  end
+end
+
+
+db_tasks.each do |db_task|
+  if wrappable_task?(db_task)
+    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|
+      Rails.application.eager_load!
+      using_each_tenant do |tenant|
+        puts "Running #{db_task.name} for tenant '#{tenant.cell_id}'"
+        Rake::Task[db_task.name].execute
+      end
+    end
+  end
+end

data/lib/cell/version.rb

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

data/lib/cell/with_schema.rb

@@ -0,0 +1,30 @@
+require 'active_record/base'
+
+module Cell
+  module WithSchema
+    module_function
+    def with_schema(new_path, exclusive: false, connection:)
+      saved_path = connection.schema_search_path
+      new_path = connection.quote_schema_name(new_path)
+      active_path = exclusive ? new_path : "#{new_path},#{saved_path}"
+
+      set_schema_search_path(active_path, connection: connection)
+
+      if block_given?
+        begin
+          yield
+        ensure
+          set_schema_search_path(saved_path, connection: connection)
+        end
+      end
+    end
+
+    private \
+    def set_schema_search_path(path, connection:)
+      if path != connection.schema_search_path
+        connection.schema_search_path = path
+        connection.clear_query_cache
+      end
+    end
+  end
+end

data/lib/cell.rb

@@ -1,5 +1,7 @@
-require "cell/version"
+require 'cell/version'
+require 'cell/configure'
 
-module Cell
-  # Your code goes here...
+if defined?(Rails)
+  require 'cell/migration'
+  require 'cell/railtie'
 end

data/lib/dump/tenant_routing_manager.rb

@@ -0,0 +1,25 @@
+# TenantRoutingManager contains methods that can locate URLs and such for
+# a given tenant.
+
+module TenantRoutingManager
+  extend ActiveSupport::Concern
+  
+  class_methods do
+    def slug_from_host(host)
+      if host && (match = host.match(/\A([a-z][a-z0-9-]*)\./))
+        return match[1]
+      end
+      return nil
+    end
+
+    def from_slug(slug)
+      return friendly.find(slug)
+    rescue ActiveRecord::RecordNotFound
+      return nil
+    end
+
+    def from_host(host)
+      from_slug(slug_from_host(host))
+    end
+  end
+end

data/lib/dump/tenant_url_options.rb

@@ -0,0 +1,17 @@
+module TenantUrlOptions
+  module_function \
+  def default_url_options
+    r = {}
+    r[:protocol] = 'https' if Rails.env.production?
+    r[:port] = 3000 unless Rails.env.production?
+    r[:host] = Tenant.current.try(:host)
+    r
+  end
+
+end
+
+class ActionMailer::Base
+  def default_url_options
+    TenantUrlOptions.default_url_options
+  end
+end

metadata

@@ -1,15 +1,63 @@
 --- !ruby/object:Gem::Specification
 name: cell
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Mike Owens
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-01 00:00:00.000000000 Z
+date: 2016-10-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+  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
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.4
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.9.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,9 +100,25 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/test
 - cell.gemspec
 - lib/cell.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/migration.rb
+- lib/cell/model.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/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