sessionm-cassandra_object 2.2.6

data/lib/cassandra_object/persistence.rb

@@ -0,0 +1,138 @@
+module CassandraObject
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def remove(key)
+        ActiveSupport::Notifications.instrument("remove.cassandra_object", column_family: column_family, key: key) do
+          connection.remove(column_family, key.to_s, consistency: thrift_write_consistency)
+        end
+      end
+
+      def delete_all
+        ActiveSupport::Notifications.instrument("truncate.cassandra_object", column_family: column_family) do
+          connection.truncate!(column_family)
+        end
+      end
+
+      def create(attributes = {})
+        new(attributes).tap do |object|
+          object.save
+        end
+      end
+
+      def write(key, attributes, schema_version)
+        key.tap do |key|
+          attributes = encode_columns_hash(attributes, schema_version)
+          ActiveSupport::Notifications.instrument("insert.cassandra_object", column_family: column_family, key: key, attributes: attributes) do
+            connection.insert(column_family, key.to_s, attributes, consistency: thrift_write_consistency)
+          end
+        end
+      end
+
+      def instantiate(key, attributes)
+        # remove any attributes we don't know about. we would do this earlier, but we want to make such
+        #  attributes available to migrations
+        attributes.delete_if { |k,_| model_attributes[k].nil? }
+
+        allocate.tap do |object|
+          object.instance_variable_set("@schema_version", attributes.delete('schema_version'))
+          object.instance_variable_set("@key", parse_key(key))
+          object.instance_variable_set("@new_record", false)
+          object.instance_variable_set("@destroyed", false)
+          object.instance_variable_set("@attributes", decode_columns_hash(attributes))
+        end
+      end
+
+      def encode_columns_hash(attributes, schema_version)
+        attributes.inject({}) do |memo, (column_name, value)|
+          # cassandra stores bytes, not strings, so it has no concept of encodings. The ruby thrift gem 
+          # expects all strings to be encoded as ascii-8bit.
+          # don't attempt to encode columns that are nil
+          memo[column_name.to_s] = value.nil? ? '' : model_attributes[column_name].converter.encode(value).force_encoding('ASCII-8BIT')
+          memo
+        end.merge({"schema_version" => schema_version.to_s})
+      end
+
+      def decode_columns_hash(attributes)
+        Hash[attributes.map { |k, v| [k.to_s, model_attributes[k].converter.decode(v)] }]
+      end
+      
+      def column_family_configuration
+        [{:Name => column_family, :CompareWith => "UTF8Type"}]
+      end
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    def save(*)
+      begin
+        create_or_update
+      rescue CassandraObject::RecordInvalid
+        false
+      end
+    end
+
+    def save!
+      create_or_update || raise(RecordNotSaved)
+    end
+
+    def destroy
+      self.class.remove(key)
+      @destroyed = true
+      freeze
+    end
+
+    def update_attribute(name, value)
+      name = name.to_s
+      send("#{name}=", value)
+      save(:validate => false)
+    end
+
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    def update_attributes!(attributes)
+      self.attributes = attributes
+      save!
+    end
+
+    def reload
+      @attributes.update(self.class.find(self.id).instance_variable_get('@attributes'))
+    end
+
+    private
+      def create_or_update
+        result = new_record? ? create : update
+        result != false
+      end
+
+      def create
+        @key ||= self.class.next_key(self)
+        write
+        @new_record = false
+        @key
+      end
+    
+      def update
+        write
+      end
+
+      def write
+        changed_attributes = changed.inject({}) { |h, n| h[n] = read_attribute(n); h }
+        self.class.write(key, changed_attributes, schema_version)
+      end
+  end
+end

data/lib/cassandra_object/railtie.rb

@@ -0,0 +1,11 @@
+module CassandraObject
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'cassandra_object/tasks/ks.rake'
+    end
+
+    generators do
+      require 'cassandra_object/generators/migration_generator'
+    end
+  end
+end

data/lib/cassandra_object/schema/migration.rb

@@ -0,0 +1,106 @@
+module CassandraObject
+  module Schema
+
+    class Migration
+
+      @@verbose = true
+      cattr_accessor :verbose
+
+      # Returns the raw connection to Cassandra
+      def self.connection
+        CassandraObject::Base.connection
+      end
+
+      def self.migrate(direction)
+        return unless respond_to?(direction)
+
+        case direction
+        when :up   then announce "migrating"
+        when :down then announce "reverting"
+        end
+
+        result = nil
+        time = Benchmark.measure { result = send("#{direction}") }
+
+        case direction
+        when :up   then announce "migrated (%.4fs)" % time.real; write
+        when :down then announce "reverted (%.4fs)" % time.real; write
+        end
+
+        result
+      end
+
+      # Creates a new column family with the given name.  Column family configurations can be set within
+      # a block like this:
+      #
+      #  create_column_family(:users) do |cf|
+      #    cf.comment = 'Users column family'
+      #    cf.comparator_type = 'TimeUUIDType'
+      #  end
+      #
+      # A complete list of available configuration settings is here:
+      #
+      # http://github.com/fauna/cassandra/blob/master/vendor/0.7/gen-rb/cassandra_types.rb
+      #
+      # Scroll down to the CfDef definition.
+      def self.create_column_family(name, &block)
+        say_with_time("create_column_family #{name}") do
+          column_family_tasks.create(name, &block)
+        end
+      end
+
+      # Drops the given column family
+      def self.drop_column_family(name)
+        say_with_time("drop_column_family #{name}") do
+          column_family_tasks.drop(name)
+        end
+      end
+
+      # Renames the column family from the old name to the new name
+      def self.rename_column_family(old_name, new_name)
+        say_with_time("rename_column_family #{name}") do
+          column_family_tasks.rename(old_name, new_name)
+        end
+      end
+
+      def self.write(text="")
+        puts(text) if verbose
+      end
+
+      def self.announce(message)
+        version = defined?(@version) ? @version : nil
+
+        text = "#{version} #{name}: #{message}"
+        length = [0, 75 - text.length].max
+        write "== %s %s" % [text, "=" * length]
+      end
+
+      def self.say(message, subitem=false)
+        write "#{subitem ? "   ->" : "--"} #{message}"
+      end
+
+      def self.say_with_time(message)
+        say(message)
+        result = nil
+        time = Benchmark.measure { result = yield }
+        say "%.4fs" % time.real, :subitem
+        say("#{result} rows", :subitem) if result.is_a?(Integer)
+        result
+      end
+
+      def self.suppress_messages
+        save, self.verbose = verbose, false
+        yield
+      ensure
+        self.verbose = save
+      end
+
+      private
+
+      def self.column_family_tasks
+        Tasks::ColumnFamily.new(CassandraObject::Base.connection.keyspace)
+      end
+
+    end
+  end
+end

data/lib/cassandra_object/schema/migration_proxy.rb

@@ -0,0 +1,25 @@
+module CassandraObject
+  module Schema
+
+    # MigrationProxy is used to defer loading of the actual migration classes
+    # until they are needed
+    class MigrationProxy
+
+      attr_accessor :name, :version, :filename
+
+      delegate :migrate, :announce, :write, :to=>:migration
+
+      private
+
+      def migration
+        @migration ||= load_migration
+      end
+
+      def load_migration
+        require(File.expand_path(filename))
+        name.constantize
+      end
+
+    end
+  end
+end

data/lib/cassandra_object/schema/migrator.rb

@@ -0,0 +1,213 @@
+module CassandraObject
+  module Schema
+
+    class Migrator
+
+      def self.migrate(migrations_path, target_version = nil)
+        case
+        when target_version.nil?
+          up(migrations_path, target_version)
+        when current_version == 0 && target_version == 0
+        when current_version > target_version
+          down(migrations_path, target_version)
+        else
+          up(migrations_path, target_version)
+        end
+      end
+
+      def self.rollback(migrations_path, steps = 1)
+        move(:down, migrations_path, steps)
+      end
+
+      def self.forward(migrations_path, steps = 1)
+        move(:up, migrations_path, steps)
+      end
+
+      def self.up(migrations_path, target_version = nil)
+        new(:up, migrations_path, target_version).migrate
+      end
+
+      def self.down(migrations_path, target_version = nil)
+        new(:down, migrations_path, target_version).migrate
+      end
+
+      def self.run(direction, migrations_path, target_version)
+        new(direction, migrations_path, target_version).run
+      end
+
+      def self.migrations_path
+        'ks/migrate'
+      end
+
+      def self.schema_migrations_column_family
+        :schema_migrations
+      end
+
+      def self.column_family_tasks
+        cas = CassandraObject::Base.connection
+        Tasks::ColumnFamily.new(cas.keyspace)
+      end
+
+      def self.get_all_versions
+        cas = CassandraObject::Base.connection
+        cas.get(schema_migrations_column_family, 'all').map {|(name, _value)| name.to_i}.sort
+      end
+
+      def self.current_version
+        sm_cf = schema_migrations_column_family
+        if column_family_tasks.exists?(sm_cf)
+          get_all_versions.max || 0
+        else
+          0
+        end
+      end
+
+      private
+
+      def self.move(direction, migrations_path, steps)
+        migrator = self.new(direction, migrations_path)
+        start_index = migrator.migrations.index(migrator.current_migration)
+
+        if start_index
+          finish = migrator.migrations[start_index + steps]
+          version = finish ? finish.version : 0
+          send(direction, migrations_path, version)
+        end
+      end
+
+      public
+
+      def initialize(direction, migrations_path, target_version = nil)
+        sm_cf = self.class.schema_migrations_column_family
+
+        unless column_family_tasks.exists?(sm_cf)
+          column_family_tasks.create(sm_cf) do |cf|
+            cf.comparator_type = 'LongType'
+          end
+        end
+
+        @direction, @migrations_path, @target_version = direction, migrations_path, target_version
+      end
+
+      def current_version
+        migrated.last || 0
+      end
+
+      def current_migration
+        migrations.detect { |m| m.version == current_version }
+      end
+
+      def run
+        target = migrations.detect { |m| m.version == @target_version }
+        raise UnknownMigrationVersionError.new(@target_version) if target.nil?
+        unless (up? && migrated.include?(target.version.to_i)) || (down? && !migrated.include?(target.version.to_i))
+          target.migrate(@direction)
+          record_version_state_after_migrating(target)
+        end
+      end
+
+      def migrate
+        current = migrations.detect { |m| m.version == current_version }
+        target = migrations.detect { |m| m.version == @target_version }
+
+        if target.nil? && !@target_version.nil? && @target_version > 0
+          raise UnknownMigrationVersionError.new(@target_version)
+        end
+
+        start = up? ? 0 : (migrations.index(current) || 0)
+        finish = migrations.index(target) || migrations.size - 1
+        runnable = migrations[start..finish]
+
+        # skip the last migration if we're headed down, but not ALL the way down
+        runnable.pop if down? && !target.nil?
+
+        runnable.each do |migration|
+          #puts "Migrating to #{migration.name} (#{migration.version})"
+
+          # On our way up, we skip migrating the ones we've already migrated
+          next if up? && migrated.include?(migration.version.to_i)
+
+          # On our way down, we skip reverting the ones we've never migrated
+          if down? && !migrated.include?(migration.version.to_i)
+            migration.announce 'never migrated, skipping'; migration.write
+            next
+          end
+
+          migration.migrate(@direction)
+          record_version_state_after_migrating(migration)
+        end
+      end
+
+      def migrations
+        @migrations ||= begin
+                          files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
+
+                          migrations = files.inject([]) do |klasses, file|
+                            version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+
+                            raise IllegalMigrationNameError.new(file) unless version
+                            version = version.to_i
+
+                            if klasses.detect { |m| m.version == version }
+                              raise DuplicateMigrationVersionError.new(version)
+                            end
+
+                            if klasses.detect { |m| m.name == name.camelize }
+                              raise DuplicateMigrationNameError.new(name.camelize)
+                            end
+
+                            migration = MigrationProxy.new
+                            migration.name     = name.camelize
+                            migration.version  = version
+                            migration.filename = file
+                            klasses << migration
+                          end
+
+                          migrations = migrations.sort_by { |m| m.version }
+                          down? ? migrations.reverse : migrations
+                        end
+      end
+
+      def pending_migrations
+        already_migrated = migrated
+        migrations.reject { |m| already_migrated.include?(m.version.to_i) }
+      end
+
+      def migrated
+        @migrated_versions ||= self.class.get_all_versions
+      end
+
+      private
+
+      def column_family_tasks
+        Tasks::ColumnFamily.new(connection.keyspace)
+      end
+
+      def connection
+        CassandraObject::Base.connection
+      end
+
+      def record_version_state_after_migrating(migration)
+        sm_cf = self.class.schema_migrations_column_family
+
+        @migrated_versions ||= []
+        if down?
+          @migrated_versions.delete(migration.version)
+          connection.remove sm_cf, 'all', migration.version
+        else
+          @migrated_versions.push(migration.version).sort!
+          connection.insert sm_cf, 'all', { migration.version => migration.name }
+        end
+      end
+
+      def up?
+        @direction == :up
+      end
+
+      def down?
+        @direction == :down
+      end
+
+    end
+  end
+end

data/lib/cassandra_object/schema.rb

@@ -0,0 +1,37 @@
+module CassandraObject
+  module Schema
+    extend ActiveSupport::Autoload
+
+    class IrreversibleMigration < StandardError
+    end
+
+    class DuplicateMigrationVersionError < StandardError#:nodoc:
+      def initialize(version)
+        super("Multiple migrations have the version number #{version}")
+      end
+    end
+
+    class DuplicateMigrationNameError < StandardError#:nodoc:
+      def initialize(name)
+        super("Multiple migrations have the name #{name}")
+      end
+    end
+
+    class UnknownMigrationVersionError < StandardError #:nodoc:
+      def initialize(version)
+        super("No migration with version number #{version}")
+      end
+    end
+
+    class IllegalMigrationNameError < StandardError#:nodoc:
+      def initialize(name)
+        super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed)")
+      end
+    end
+
+    autoload :Migrator
+    autoload :Migration
+    autoload :MigrationProxy
+
+  end
+end

data/lib/cassandra_object/serialization.rb

@@ -0,0 +1,6 @@
+module CassandraObject
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+  end
+end

data/lib/cassandra_object/tasks/column_family.rb

@@ -0,0 +1,90 @@
+module CassandraObject
+
+  module Tasks
+
+    class ColumnFamily
+
+      COMPARATOR_TYPES = { :time      => 'TimeUUIDType',
+                           :timestamp => 'TimeUUIDType',
+                           :long      => 'LongType',
+                           :string    => 'BytesType',
+                           :utf8      => 'UTF8Type' }
+
+      COLUMN_TYPES = {     :standard  => 'Standard',
+                           :super     => 'Super' }
+
+      def initialize(keyspace)
+        @keyspace = keyspace
+      end
+
+      def exists?(name)
+        connection.schema.cf_defs.find { |cf_def| cf_def.name == name.to_s }
+      end
+
+      def create(name, &block)
+        cf = Cassandra::ColumnFamily.new
+        cf.name = name.to_s
+        cf.keyspace = @keyspace.to_s
+        cf.comparator_type = 'BytesType'
+        cf.column_type = 'Standard'
+
+        block.call cf if block
+
+        post_process_column_family(cf)
+        connection.add_column_family(cf)
+      end
+
+      def drop(name)
+        connection.drop_column_family(name.to_s)
+      end
+
+      def rename(old_name, new_name)
+        connection.rename_column_family(old_name.to_s, new_name.to_s)
+      end
+
+      def clear(name)
+        connection.truncate!(name.to_s)
+      end
+
+      private
+
+      def connection
+        CassandraObject::Base.connection
+      end
+
+      def post_process_column_family(cf)
+        comp_type = cf.comparator_type
+        if comp_type && COMPARATOR_TYPES.has_key?(comp_type)
+          cf.comparator_type = COMPARATOR_TYPES[comp_type]
+        end
+
+        comp_type = cf.subcomparator_type
+        if comp_type && COMPARATOR_TYPES.has_key?(comp_type)
+          cf.subcomparator_type = COMPARATOR_TYPES[comp_type]
+        end
+
+        col_type = cf.column_type
+        if col_type && COLUMN_TYPES.has_key?(col_type)
+          cf.column_type = COLUMN_TYPES[col_type]
+        end
+
+        cf
+      end
+
+    end
+
+  end
+
+end
+
+class Cassandra
+  class ColumnFamily
+    def with_fields(options)
+      struct_fields.collect { |f| f[1][:name] }.each do |f|
+        send("#{f}=", options[f.to_sym] || options[f.to_s])
+      end
+      self
+    end
+  end
+end
+