penthouse 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 89e508c4ecb8d4e9aaebf054202f87e0ef171578
+  data.tar.gz: d89449c14673b9a0764c82a4711018dc8db85fce
+SHA512:
+  metadata.gz: 3c6cebc9a8e4d0d12331d4d801cbe87866c998c52695c17d5400b8102217f98c117b89bd52dff1eb23be7f09ef8e23827e38f56af4051f28904680d8500e3be0
+  data.tar.gz: 09bacbedcbbe99b6af2165e6501661267a0e6b7735a3234f9ef3c8c00b92385749c2b2ba9971dbe5a0e7a0c2460f46e4890c3352ff22f8fce0a743d6d9e59ee0

data/.gitignore

@@ -0,0 +1,11 @@
+**.DS_Store
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/spec/support/database.yml
+/tmp/

data/.ruby-gemset

@@ -0,0 +1 @@
+ryantownsend-penthouse-rubygem

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+ruby '2.3.0'
+gemspec

data/README.md

@@ -0,0 +1,42 @@
+Penthouse is an alternative to the excellent [Apartment gem](https://github.com/influitive/apartment) – however Penthouse is more of a framework for multi-tenancy than a library, in that it provides less out-of-the-box functionality, but should make for easier customisation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'penthouse'
+```
+
+## Usage
+
+If you're using Rails, you just need to configure an initializer at `config/initializers/penthouse.rb`
+
+```ruby
+require 'penthouse'
+# include the standard Rack app
+require 'penthouse/app'
+# include the automated Sidekiq integration, should you be using it
+require 'penthouse/sidekiq' if defined?(Sidekiq)
+# require the relevant router/runner you wish to use
+require 'penthouse/routers/subdomain_router'
+require 'penthouse/runners/schema_runner'
+
+Penthouse.configure do |config|
+  config.router = Penthouse::Routers::SubdomainRouter
+  config.runner = Penthouse::Runners::SchemaRunner
+end
+
+Rails.application.config.middleware.use Penthouse::App
+```
+
+It's advised that if you want to customise these classes, you do so by sub-classing `Penthouse::App`, `Penthouse::Routers::BaseRouter` and/or `Penthouse::Runners::BaseRunner` within this initializer.
+
+## Dictionary
+
+* **Router** – this class receives a Rack request object and returns an identifier (just a string or symbol) for the tenant.
+* **Runner** – this class receives the identifier (either from the router or manually switching), then looks up the tenant instance and runs the code within it.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ryantownsend/penthouse.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "penthouse"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/penthouse/app.rb

@@ -0,0 +1,37 @@
+#
+# The Penthouse::App class defines a Rack middleware to be included into your
+# stack before your main application is called.
+#
+# @example Typically in Rails you'd use:
+#   Rails.application.config.middleware.use Penthouse::App, router: Penthouse::Routers::BaseRouter
+#
+# This app uses the router to determine the tenant instance, then calls the
+# application within that tenant.
+#
+
+require 'rack/request'
+
+module Penthouse
+  class App
+    attr_accessor :app, :router, :runner
+    private :app=, :router=, :runner=
+
+    # @param app the Rack application
+    # @param router [#call] the class/proc to use as the router
+    # @param runner [#call] the class/proc to use as the runner
+    def initialize(app, router: Penthouse.configuration.router, runner: Penthouse.configuration.runner)
+      self.app = app
+      self.router = router
+      self.runner = runner
+    end
+
+    # @param env [Hash] the environment passed from Rack
+    # @raise [Penthouse::TenantNotFound] if the tenant cannot be found/switched to
+    def call(env)
+      request = Rack::Request.new(env)
+      runner.call(router.call(request)) do
+        app.call(env)
+      end
+    end
+  end
+end

data/lib/penthouse/configuration.rb

@@ -0,0 +1,21 @@
+#
+# The Penthouse::Configuration class contains all configuration options for
+# Penthouse, such as which router to use.
+#
+# @example
+#   Penthouse.configure do |config|
+#     config.router = Penthouse::Routers::BaseRouter
+#     config.runner = Penthouse::Runners::BaseRunner
+#   end
+#
+
+module Penthouse
+  class Configuration
+    attr_accessor :router, :runner
+
+    def initialize(router: nil, runner: nil)
+      self.router = router
+      self.runner = runner
+    end
+  end
+end

data/lib/penthouse/routers/base_router.rb

@@ -0,0 +1,24 @@
+#
+# This class provides an abstract for the router interface. Whilst any Proc
+# could be used, it's safest for people to sub-class to ensure that any future
+# interface changes are catered for.
+#
+# A router class's responsibility in Penthouse is to receive a Rack::Request
+# object from the App instance and return an identifier for that tenant
+#
+
+module Penthouse
+  module Routers
+    class BaseRouter
+
+      # Typically used by the App to return a tenant that can be switched to
+      # @param request [Rack::Request] The request from the Rack app, used to determine the tenant
+      # @return [String, Symbol] A tenant identifier
+      # @raise [Penthouse::TenantNotFound] if the tenant cannot be found/switched to
+      def self.call(request)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/penthouse/routers/subdomain_router.rb

@@ -0,0 +1,18 @@
+#
+# This router will load the tenant name based on a request's sub-domain
+#
+
+module Penthouse
+  module Routers
+    class SubdomainRouter < BaseRouter
+
+      # Determines the tenant identifier based on the sub-domain of the request
+      # @param request [Rack::Request] The request from the Rack app, used to determine the tenant
+      # @return [String, Symbol] A tenant identifier
+      def self.call(request)
+        request.host.split(".").first
+      end
+
+    end
+  end
+end

data/lib/penthouse/runners/base_runner.rb

@@ -0,0 +1,33 @@
+#
+# This class provides an abstract for the runner interface. Whilst any Proc
+# could be used, it's easiest to sub-class then overwrite the #load_tenant
+# method.
+#
+# A runner class's responsibility in Penthouse is to receive an identifier for
+# a tenant and a block, and to execute that block within the tenant
+#
+
+module Penthouse
+  module Runners
+    class BaseRunner
+
+      # @param tenant_identifier [String, Symbol] The identifier for the tenant
+      # @param block [Block] The code to execute within the tenant
+      # @raise [Penthouse::TenantNotFound] if the tenant cannot be switched to
+      def self.call(tenant_identifier, &block)
+        load_tenant(tenant_identifier).call do |tenant|
+          Penthouse.with_tenant(tenant.identifier) do
+            block.yield(tenant)
+          end
+        end
+      end
+
+      # @param tenant_identifier [String, Symbol] The identifier for the tenant
+      # @return [Penthouse::Tenants::BaseTenant] An instance of a tenant
+      # @raise [Penthouse::TenantNotFound] if the tenant cannot be switched to
+      def self.load_tenant(tenant_identifier)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/penthouse/runners/schema_runner.rb

@@ -0,0 +1,20 @@
+#
+# This runner will simply use the SchemaTenant
+#
+
+require_relative './base_runner'
+require_relative '../tenants/schema_tenant'
+
+module Penthouse
+  module Runners
+    class SchemaRunner < BaseRunner
+
+      # @param tenant_identifier [String, Symbol] The identifier for the tenant
+      # @return [Penthouse::Tenants::BaseTenant] An instance of a tenant
+      def self.load_tenant(tenant_identifier)
+        Tenants::SchemaTenant.new(tenant_identifier, tenant_schema: tenant_identifier)
+      end
+
+    end
+  end
+end

data/lib/penthouse/sidekiq/middleware/client.rb

@@ -0,0 +1,8 @@
+module Penthouse::Sidekiq::Middleware
+  class Client
+    def call(worker_class, item, queue, redis_pool=nil)
+      item['tenant'] ||= Penthouse.current_tenant
+      yield
+    end
+  end
+end

data/lib/penthouse/sidekiq/middleware/server.rb

@@ -0,0 +1,9 @@
+module Apartment::Sidekiq::Middleware
+  class Server
+    def call(worker_class, item, queue)
+      Penthouse.router.switch(item['tenant']) do
+        yield
+      end
+    end
+  end
+end

data/lib/penthouse/sidekiq/railtie.rb

@@ -0,0 +1,7 @@
+module Penthouse::Sidekiq
+  class Railtie < Rails::Railtie
+    initializer "penthouse.sidekiq" do
+      Penthouse::Sidekiq::Middleware.run
+    end
+  end
+end

data/lib/penthouse/sidekiq.rb

@@ -0,0 +1,30 @@
+require 'sidekiq'
+require 'penthouse/sidekiq/middleware/client'
+require 'penthouse/sidekiq/middleware/server'
+
+module Penthouse
+  module Sidekiq
+    module Middleware
+
+      def self.run
+        ::Sidekiq.configure_client do |config|
+          config.client_middleware do |chain|
+            chain.add Penthouse::Sidekiq::Middleware::Client
+          end
+        end
+
+        ::Sidekiq.configure_server do |config|
+          config.client_middleware do |chain|
+            chain.add Penthouse::Sidekiq::Middleware::Client
+          end
+
+          config.server_middleware do |chain|
+            chain.insert_before ::Sidekiq::Middleware::Server::RetryJobs, Penthouse::Sidekiq::Middleware::Server
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'penthouse/sidekiq/railtie' if defined?(Rails)

data/lib/penthouse/tenants/base_tenant.rb

@@ -0,0 +1,29 @@
+#
+# This class provides an abstract for the tenant interface. Whilst any Proc
+# could be used, it's safest for people to sub-class to ensure that any future
+# interface changes are catered for.
+#
+# A tenant class's responsibility is to receive a block, around which it should
+# handle switching to the given tenant's configuration, ensuring that if an
+# exception occurs, the configuration is reset back to the global configuration.
+#
+module Penthouse
+  module Tenants
+    class BaseTenant
+      attr_accessor :identifier
+      private :identifier=
+
+      # @param identifier [String, Symbol] An identifier for the tenant
+      def initialize(identifier)
+        self.identifier = identifier
+      end
+
+      # placeholder for the relevant tenant-switching code
+      # @param block [Block] The code to execute within the tenant
+      # @yield [BaseTenant] The current tenant instance
+      def call(&block)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/penthouse/tenants/octopus_schema_tenant.rb

@@ -0,0 +1,28 @@
+#
+# The OctopusSchemaTenant class relies upon Octopus [1], it uses the master
+# database and simply switches the schema search path to allow for isolated
+# data, but low overheads in terms of costs. Note: this means tenants will be
+# sharing a single Postgres instance and therefore performance is shared.
+#
+# [1]: (https://github.com/thiagopradi/octopus)
+#
+
+require_relative './schema_tenant'
+require 'octopus'
+
+module Penthouse
+  module Tenants
+    class OctopusSchemaTenant < SchemaTenant
+
+      # ensures we're on the master Octopus shard, just updates the schema name
+      # with the tenant name
+      # @param block [Block] The code to execute within the schema
+      # @yield [SchemaTenant] The current tenant instance
+      def call(&block)
+        Octopus.using(:master) do
+          super
+        end
+      end
+    end
+  end
+end

data/lib/penthouse/tenants/octopus_shard_tenant.rb

@@ -0,0 +1,36 @@
+#
+# The ShardTenant class relies upon Octopus [1], it switches to a different
+# shard per tenant, allowing for each tenant to have their own database, 100%
+# isolated from other tenants in terms of data and performance.
+#
+# [1]: (https://github.com/thiagopradi/octopus)
+#
+
+require_relative './base_tenant'
+require 'octopus'
+
+module Penthouse
+  module Tenants
+    class OctopusShardTenant < BaseTenant
+      attr_accessor :shard
+      private :shard=
+
+      # @param identifier [String, Symbol] An identifier for the tenant
+      # @param shard [String, Symbol] the configured Octopus shard to use for this tenant
+      def initialize(identifer, shard:)
+        super(identifier)
+        self.shard = shard
+        freeze
+      end
+
+      # switches to the relevant Octopus shard, and processes the block
+      # @param block [Block] The code to execute within the connection to the shard
+      # @yield [ShardTenant] The current tenant instance
+      def call(&block)
+        Octopus.using(shard) do
+          block.yield(self)
+        end
+      end
+    end
+  end
+end

data/lib/penthouse/tenants/schema_tenant.rb

@@ -0,0 +1,45 @@
+#
+# The SchemaTenant class simply switches the schema search path to allow for
+# isolated data, but low overheads in terms of costs. Note: this means tenants
+# will be sharing a single Postgres instance and therefore performance is
+# shared.
+#
+
+require_relative './base_tenant'
+
+module Penthouse
+  module Tenants
+    class SchemaTenant < BaseTenant
+      attr_accessor :tenant_schema, :persistent_schemas, :default_schema
+      private :tenant_schema=, :persistent_schemas=, :default_schema=
+
+      # @param identifier [String, Symbol] An identifier for the tenant
+      # @param tenant_schema [String] your tenant's schema name in Postgres
+      # @param tenant_schema [String] your tenant's schema name in Postgres
+      # @param persistent_schemas [Array<String>] The schemas you always want in the search path
+      # @param default_schema [String] The global schema name, usually 'public'
+      def initialize(identifier, tenant_schema:, persistent_schemas: ["shared_extensions"], default_schema: "public")
+        super(identifier)
+        self.tenant_schema = tenant_schema
+        self.persistent_schemas = Array(persistent_schemas).flatten
+        self.default_schema = default_schema
+        freeze
+      end
+
+      # ensures we're on the master Octopus shard, just updates the schema name
+      # with the tenant name
+      # @param block [Block] The code to execute within the schema
+      # @yield [SchemaTenant] The current tenant instance
+      def call(&block)
+        begin
+          # set the search path to include the tenant
+          ActiveRecord::Base.connection.schema_search_path = persistent_schemas.unshift(tenant_schema).join(", ")
+          block.yield(self)
+        ensure
+          # reset the search path back to the default
+          ActiveRecord::Base.connection.schema_search_path = persistent_schemas.unshift(default_schema).join(", ")
+        end
+      end
+    end
+  end
+end

data/lib/penthouse/version.rb

@@ -0,0 +1,3 @@
+module Penthouse
+  VERSION = "0.1.0"
+end

data/lib/penthouse.rb

@@ -0,0 +1,61 @@
+require "penthouse/version"
+require "penthouse/configuration"
+require "penthouse/routers/base_router"
+require "penthouse/runners/base_runner"
+
+module Penthouse
+  class TenantNotFound < RuntimeError; end
+
+  class << self
+    # Retrieves the currently active tenant identifier
+    # @return [String, Symbol] the current tenant name
+    def tenant
+      Thread.current[:tenant]
+    end
+
+    # Sets the currently active tenant identifier
+    # @param tenant_identifier [String, Symbol] the identifier for the tenant
+    def tenant=(tenant_identifier)
+      Thread.current[:tenant] = tenant_identifier
+    end
+
+    # Similar to Penthouse.tenant=, except this will switch back after the given
+    # block has finished executing
+    # @param tenant_identifier [String, Symbol] the identifier for the tenant
+    # @param default_tenant [String, Symbol] the identifier for the tenant to return to
+    # @param block [Block] the code to execute
+    # @yield [String, Symbol] the identifier for the tenant
+    def with_tenant(tenant_identifier, default_tenant: tenant, &block)
+      self.tenant = tenant_identifier
+      block.yield(tenant_identifier)
+    ensure
+      self.tenant = default_tenant
+    end
+
+    # Executes the given block of code within a given tenant
+    # @param tenant_identifier [String, Symbol] the identifier for the tenant
+    # @param runner [Penthouse::Runners::BaseRunner] an optional runner to use, defaults to the one configured
+    # @param block [Block] the code to execute
+    def switch(tenant_identifier, runner: configuration.runner, &block)
+      runner.call(tenant_identifier, &block)
+    end
+
+    # Allows you to configure the router of Penthouse
+    # @yield [Penthouse::Configuration]
+    def configure(&block)
+      # allow the configuration by the block
+      block.yield(self.configuration)
+      # prevent modification of configuration once set
+      self.configuration.freeze
+    end
+
+    # Returns the current configuration of Penthouse
+    # @return [Penthouse::Configuration]
+    def configuration
+      @configuration ||= Configuration.new(
+        router: Routers::BaseRouter,
+        runner: Runners::BaseRunner
+      )
+    end
+  end
+end

data/penthouse.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'penthouse/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'penthouse'
+  spec.version       = Penthouse::VERSION
+  spec.authors       = ['Ryan Townsend']
+  spec.email         = ['ryan@ryantownsend.co.uk']
+
+  spec.summary       = %q{Multi-tenancy framework. Out of the box, supports Postgres schemas and per-tenant databases}
+  spec.homepage      = 'https://github.com/ryantownsend/penthouse'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'bundler', '~> 1.11'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'yard', '~> 0.8.7.6'
+  # testing
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
+  spec.add_development_dependency 'simplecov', '~> 0.11.2'
+  # web
+  spec.add_development_dependency 'rack', '~> 1.6.4'
+  # db
+  spec.add_development_dependency 'ar-octopus', '~> 0.8.6'
+  spec.add_development_dependency 'activerecord', '~> 4.2.6'
+  spec.add_development_dependency 'pg'
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: penthouse
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Townsend
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+- !ruby/object:Gem::Dependency
+  name: ar-octopus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ryan@ryantownsend.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/penthouse.rb
+- lib/penthouse/app.rb
+- lib/penthouse/configuration.rb
+- lib/penthouse/routers/base_router.rb
+- lib/penthouse/routers/subdomain_router.rb
+- lib/penthouse/runners/base_runner.rb
+- lib/penthouse/runners/schema_runner.rb
+- lib/penthouse/sidekiq.rb
+- lib/penthouse/sidekiq/middleware/client.rb
+- lib/penthouse/sidekiq/middleware/server.rb
+- lib/penthouse/sidekiq/railtie.rb
+- lib/penthouse/tenants/base_tenant.rb
+- lib/penthouse/tenants/octopus_schema_tenant.rb
+- lib/penthouse/tenants/octopus_shard_tenant.rb
+- lib/penthouse/tenants/schema_tenant.rb
+- lib/penthouse/version.rb
+- penthouse.gemspec
+homepage: https://github.com/ryantownsend/penthouse
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Multi-tenancy framework. Out of the box, supports Postgres schemas and per-tenant
+  databases
+test_files: []
+has_rdoc: