sessionm-cassandra_object 2.2.6

data/lib/cassandra_object/cursor.rb

@@ -0,0 +1,90 @@
+module CassandraObject
+  class Cursor
+    include Consistency
+
+    def initialize(target_class, column_family, key, super_column, options={})
+      @target_class  = target_class
+      @column_family = column_family
+      @key           = key.to_s
+      @super_column  = super_column
+      @options       = options
+      @validators    = []
+    end
+    
+    def find(number_to_find)
+      limit       = number_to_find
+      objects     = CassandraObject::Collection.new
+      out_of_keys = false
+
+      if start_with = @options[:start_after]
+        limit += 1
+      else
+        start_with = nil
+      end
+      
+      while objects.size < number_to_find && !out_of_keys
+        index_results = connection.get(@column_family, @key, @super_column,
+          count: limit,
+          start: start_with,
+          reversed: @options[:reversed],
+          consistency: target_class.thrift_read_consistency)
+
+        out_of_keys  = index_results.size < limit
+
+        if !start_with.blank?
+          index_results.delete(start_with)
+        end
+
+        keys = index_results.keys
+        values = index_results.values
+        
+        missing_keys = []
+        
+        results = values.empty? ? {} : @target_class.multi_get(values)
+        results.each do |(key, result)|
+          if result.nil?
+            missing_keys << key
+          end
+        end
+    
+        unless missing_keys.empty?
+          @target_class.multi_get(missing_keys, :quorum=>true).each do |(key, result)|
+            index_key = index_results.index(key)
+            if result.nil?
+              remove(index_key)
+              results.delete(key)
+            else
+              results[key] = result
+            end
+          end
+        end
+
+        results.values.each do |o|
+          if @validators.all? {|v| v.call(o) }
+            objects << o
+          else
+            remove(index_results.index(o.key))
+          end
+        end
+        
+        start_with = objects.last_column_name = keys.last
+        limit = (number_to_find - results.size) + 1
+        
+      end
+      
+      return objects
+    end
+    
+    def connection
+      @target_class.connection
+    end
+    
+    def remove(index_key)
+      connection.remove(@column_family, @key, @super_column, index_key, consistency: target_class.thrift_write_consistency)
+    end
+    
+    def validator(&validator)
+      @validators << validator
+    end
+  end
+end

data/lib/cassandra_object/dirty.rb

@@ -0,0 +1,32 @@
+module CassandraObject
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    # Attempts to +save+ the record and clears changed attributes if successful.
+    def save(*) #:nodoc:
+      if status = super
+        @previously_changed = changes
+        @changed_attributes.clear
+      end
+      status
+    end
+
+    # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
+    def save!(*) #:nodoc:
+      super.tap do
+        @previously_changed = changes
+        @changed_attributes.clear
+      end
+    end
+
+    def write_attribute(name, value)
+      name = name.to_s
+      unless attribute_changed?(name)
+        old = read_attribute(name)
+        changed_attributes[name] = old if old != value
+      end
+      super
+    end
+  end
+end

data/lib/cassandra_object/errors.rb

@@ -0,0 +1,10 @@
+module CassandraObject
+  class CasssandraObjectError < StandardError
+  end
+
+  class RecordNotSaved < CasssandraObjectError
+  end
+  
+  class RecordNotFound < CasssandraObjectError
+  end
+end

data/lib/cassandra_object/finder_methods.rb

@@ -0,0 +1,72 @@
+module CassandraObject
+  module FinderMethods
+    extend ActiveSupport::Concern
+    module ClassMethods
+      def find(key)
+        if parse_key(key) && attributes = connection.get(column_family, key)
+          instantiate(key, attributes)
+        else
+          raise CassandraObject::RecordNotFound
+        end
+      end
+
+      def find_by_id(key)
+        find(key)
+      rescue CassandraObject::RecordNotFound
+        nil
+      end
+
+      def all(options = {})
+        limit = options[:limit] || 100
+        results = ActiveSupport::Notifications.instrument("get_range.cassandra_object", column_family: column_family, key_count: limit) do
+          connection.get_range(column_family, key_count: limit, consistency: thrift_read_consistency)
+        end
+
+        results.map do |k, v|
+          v.empty? ? nil : instantiate(k, v)
+        end.compact
+      end
+
+      def first(options = {})
+        all(options.merge(:limit => 1)).first
+      end
+
+      def find_with_ids(*ids)
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
+
+        ids = ids.dup
+        ids.flatten!
+        ids.compact!
+        ids.collect!(&:to_s)
+        ids.uniq!
+
+        #raise RecordNotFound, "Couldn't find #{record_klass.name} without an ID" if ids.empty?
+
+        results = multi_get(ids).values.compact
+
+        results.size <= 1 && !expects_array ? results.first : results
+      end
+
+      private
+        def multi_get(keys, options={})
+          attribute_results = ActiveSupport::Notifications.instrument("multi_get.cassandra_object", column_family: column_family, keys: keys) do
+            connection.multi_get(column_family, keys.map(&:to_s), consistency: thrift_read_consistency)
+          end
+
+          attribute_results.inject({}) do |memo, (key, attributes)|
+            if attributes.empty?
+              memo[key] = nil
+            else
+              memo[parse_key(key)] = instantiate(key, attributes)
+            end
+            memo
+          end
+        end
+
+        def get(key, options={})
+          multi_get([key], options).values.first
+        end
+    end
+  end
+end

data/lib/cassandra_object/generators/migration_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module CassandraObject
+  module Generators
+    class MigrationGenerator < Rails::Generators::NamedBase
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def self.banner
+        "rails g cassandra_object:migration NAME"
+      end
+
+      def self.desc(description = nil)
+<<EOF
+Description:
+  Create an empty Cassandra migration file in 'ks/migrate'.  Very similar to Rails database migrations.
+
+Example:
+  `rails g cassandra_object:migration CreateFooColumnFamily`
+EOF
+      end
+
+      def create
+        timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        template 'migration.rb.erb', "ks/migrate/#{timestamp}_#{file_name.underscore}.rb"
+      end
+
+    end
+  end
+end

data/lib/cassandra_object/generators/templates/migration.rb.erb

@@ -0,0 +1,11 @@
+class <%= name %> < CassandraObject::Schema::Migration
+
+  def self.up
+
+  end
+
+  def self.down
+
+  end
+
+end

data/lib/cassandra_object/identity/abstract_key_factory.rb

@@ -0,0 +1,36 @@
+module CassandraObject
+  module Identity
+    # Key factories need to support 3 operations
+    class AbstractKeyFactory
+      # Next key takes an object and returns the key object it should use.
+      # object will be ignored with synthetic keys but could be useful with natural ones
+      #
+      # @param  [CassandraObject::Base] the object that needs a new key
+      # @return [CassandraObject::Identity::Key] the key
+      #
+      def next_key(object)
+        raise NotImplementedError, "#{self.class.name}#next_key isn't implemented."
+      end
+
+      # Parse should create a new key object from the 'to_param' format
+      #
+      # @param  [String] the result of calling key.to_param
+      # @return [CassandraObject::Identity::Key] the parsed key
+      #
+      def parse(string)
+        raise NotImplementedError, "#{self.class.name}#parse isn't implemented."
+      end
+
+
+      # create should create a new key object from the cassandra format.
+      #
+      # @param  [String] the result of calling key.to_s
+      # @return [CassandraObject::Identity::Key] the key
+      #
+      def create(string)
+        raise NotImplementedError, "#{self.class.name}#create isn't implemented."
+      end
+    end
+  end
+end
+

data/lib/cassandra_object/identity/custom_key_factory.rb

@@ -0,0 +1,50 @@
+module CassandraObject
+  module Identity
+    class CustomKeyFactory < AbstractKeyFactory
+      class CustomKey
+        include Key
+
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_s
+          value
+        end
+
+        def to_param
+          value
+        end
+
+        def ==(other)
+          other.is_a?(CustomKey) && other.value == value
+        end
+
+        def eql?(other)
+          other == self
+        end
+      end
+
+      attr_reader :method
+
+      def initialize(options)
+        @method = options[:method]
+      end
+
+      def next_key(object)
+        CustomKey.new(object.send(@method))
+      end
+
+      def parse(paramized_key)
+        CustomKey.new(paramized_key)
+      end
+
+      def create(paramized_key)
+        CustomKey.new(paramized_key)
+      end
+    end
+  end
+end
+

data/lib/cassandra_object/identity/hashed_natural_key_factory.rb

@@ -0,0 +1,10 @@
+require 'digest/sha1'
+module CassandraObject
+  module Identity
+    class HashedNaturalKeyFactory < NaturalKeyFactory
+      def next_key(object)
+        NaturalKey.new(Digest::SHA1.hexdigest(attributes.map { |a| object.attributes[a.to_s] }.join(separator)))
+      end
+    end
+  end
+end

data/lib/cassandra_object/identity/key.rb

@@ -0,0 +1,20 @@
+module CassandraObject
+  module Identity
+    # An "interface" that keys need to implement
+    # 
+    # You don't have to include this. But, there's no reason I can think of not to.
+    #
+    module Key
+      # to_param should return a nice-readable representation of the key suitable to chuck into URLs
+      #
+      # @return [String] a nice readable representation of the key suitable for URLs
+      def to_param; end
+        
+      # to_s should return the bytes which will be written to cassandra both as keys and values for associations.
+      #
+      # @return [String] the bytes which will be written to cassandra as keys
+      def to_s; end
+    end
+  end
+end
+

data/lib/cassandra_object/identity/natural_key_factory.rb

@@ -0,0 +1,51 @@
+module CassandraObject
+  module Identity
+    class NaturalKeyFactory < AbstractKeyFactory
+      class NaturalKey
+        include Key
+
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_s
+          value
+        end
+
+        def to_param
+          value
+        end
+
+        def ==(other)
+          other.is_a?(NaturalKey) && other.value == value
+        end
+
+        def eql?(other)
+          other == self
+        end
+      end
+
+      attr_reader :attributes, :separator
+
+      def initialize(options)
+        @attributes = [*options[:attributes]]
+        @separator  = options[:separator] || "-"
+      end
+
+      def next_key(object)
+        NaturalKey.new(attributes.map { |a| object.attributes[a.to_s] }.join(separator))
+      end
+
+      def parse(paramized_key)
+        NaturalKey.new(paramized_key)
+      end
+
+      def create(paramized_key)
+        NaturalKey.new(paramized_key)
+      end
+    end
+  end
+end
+

data/lib/cassandra_object/identity/uuid_key_factory.rb

@@ -0,0 +1,39 @@
+module CassandraObject
+  module Identity
+    # Key factories need to support 3 operations
+    class UUIDKeyFactory < AbstractKeyFactory
+      class UUID < SimpleUUID::UUID
+        include Key
+
+        def to_param
+          to_guid
+        end
+        
+        def to_s
+          # FIXME - this should probably write the raw bytes 
+          # but it's very hard to debug without this for now.
+          to_guid
+        end
+      end
+    
+      # Next key takes an object and returns the key object it should use.
+      # object will be ignored with synthetic keys but could be useful with natural ones
+      def next_key(object)
+        UUID.new
+      end
+      
+      # Parse should create a new key object from the 'to_param' format
+      def parse(string)
+        UUID.new(string)
+      rescue
+        nil
+      end
+      
+      # create should create a new key object from the cassandra format.
+      def create(string)
+        UUID.new(string)
+      end
+    end
+  end
+end
+

data/lib/cassandra_object/identity.rb

@@ -0,0 +1,52 @@
+module CassandraObject
+  module Identity
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :Key
+    autoload :AbstractKeyFactory
+    autoload :UUIDKeyFactory
+    autoload :NaturalKeyFactory
+    autoload :HashedNaturalKeyFactory
+    autoload :CustomKeyFactory
+
+    module ClassMethods
+      # Indicate what kind of key the model will have: uuid or natural
+      #
+      # @param [:uuid, :natural] the type of key
+      # @param the options you want to pass along to the key factory (like :attributes => :name, for a natural key).
+      # 
+      def key(name_or_factory = :uuid, *options)
+        @key_factory = case name_or_factory
+        when :uuid
+          UUIDKeyFactory.new
+        when :natural
+          NaturalKeyFactory.new(*options)
+        when :custom
+          CustomKeyFactory.new(*options)
+        else
+          name_or_factory
+        end
+      end
+
+      def next_key(object = nil)
+        @key_factory.next_key(object).tap do |key|
+          raise "Keys may not be nil" if key.nil?
+        end
+      end
+
+      def parse_key(string)
+        @key_factory.parse(string)
+      end
+    end
+
+    def id
+      key.to_s
+    end
+
+    def id=(key)
+      self.key = self.class.parse_key(key)
+      id
+    end
+  end
+end

data/lib/cassandra_object/log_subscriber.rb

@@ -0,0 +1,37 @@
+module CassandraObject
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def multi_get(event)
+      name = '%s multi_get (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      debug "  #{name}  (#{event.payload[:keys].size}) #{event.payload[:keys].join(" ")}"
+    end
+
+    def remove(event)
+      name = '%s remove (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      message = "  #{name}  #{event.payload[:key]}"
+      message << " #{Array(event.payload[:attributes]).inspect}" if event.payload[:attributes]
+
+      debug message
+    end
+
+    def truncate(event)
+      name = '%s truncate (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      debug "  #{name}  #{event.payload[:column_family]}"
+    end
+
+    def insert(event)
+      name = '%s insert (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      debug "  #{name}  #{event.payload[:key]} #{event.payload[:attributes].inspect}"
+    end
+
+    def get_range(event)
+      name = '%s get_range (%.1fms)' % [event.payload[:column_family], event.duration]
+      
+      debug "  #{name}  (#{event.payload[:count]}) '#{event.payload[:start]}' => '#{event.payload[:finish]}'"
+    end
+  end
+end
+CassandraObject::LogSubscriber.attach_to :cassandra_object

data/lib/cassandra_object/migrations/migration.rb

@@ -0,0 +1,15 @@
+module CassandraObject
+  module Migrations
+    class Migration
+      attr_reader :version
+      def initialize(version, block)
+        @version = version
+        @block = block
+      end
+
+      def run(attrs)
+        @block.call(attrs)
+      end
+    end
+  end
+end

data/lib/cassandra_object/migrations.rb

@@ -0,0 +1,66 @@
+module CassandraObject
+  module Migrations
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    included do
+      class_inheritable_array :migrations
+      class_inheritable_accessor :current_schema_version
+      self.current_schema_version = 0
+    end
+
+    autoload :Migration
+    
+    class MigrationNotFoundError < StandardError
+      def initialize(record_version, migrations)
+        super("Cannot migrate a record from #{record_version.inspect}.  Migrations exist for #{migrations.map(&:version)}")
+      end
+    end
+    
+    module InstanceMethods
+      def schema_version
+        Integer(@schema_version || self.class.current_schema_version)
+      end
+    end
+    
+    module ClassMethods
+      def migrate(version, &blk)
+        write_inheritable_array(:migrations, [Migration.new(version, blk)])
+        
+        if version > self.current_schema_version 
+          self.current_schema_version = version
+        end
+      end
+      
+      def instantiate(key, attributes)
+        version = attributes.delete('schema_version')
+        original_attributes = attributes.dup
+        if version == current_schema_version
+          return super(key, attributes)
+        end
+        
+        versions_to_migrate = ((version.to_i + 1)..current_schema_version)
+        
+        migrations_to_run = versions_to_migrate.map do |v|
+          migrations.find {|m| m.version == v}
+        end
+        
+        if migrations_to_run.any?(&:nil?)
+          raise MigrationNotFoundError.new(version, migrations)
+        end
+        
+        migrations_to_run.inject(attributes) do |attrs, migration|
+          migration.run(attrs)
+          @schema_version = migration.version.to_s
+          attrs
+        end
+        
+        super(key, attributes).tap do |record|
+          original_attributes.diff(attributes).keys.each do |attribute|
+            record.attribute_will_change! attribute
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/mocking.rb

@@ -0,0 +1,15 @@
+require 'cassandra/mock'
+module CassandraObject
+  module Mocking
+    extend ActiveSupport::Concern
+    module ClassMethods
+      def use_mock!(really=true)
+        if really
+          self.connection_class = Cassandra::Mock
+        else
+          self.connection_class = Cassandra
+        end
+      end
+    end
+  end
+end