cassanity 0.4.0 → 0.5.0

data/lib/cassanity/migration.rb

@@ -0,0 +1,125 @@
+require 'forwardable'
+
+module Cassanity
+  class Migration
+    extend Forwardable
+
+    # Private: The migrator that is running the migration.
+    attr_reader :migrator
+
+    # Private: Delegates keyspace to migrator.
+    def_delegator :@migrator, :keyspace
+
+    # Public: Get new instance of a migration.
+    #
+    # migrator - The Cassanity::Migrator instance that is running the show.
+    def initialize(migrator)
+      @migrator = migrator
+    end
+
+    # Public: Override in subclass.
+    def up
+    end
+
+    # Public: Override in subclass.
+    def down
+    end
+
+    # Public: Create a column family.
+    #
+    # column_family_name - The String or Symbol name of the column family.
+    # args - The Hash of arguments. See ColumnFamily#create for available args.
+    #
+    # Returns nothing.
+    def create_column_family(column_family_name, schema)
+      keyspace.column_family(column_family_name, schema: schema).create
+    end
+    alias_method :add_column_family, :create_column_family
+    alias_method :create_table, :create_column_family
+    alias_method :add_table, :create_column_family
+
+    # Public: Drop a column family.
+    #
+    # column_family_name - The String or Symbol name of the column family.
+    #
+    # Returns nothing.
+    def drop_column_family(column_family_name)
+      keyspace[column_family_name].drop
+    end
+    alias_method :drop_table, :drop_column_family
+
+    # Public: Add a column to a column family.
+    #
+    # column_family_name - The String or Symbol name of the column family.
+    # column_name - The String or Symbol name of the column to index.
+    # type - The String or Symbol CQL data type for the column.
+    #
+    # Returns nothing.
+    def add_column(column_family_name, column_name, type)
+      keyspace[column_family_name].alter(add: {column_name => type})
+    end
+    alias_method :create_column, :add_column
+
+    # Public: Drop a column from a column family.
+    #
+    # column_family_name - The String or Symbol name of the column family.
+    # column_name - The String or Symbol name of the column to index.
+    #
+    # Returns nothing.
+    def drop_column(column_family_name, column_name)
+      keyspace[column_family_name].alter(drop: column_name)
+    end
+
+    # Public: Alter a column family.
+    #
+    # column_family_name - The String or Symbol name of the column family.
+    # args - The Hash of arguments. See ColumnFamily#alter for available args.
+    #
+    # Returns nothing.
+    def alter_column_family(column_family_name, args = {})
+      keyspace[column_family_name].alter(args)
+    end
+    alias_method :alter_table, :alter_column_family
+
+    # Public: Create an index on a column for a column family.
+    #
+    # column_family_name - The String or Symbol name of the column family.
+    # column_name - The String or Symbol name of the column to index.
+    # options - The Hash of options.
+    #           :name - The String or Symbol name of the index
+    #                   (defaults to column_name).
+    #
+    # Returns nothing.
+    def add_index(column_family_name, column_name, options = {})
+      index_args = {column_name: column_name}
+      index_args[:name] = options[:name] if options.key?(:name)
+
+      keyspace[column_family_name].create_index(index_args)
+    end
+    alias_method :create_index, :add_index
+
+    # Public: Drop an index by name for a column family.
+    #
+    # column_family_name - The String or Symbol name of the column family.
+    # name - The String or Symbol name of the index.
+    #
+    # Returns nothing.
+    def drop_index(column_family_name, index_name)
+      keyspace[column_family_name].drop_index(name: index_name)
+    end
+
+    # Public: Spit something to the log with timing.
+    def say_with_time(message)
+      say message
+      start = Time.now
+      result = yield
+      duration = (Time.now - start).round(3)
+      @migrator.log "   -> #{duration}s"
+    end
+
+    # Public: Spit something to the log.
+    def say(message)
+      @migrator.log "-- #{message}"
+    end
+  end
+end

data/lib/cassanity/migration_proxy.rb

@@ -0,0 +1,76 @@
+require 'pathname'
+
+module Cassanity
+  class MigrationProxy
+    include Comparable
+
+    # Public: The full path to the migration on disk.
+    attr_reader :path
+
+    # Public: The version of the migration.
+    attr_reader :version
+
+    # Public: The name of the migration.
+    attr_reader :name
+
+    def initialize(path)
+      raise ArgumentError, "path cannot be nil" if path.nil?
+
+      basename = File.basename(path, '.rb')
+      version, name = basename.split('_', 2)
+
+      raise ArgumentError, "version cannot be nil" if version.nil?
+      raise ArgumentError, "name cannot be nil" if name.nil?
+
+      @path = Pathname(path)
+      @version = version.to_i
+      @name = name
+    end
+
+    def up(migrator)
+      log(migrator) { build_migration(migrator).up }
+    end
+
+    def down(migrator)
+      log(migrator) { build_migration(migrator).down }
+    end
+
+    def log(migrator)
+      migrator.log "== #{@name}: migrating ".ljust(80, "=")
+      start = Time.now
+      result = yield
+      duration = (Time.now - start).round(3)
+      migrator.log "== #{@name}: migrated (#{duration}s) ".ljust(80, "=")
+      result
+    end
+
+    def build_migration(migrator)
+      migration_class.new(migrator)
+    end
+
+    def migration_class
+      @migration_class ||= begin
+        require path
+        # TODO: handle constant not found
+        Kernel.const_get(constant)
+      end
+    end
+
+    def constant
+      name.split('_').map { |word| word.capitalize }.join('')
+    end
+
+    def hash
+      path.hash
+    end
+
+    def eql?(other)
+      self.class.eql?(other.class) && path == other.path
+    end
+    alias_method :==, :eql?
+
+    def <=>(other)
+      @path <=> other.path
+    end
+  end
+end

data/lib/cassanity/migrator.rb

@@ -0,0 +1,154 @@
+require 'logger'
+require 'pathname'
+require 'cassanity/migration_proxy'
+require 'cassanity/migration'
+
+module Cassanity
+  class Migrator
+    SupportedDirections = [:up, :down]
+
+    # Public: The keyspace all migrations apply to.
+    attr_reader :keyspace
+
+    # Public: The path to all the migrations.
+    attr_reader :migrations_path
+
+    # Public: Where to spit all the logging related to migrations.
+    attr_reader :logger
+
+    def initialize(keyspace, migrations_path, options = {})
+      @keyspace = keyspace
+      @migrations_path = Pathname(migrations_path)
+      @logger = options[:logger] || default_logger
+    end
+
+    # Public: Runs all pending migrations in order.
+    def migrate
+      run_migrations pending_migrations, :up
+    end
+
+    # Public: Migrates to a version using a direction.
+    #
+    # version - The String or Integer version to migrate to.
+    # direction - The String or Symbol direction you would like to migrate.
+    def migrate_to(version, direction = :up)
+      version = version.to_i
+      direction = direction.to_sym
+      assert_valid_direction(direction)
+
+      migrations = case direction
+      when :up
+        pending_migrations.select { |migration| migration.version <= version }
+      when :down
+        performed_migrations.select { |migration| migration.version > version }
+      else
+        []
+      end
+
+      run_migrations migrations, direction
+    end
+
+    # Public: Marks a migration as migrated.
+    def migrated_up(migration)
+      column_family.insert({
+        data: {
+          version: migration.version,
+          name: migration.name,
+          migrated_at: Time.now.utc,
+        },
+      })
+    end
+
+    # Public: Marks a migration as not run.
+    def migrated_down(migration)
+      column_family.delete({
+        where: {
+          version: migration.version,
+          name: migration.name,
+        },
+      })
+    end
+
+    # Public: An array of all migrations.
+    def migrations
+      @migrations ||= begin
+        paths = Dir["#{migrations_path}/*.rb"]
+        migrations = paths.map { |path| MigrationProxy.new(path) }
+        migrations.sort
+      end
+    end
+
+    # Public: An array of the migrations that have been performed.
+    def performed_migrations
+      rows = column_family.select
+      rows.map { |row|
+        path = migrations_path.join("#{row['version']}_#{row['name']}.rb")
+        MigrationProxy.new(path)
+      }.sort
+    end
+
+    # Public: An array of the migrations that have not been performed.
+    def pending_migrations
+      (migrations - performed_migrations).sort
+    end
+
+    # Internal: Log a message.
+    def log(message)
+      @logger.info message
+    end
+
+    # Private
+    def run_migrations(migrations, direction)
+      migrations = migrations.sort
+
+      case direction
+      when :up
+        migrations.each do |migration|
+          migration.up(self)
+          migrated_up(migration)
+        end
+      when :down
+        migrations = migrations.reverse
+        migrations.each do |migration|
+          migration.down(self)
+          migrated_down(migration)
+        end
+      end
+
+      {performed: migrations}
+    end
+
+    # Private: The column family storing all
+    # migration information.
+    def column_family
+      @column_family ||= begin
+        column_family = keyspace.column_family({
+          name: :migrations,
+          schema: {
+            primary_key: [:version, :name],
+            columns: {
+              version: :text,
+              name: :text,
+              migrated_at: :timestamp,
+            },
+          },
+        })
+        column_family.create unless column_family.exists?
+        column_family
+      end
+    end
+
+    # Private
+    def default_logger
+      logger = Logger.new(STDOUT)
+      logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+      logger
+    end
+
+    def assert_valid_direction(direction)
+      unless SupportedDirections.include?(direction)
+        raise ArgumentError, "#{direction.inspect} is not a valid migration direction"
+      end
+    end
+  end
+end

data/lib/cassanity/result_transformers/column_families.rb

@@ -0,0 +1,20 @@
+require 'cassanity/column_family'
+
+module Cassanity
+  module ResultTransformers
+    class ColumnFamilies
+
+      # Internal: Turns result into Array of column families.
+      def call(result, args = {})
+        column_families = []
+        result.fetch_hash do |row|
+          column_families << ColumnFamily.new({
+            name: row['columnfamily'] || row['columnfamily_name'],
+            keyspace: args[:keyspace],
+          })
+        end
+        column_families
+      end
+    end
+  end
+end

data/lib/cassanity/result_transformers/columns.rb

@@ -0,0 +1,21 @@
+require 'cassanity/column'
+
+module Cassanity
+  module ResultTransformers
+    class Columns
+
+      # Internal: Turns result into Array of column families.
+      def call(result, args = {})
+        columns = []
+        result.fetch_hash do |row|
+          columns << Column.new({
+            name: row['column'],
+            type: row['validator'],
+            column_family: args[:column_family],
+          })
+        end
+        columns
+      end
+    end
+  end
+end

data/lib/cassanity/result_transformers/keyspaces.rb

@@ -0,0 +1,21 @@
+require 'cassanity/column_family'
+
+module Cassanity
+  module ResultTransformers
+    class Keyspaces
+
+      # Internal: Turns result into Array of keyspaces.
+      def call(result, args = {})
+        keyspaces = []
+        result.fetch_hash do |row|
+          name = row['name'] || row['keyspace'] || row['keyspace_name']
+          keyspaces << Keyspace.new({
+            name: name,
+            executor: args[:executor],
+          })
+        end
+        keyspaces
+      end
+    end
+  end
+end

data/lib/cassanity/result_transformers/mirror.rb

@@ -4,7 +4,7 @@ module Cassanity
 
       # Internal: Returns whatever result is passed to it. This is used as the
       # default result transformer when a command does not have one.
-      def call(result)
+      def call(result, args = nil)
         result
       end
     end

data/lib/cassanity/result_transformers/result_to_array.rb

@@ -3,7 +3,7 @@ module Cassanity
     class ResultToArray
 
       # Internal: Turns result into Array of Hashes.
-      def call(result)
+      def call(result, args = nil)
         rows = []
         result.fetch_hash do |row|
           rows << row

data/lib/cassanity/retry_strategies/exponential_backoff.rb

@@ -0,0 +1,43 @@
+require 'cassanity/retry_strategies/retry_strategy'
+
+module Cassanity
+  module RetryStrategies
+    class ExponentialBackoff < RetryStrategy
+      ForeverSentinel = :forever
+
+      # Private: Taken from https://github.com/twitter/kestrel-client's
+      # blocking client.
+      SleepTimes = [[0] * 1, [0.01] * 2, [0.1] * 2, [0.5] * 2, [1.0] * 1].flatten
+
+      # Private: the maxmimum number of times to retry or -1 to try forever.
+      attr_reader :retries
+
+      # Public: Initialize the retry strategy.
+      #
+      # args   - The Hash of options.
+      #          :retries - the maximum number of times to retry (default: forever)
+      def initialize(args = {})
+        # The default behavior is to retry forever.
+        @retries = args[:retries] || ForeverSentinel
+      end
+
+      def fail(attempts, error)
+        if @retries != ForeverSentinel && attempts > @retries
+          raise error
+        end
+        sleep_for_count(attempts)
+      end
+
+      # Private: sleep a randomized amount of time from the SleepTimes
+      # mostly-exponential distribution.
+      #
+      # count - the index into the distribution to pull the base sleep time from
+      def sleep_for_count(count)
+        base = SleepTimes[count] || SleepTimes.last
+
+        time = ((rand * base) + base) / 2
+        sleep time if time > 0
+      end
+    end
+  end
+end