monkey_butler 1.2.2

data/lib/monkey_butler/databases/cassandra_database.rb

@@ -0,0 +1,69 @@
+require 'uri'
+require 'cql'
+
+module MonkeyButler
+  module Databases
+    class CassandraDatabase < AbstractDatabase
+      attr_reader :client, :keyspace
+
+      class << self
+        def migration_ext
+          ".cql"
+        end
+
+        def exception_class
+          Cql::CqlError
+        end
+      end
+
+      def initialize(url)
+        super(url)
+        options = { host: url.host, port: (url.port || 9042) }
+        @client = Cql::Client.connect(options)
+        @keyspace = url.path[1..-1] # Drop leading slash
+      end
+
+      def migrations_table?
+        client.use('system')
+        rows = client.execute "SELECT columnfamily_name FROM schema_columnfamilies WHERE keyspace_name='#{keyspace}' AND columnfamily_name='schema_migrations'"
+        !rows.empty?
+      end
+
+      def origin_version
+        client.use(keyspace)
+        rows = client.execute("SELECT version FROM schema_migrations WHERE partition_key = 0 ORDER BY version ASC LIMIT 1")
+        rows.empty? ? nil : rows.each.first['version']
+      end
+
+      def current_version
+        client.use(keyspace)
+        rows = client.execute("SELECT version FROM schema_migrations WHERE partition_key = 0 ORDER BY version DESC LIMIT 1")
+        rows.empty? ? nil : rows.each.first['version']
+      end
+
+      def all_versions
+        client.use(keyspace)
+        rows = client.execute("SELECT version FROM schema_migrations WHERE partition_key = 0 ORDER BY version ASC")
+        rows.each.map { |row| row['version'] }
+      end
+
+      def insert_version(version)
+        client.use(keyspace)
+        client.execute "INSERT INTO schema_migrations (partition_key, version) VALUES (0, ?)", version
+      end
+
+      def execute_migration(cql)
+        cql.split(';').each { |statement| client.execute(statement) unless statement.strip.empty? }
+      end
+
+      def drop(keyspaces = [keyspace])
+        keyspaces.each { |keyspace| client.execute "DROP KEYSPACE IF EXISTS #{keyspace}" }
+      end
+
+      def create_migrations_table
+        client.execute "CREATE KEYSPACE IF NOT EXISTS #{keyspace} WITH replication = {'class' : 'SimpleStrategy', 'replication_factor' : 1};"
+        client.execute "CREATE TABLE IF NOT EXISTS #{keyspace}.schema_migrations (partition_key INT, version VARINT, PRIMARY KEY (partition_key, version));"
+      end
+    end
+  end
+end

data/lib/monkey_butler/databases/sqlite_database.rb

@@ -0,0 +1,105 @@
+require 'sqlite3'
+require 'uri'
+
+module MonkeyButler
+  module Databases
+    class SqliteDatabase < AbstractDatabase
+      attr_reader :db, :path
+
+      class << self
+        def create_schema_migrations_sql
+          MonkeyButler::Util.strip_leading_whitespace <<-SQL
+            CREATE TABLE schema_migrations(
+                version INTEGER UNIQUE NOT NULL
+            );
+          SQL
+        end
+
+        def create(url)
+          new(url) do |database|
+            database.db.execute(create_schema_migrations_sql)
+          end
+        end
+
+        def migration_ext
+          ".sql"
+        end
+
+        def exception_class
+          SQLite3::Exception
+        end
+      end
+
+      def initialize(url)
+        super(url)
+        raise ArgumentError, "Must initialize with a URI" unless url.kind_of?(URI)
+        raise ArgumentError, "Must initialize with a sqlite URI" unless url.scheme.nil? || url.scheme == 'sqlite'
+        path = url.path || url.opaque
+        raise ArgumentError, "Must initialize with a sqlite URI that has a path component" unless path
+        @path = path
+        @db = SQLite3::Database.new(path)
+        yield self if block_given?
+      end
+
+      def migrations_table?
+        has_table?('schema_migrations')
+      end
+
+      def origin_version
+        db.get_first_value('SELECT MIN(version) FROM schema_migrations')
+      end
+
+      def current_version
+        db.get_first_value('SELECT MAX(version) FROM schema_migrations')
+      end
+
+      def all_versions
+        db.execute('SELECT version FROM schema_migrations ORDER BY version ASC').map { |row| row[0] }
+      end
+
+      def insert_version(version)
+        db.execute("INSERT INTO schema_migrations(version) VALUES (?)", version)
+      end
+
+      def execute_migration(sql)
+        db.transaction do |db|
+          db.execute_batch(sql)
+        end
+      end
+
+      def drop
+        File.truncate(path, 0) if File.size?(path)
+      end
+
+      def to_s
+        path
+      end
+
+      ####
+      # Outside of abstract interface...
+
+      def dump_to_schema(type, schema_path)
+        sql = MonkeyButler::Util.strip_leading_whitespace <<-SQL
+          SELECT name, sql
+          FROM sqlite_master
+          WHERE sql NOT NULL AND type = '#{type}'
+          ORDER BY name ASC
+        SQL
+        File.open(schema_path, 'a') do |f|
+          db.execute(sql) do |row|
+            name, sql = row
+            next if name =~ /^sqlite/
+            f << "#{sql};\n\n"
+            yield name if block_given?
+          end
+          f.puts
+        end
+      end
+
+      private
+      def has_table?(table)
+        db.get_first_value("SELECT name FROM sqlite_master WHERE type='table' AND name=?", table)
+      end
+    end
+  end
+end

data/lib/monkey_butler/migrations.rb

@@ -0,0 +1,52 @@
+module MonkeyButler
+  class Migrations
+    attr_reader :path, :database
+
+    def initialize(path, database)
+      @path = path
+      @database = database
+      migration_paths = Dir.glob(File.join(path, "*#{database.class.migration_ext}"))
+      @paths_by_version = MonkeyButler::Util.migrations_by_version(migration_paths)
+    end
+
+    def current_version
+      database.migrations_table? ? database.current_version : nil
+    end
+
+    def all_versions
+      @paths_by_version.keys
+    end
+
+    def latest_version
+      all_versions.max
+    end
+
+    def applied_versions
+      database.migrations_table? ? database.all_versions : []
+    end
+
+    def pending_versions
+      (all_versions - applied_versions).sort
+    end
+
+    def pending(&block)
+      pending_versions.inject({}) { |hash, v| hash[v] = self[v]; hash }.tap do |hash|
+        hash.each(&block) if block_given?
+      end
+    end
+
+    def all(&block)
+      all_versions.inject({}) { |hash, v| hash[v] = self[v]; hash }.tap do |hash|
+        hash.each(&block) if block_given?
+      end
+    end
+
+    def up_to_date?
+      pending_versions.empty?
+    end
+
+    def [](version)
+      @paths_by_version[version]
+    end
+  end
+end

data/lib/monkey_butler/project.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+require 'uri'
+
+module MonkeyButler
+  class Project
+    class << self
+      def load(path = Dir.pwd)
+        @project ||= proc do
+          project_path = File.join(path, '.monkey_butler.yml')
+          raise "fatal: Not a monkey_butler repository: no .monkey_butler.yml" unless File.exists?(project_path)
+          options = YAML.load(File.read(project_path))
+          new(options)
+        end.call
+      end
+
+      def set(options)
+        @project = new(options)
+      end
+
+      def clear
+        @project = nil
+      end
+    end
+
+    attr_accessor :name, :config, :database_url, :targets
+
+    def initialize(options = {})
+      options.each { |k,v| send("#{k}=", v) }
+    end
+
+    def database_url=(database_url)
+      @database_url = database_url ? URI(database_url) : nil
+    end
+
+    def database
+      database_url.scheme || 'sqlite'
+    end
+
+    def schema_path
+      "#{name}" + database_class.migration_ext
+    end
+
+    def migrations_path
+      "migrations"
+    end
+
+    def git_url
+      `git config remote.origin.url`.chomp
+    end
+
+    def git_latest_tag
+      git_tag_for_version(nil)
+    end
+    
+    def git_current_branch
+      `git symbolic-ref --short HEAD`.chomp
+    end
+
+    def git_tag_for_version(version)
+      pattern = version && "#{version}*"
+      tag = `git tag -l --sort=-v:refname #{pattern} | head -n 1`.chomp
+      tag.empty? ? nil : tag
+    end
+
+    def git_user_email
+      `git config user.email`.chomp
+    end
+
+    def git_user_name
+      `git config user.name`.chomp
+    end
+
+    def save!(path)
+      project_path = File.join(path, '.monkey_butler.yml')
+      File.open(project_path, 'w') { |f| f << YAML.dump(self.to_hash) }
+    end
+
+    def database_class
+      MonkeyButler::Util.database_named(database)
+    end
+
+    def database_target_class
+      MonkeyButler::Util.target_classes_named(database)[0]
+    end
+
+    def to_hash
+      { "name" => name, "config" => config, "database_url" => database_url.to_s, "targets" => targets }
+    end
+  end
+end

data/lib/monkey_butler/targets/base.rb

@@ -0,0 +1,85 @@
+module MonkeyButler
+  module Targets
+    class Base < Thor
+      include Thor::Actions
+      include MonkeyButler::Actions
+      add_runtime_options!
+
+      class << self
+        def source_root
+          File.join File.dirname(__FILE__), name
+        end
+
+        def name
+          "#{self}".split('::').last.gsub(/Target$/, '').downcase
+        end
+
+        def register_with_cli(cli)
+          # Allows targets a chance to configure the CLI
+          # This is an ideal place to register any options, tweak description, etc.
+        end
+      end
+
+      attr_reader :project, :database, :migrations
+
+      # Target Command
+
+      desc "init", "Initializes the target."
+      def init
+        # Default implementation does nothing
+      end
+
+      desc "new NAME", "Create a new migration"
+      def new(path)
+        # Default implementation does nothing
+      end
+
+      desc "generate", "Generates a platform specific package."
+      def generate
+        # Default implementation does nothing
+      end
+
+      desc "push", "Pushes a built package."
+      def push
+        # Default implementation does nothing
+      end
+
+      desc "push", "Validates the environment."
+      def validate
+        # Default implementation does nothing
+      end
+
+      desc "dump", "Dumps the schema"
+      def dump
+        # Default implementation does nothing
+      end
+
+      desc "load", "Loads the schema"
+      def load
+        # Default implementation does nothing
+      end
+      
+      desc "drop", "Drops all tables and records"
+      def drop
+        # Default implementation does nothing
+      end
+
+      protected
+      def project
+        @project ||= MonkeyButler::Project.load(destination_root)
+      end
+
+      def database
+        @database ||= project.database_class.new(database_url)
+      end
+
+      def database_url
+        (options[:database] && URI(options[:database])) || project.database_url
+      end
+
+      def migrations
+        @migrations ||= MonkeyButler::Migrations.new(project.migrations_path, database)
+      end
+    end
+  end
+end

data/lib/monkey_butler/targets/cassandra/cassandra_target.rb

@@ -0,0 +1,72 @@
+require 'monkey_butler/databases/cassandra_database'
+
+module MonkeyButler
+  module Targets
+    class CassandraTarget < Base
+      def init
+        migration_path = "migrations/" + MonkeyButler::Util.migration_named('create_' + options[:name]) + '.cql'
+        template('create_schema_migrations.cql.erb', migration_path)
+        git_add migration_path
+      end
+
+      def new(name)
+        migration_path = "migrations/" + MonkeyButler::Util.migration_named(name) + '.cql'
+        template('migration.cql.erb', migration_path)
+        git_add migration_path
+      end
+
+      def dump
+        database_url = (options[:database] && URI(options[:database])) || project.database_url
+        @database = MonkeyButler::Databases::CassandraDatabase.new(database_url)
+        fail Error, "Cannot dump database: the database at '#{database_url}' does not have a `schema_migrations` table." unless database.migrations_table?
+        say "Dumping schema from database '#{database_url}'"
+
+        say "Dumping keyspaces '#{keyspaces.join(', ')}'..."
+        describe_statements = keyspaces.map { |keyspace| "describe keyspace #{keyspace};" }
+        run "cqlsh -e '#{describe_statements.join(' ')}' #{database_url.host} > #{project.schema_path}"
+
+        say "Dumping rows from 'schema_migrations'..."
+        with_padding do
+          File.open(project.schema_path, 'a') do |f|
+            f.puts "USE #{keyspace};"
+            database.all_versions.each do |version|
+              f.puts "INSERT INTO schema_migrations(partition_key, version) VALUES (0, #{version});"
+              say "wrote version: #{version}", :green
+            end
+          end
+        end
+        say
+
+        say "Dump complete. Schema written to #{project.schema_path}."
+      end
+
+      def load
+        project = MonkeyButler::Project.load
+        unless File.size?(project.schema_path)
+          raise Error, "Cannot load database: empty schema found at #{project.schema_path}. Maybe you need to `mb migrate`?"
+        end
+
+        @database = MonkeyButler::Databases::CassandraDatabase.new(database_url)
+        drop
+        run "cqlsh #{database_url.host} -f #{project.schema_path}"
+
+        say "Loaded schema at version #{database.current_version}"
+      end
+
+      def drop
+        say_status :drop, database_url, :yellow
+        database.drop(keyspaces)
+      end
+
+      private
+      def keyspace
+        database_url.path[1..-1]
+      end
+
+      def keyspaces
+        keyspaces = (project.config['cassandra.keyspaces'] || []).dup
+        keyspaces.unshift(keyspace)
+      end
+    end
+  end
+end