heroku-schemas 0.0.1

data/features/support/lib/output_buffer.rb

@@ -0,0 +1,26 @@
+require 'stringio'
+ 
+class OutputBuffer
+  def initialize
+    @buffer = StringIO.new
+    activate
+  end
+  
+  def activate
+    $stdout = @buffer
+    self
+  end
+  
+  def to_s
+    @buffer.rewind
+    @buffer.read
+  end
+  
+  def stop
+    OutputBuffer::restore_default
+  end
+  
+  def self.restore_default
+    $stdout = STDOUT
+  end  
+end

data/heroku-schemas.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'heroku-schemas/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'heroku-schemas'
+  s.version     = HerokuSchemas::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Tom Benner']
+  s.email       = ['tombenner@gmail.com']
+  s.homepage    = 'https://github.com/tombenner/heroku-schemas'
+  s.summary = s.description = %q{Run many apps on a single database.}
+
+  s.rubyforge_project = 'heroku-schemas'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_dependency 'heroku', '~> 3.0.0'
+  s.add_dependency 'heroku-api'
+  s.add_dependency 'pg'
+  s.add_dependency 'activerecord', '3.2.0'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'aruba'
+end

data/init.rb

@@ -0,0 +1 @@
+require 'heroku-schemas'

data/lib/heroku-schemas.rb

@@ -0,0 +1,19 @@
+require 'active_record'
+require 'active_support/core_ext'
+require 'heroku-api'
+
+require 'heroku-schemas/database'
+require 'heroku-schemas/current_database'
+require 'heroku-schemas/target_database'
+
+require 'heroku-schemas/schema_command'
+require 'heroku-schemas/drop'
+require 'heroku-schemas/migration'
+require 'heroku-schemas/show'
+
+require 'heroku-schemas/pgbackups'
+require 'heroku-schemas/schema_reference'
+require 'heroku-schemas/schema_utilities'
+require 'heroku-schemas/version'
+require 'heroku/command/base'
+require 'heroku/command/schemas'

data/lib/heroku-schemas/current_database.rb

@@ -0,0 +1,9 @@
+module HerokuSchemas
+  class CurrentDatabase < HerokuSchemas::Database
+    class << self
+      def connection_name
+        'current'
+      end
+    end
+  end
+end

data/lib/heroku-schemas/database.rb

@@ -0,0 +1,63 @@
+module HerokuSchemas
+  class Database < ActiveRecord::Base
+    class << self
+      def connect_to_url(url)
+        ActiveRecord::Base.configurations[connection_name] = url_to_config(url)
+        establish_connection(connection_name)
+        self
+      end
+
+      def url_to_config(url)
+        db = URI.parse(url)
+        { 
+          :adapter  => 'postgresql',
+          :username => db.user,
+          :password => db.password,
+          :port     => db.port,
+          :database => db.path.sub(%r(^/), ''),
+          :host     => db.host
+        }
+      end
+
+      def config_to_url(config)
+        "postgres://#{config[:username]}:#{config[:password]}@#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      end
+
+      def url
+        config_to_url(connection.instance_variable_get(:@config))
+      end
+
+      def execute(sql)
+        connection.execute(sql)
+      end
+
+      def select_values(sql)
+        connection.select_values(sql)
+      end
+
+      def schema_exists?(schema)
+        existing_schemas.include?(schema)
+      end
+
+      def tables_exist?(schema)
+        schema_tables(schema).present?
+      end
+
+      def schema_tables(schema)
+        select_values("SELECT table_name FROM information_schema.tables WHERE table_schema = '#{schema}'")
+      end
+
+      def existing_schemas
+        select_values('SELECT schema_name FROM information_schema.schemata')
+      end
+
+      def create_schema(schema)
+        execute("CREATE SCHEMA #{schema}")
+      end
+
+      def rename_schema(from_schema, to_schema)
+        execute("ALTER SCHEMA #{from_schema} RENAME TO #{to_schema}")
+      end
+    end
+  end
+end

data/lib/heroku-schemas/drop.rb

@@ -0,0 +1,22 @@
+module HerokuSchemas
+  class Drop < SchemaCommand
+    attr_reader :database
+
+    def initialize(options)
+      super(options)
+
+      @string_reference = options[:string_reference]
+      raise 'Context app not provided' if @context_app.blank?
+      raise 'Schema reference not provided' if @string_reference.blank?
+      
+      related_apps = [@context_app, @string_reference.split(':').first].uniq
+      @schema = HerokuSchemas::SchemaReference.new(heroku: @heroku, string_reference: @context_app, related_apps: related_apps)
+      @database = HerokuSchemas::CurrentDatabase.connect_to_url(@schema.database_url)
+    end
+
+    def perform
+      @database.execute("DROP SCHEMA #{@schema.schema} CASCADE")
+      write "Dropped schema #{@schema.database_app}:#{@schema.database_variable}:#{@schema.schema}"
+    end
+  end
+end

data/lib/heroku-schemas/migration.rb

@@ -0,0 +1,109 @@
+module HerokuSchemas
+  class Migration < SchemaCommand
+    attr_reader :current_schema, :current_database
+    attr_reader :target_schema, :target_database
+    attr_reader :backup_url, :context_app
+
+    def initialize(options)
+      super(options)
+      @pgbackups = HerokuSchemas::Pgbackups.new
+
+      @string_reference = options[:string_reference]
+      raise 'Context app not provided' if @context_app.blank?
+      raise 'Schema reference not provided' if @string_reference.blank?
+      
+      related_apps = [@context_app, @string_reference.split(':').first].uniq
+      @current_schema = HerokuSchemas::SchemaReference.new(heroku: @heroku, string_reference: @context_app, related_apps: related_apps)
+      @target_schema = HerokuSchemas::SchemaReference.new(heroku: @heroku, string_reference: @string_reference, related_apps: related_apps)
+
+      @current_database = HerokuSchemas::CurrentDatabase.connect_to_url(@current_schema.database_url)
+      @target_database = HerokuSchemas::TargetDatabase.connect_to_url(@target_schema.database_url)
+    end
+
+    def perform
+      validate_migration
+      if current_schema_has_data?
+        migrate_database
+      else
+        update_database_url
+      end
+    end
+
+    def validate_migration
+      if current_schema == target_schema
+        raise "App (#{context_app}) is already using the target schema (#{target_schema.base_database_url}, #{target_schema.schema})"
+      end
+      if target_schema_has_data?
+        command = "heroku schemas:drop #{target_schema.database_app}:#{target_schema.database_variable}:#{target_schema.schema}"
+        raise "Target schema (#{target_schema.base_database_url}, #{target_schema.schema}) already contains data. Please drop it before proceding by running:\n`#{command}`"
+      end
+    end
+
+    def current_schema_has_data?
+      current_database.existing_schemas.include?(current_schema.schema) && current_database.tables_exist?(current_schema.schema)
+    end
+
+    def target_schema_has_data?
+      target_database.existing_schemas.include?(target_schema.schema) && target_database.tables_exist?(target_schema.schema)
+    end
+
+    def is_migrated?
+      target_database.existing_schemas.include?(target_schema.schema)
+    end
+
+    def migrate_database
+      create_backup_with_target_schema
+      update_database_url
+      create_target_schema_in_target_database
+      import_backup_into_target_database
+    end
+
+    def create_backup_with_target_schema
+      write 'Creating database backup...'
+      current_database.rename_schema(current_schema.schema, target_schema.schema)
+      @backup_url = create_backup(current_schema.database_app, current_schema.database_variable)
+      current_database.rename_schema(target_schema.schema, current_schema.schema)
+    end
+
+    def create_target_schema_in_target_database
+      target_database.create_schema(target_schema.schema)
+    end
+
+    def import_backup_into_target_database
+      write 'Restoring database backup...'
+      restore_from_backup_url
+    end
+
+    # Point DATABASE_URL to the target app's DATABASE_URL, but with the new schema_search_path
+    def update_database_url
+      target_database_url = SchemaUtilities.add_schema_search_path_to_url(target_schema.database_url, target_schema.schema)
+      set_app_database_url(context_app, target_database_url)
+    end
+
+    def create_backup(app, database_variable)
+      args = [database_variable, '--app', app, '--expire'].compact
+      # args = ['HEROKU_POSTGRESQL_CYAN_URL', '--app', 'tom-target-app', '--expire'].compact
+
+      # @pgbackups.app = app
+      # @pgbackups.capture(database_variable, expire: true)
+      Heroku::Command.run('pgbackups:capture', args)
+
+      @pgbackups.app = app
+      @pgbackups.latest_backup_url
+    end
+
+    def restore_from_backup_url
+      args = [target_schema.database_variable, backup_url, '--app', target_schema.database_app, '--confirm', target_schema.database_app]
+      Heroku::Command.run('pgbackups:restore', args)
+    end
+
+    def app_database_url(app)
+      vars = @heroku.get_config_vars(app).body
+      vars['DATABASE_URL']
+    end
+
+    def set_app_database_url(app, url)
+      @heroku.put_config_vars(app, 'DATABASE_URL' => url)
+    end
+  end
+end

data/lib/heroku-schemas/pgbackups.rb

@@ -0,0 +1,18 @@
+require 'heroku/command/pgbackups'
+
+module HerokuSchemas
+  class Pgbackups < Heroku::Command::Pgbackups
+    attr_accessor :app, :args
+    
+    def validate_arguments!
+    end
+
+    def latest_backup
+      pgbackup_client.get_latest_backup
+    end
+
+    def latest_backup_url
+      latest_backup['public_url']
+    end
+  end
+end

data/lib/heroku-schemas/schema_command.rb

@@ -0,0 +1,12 @@
+module HerokuSchemas
+  class SchemaCommand
+    def initialize(options)
+      @heroku = Heroku::API.new(:api_key => ENV['HEROKU_API_KEY'])
+      @context_app = options[:context_app]
+    end
+
+    def write(string)
+      puts string
+    end
+  end
+end

data/lib/heroku-schemas/schema_reference.rb

@@ -0,0 +1,88 @@
+module HerokuSchemas
+  class SchemaReference
+    attr_reader :app, :database_app, :database_variable, :base_database_url, :database_url, :schema
+
+    # String references to schemas can take the following forms:
+    # my_app
+    # my_app:my_schema
+    # my_app:MY_DATABASE_URL:my_schema
+
+    def initialize(options)
+      defaults = {
+        heroku: nil,
+        string_reference: nil,
+        related_apps: []
+      }
+      options.reverse_merge!(defaults)
+      @heroku = options[:heroku]
+      @string_reference = options[:string_reference]
+      @related_apps = options[:related_apps]
+      @database_variable = nil
+      @schema = nil
+
+      raise 'String reference not provided' if @string_reference.blank?
+      configure
+    end
+
+    def configure
+      refs = @string_reference.split(':')
+      raise "Invalid schema reference: #{@string_reference}" unless [1, 2, 3].include?(refs.length)
+      if refs.length == 1
+        @app = refs.first
+      elsif refs.length == 2
+        @app, @schema = refs
+      else
+        @app, @database_variable, @schema = refs
+      end
+
+      app_variables = app_config_variables(@app)
+      @database_variable ||= 'DATABASE_URL'
+      @database_url = app_variables[@database_variable]
+      @schema ||= SchemaUtilities.url_to_schema(@database_url)
+      raise "Database URL not found for database variable #{@database_variable}" if @database_url.blank?
+
+      validation_message = SchemaUtilities.validate_schema(@schema)
+      raise validation_message if validation_message != true
+      
+      @database_url = @base_database_url = get_base_database_url(@database_url)
+      @database_url = "#{@database_url}?schema_search_path=#{@schema}" unless @schema == 'public'
+
+      if @database_variable == 'DATABASE_URL'
+        @related_apps.each do |app|
+          config_variables = app_config_variables(app)
+          database_variable = find_database_variable(config_variables, @base_database_url)
+          if database_variable
+            @database_variable = database_variable
+            @database_app = app
+            break
+          end
+        end
+      end
+      raise "Database variable not found" if @database_variable.blank?
+    end
+
+    def find_database_variable(config_variables, database_url)
+      standardized_database_url = get_base_database_url(database_url)
+      config_variables.each do |name, value|
+        next if name == 'DATABASE_URL'
+        return name if get_base_database_url(value) == standardized_database_url
+      end
+      nil
+    end
+
+    def app_config_variables(app)
+      @heroku.get_config_vars(app).body
+    end
+
+    def get_base_database_url(url)
+      return nil if url.nil?
+      url.split('?').first
+    end
+
+    def ==(schema_reference)
+      return true if self.base_database_url == schema_reference.base_database_url &&
+        self.schema == schema_reference.schema
+      false
+    end
+  end
+end

data/lib/heroku-schemas/schema_utilities.rb

@@ -0,0 +1,45 @@
+module HerokuSchemas
+  class SchemaUtilities
+    class << self
+      def add_schema_search_path_to_url(url, schema)
+        uri = URI(url)
+        params = uri_to_params(uri)
+        
+        # Handle the case of poorly-formed query strings where CGI::parse turns 'pool=20?pool=20'
+        # into {'pool' => ["20?pool=20"]}
+        params.each do |key, value|
+          if value.is_a?(Array) && value.length == 1
+            params[key] = value.first.split('?').first
+          end
+        end
+        
+        params['schema_search_path'] = schema
+        uri.query = params.to_query
+        uri.to_s
+      end
+
+      def app_to_schema(app)
+        app.downcase.gsub(/[^\w_]/, '_')
+      end
+
+      def url_to_schema(url)
+        uri = URI(url)
+        params = uri_to_params(uri)
+        schema = params['schema_search_path'] || 'public'
+        schema = schema.first if schema.is_a?(Array)
+        schema
+      end
+
+      def uri_to_params(uri)
+        uri.query ? CGI::parse(uri.query) : {}
+      end
+
+      def validate_schema(schema)
+        if schema.blank? || schema =~ /[^a-z0-9_]/
+          return "Schema must only contain lowercase letters, numbers and underscores. Provided value: #{schema}"
+        end
+        true
+      end
+    end
+  end
+end