gotime-cassandra_object 0.6.1

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/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,37 @@
+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)
+      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/indexes.rb

@@ -0,0 +1,129 @@
+module CassandraObject
+  module Indexes
+    extend ActiveSupport::Concern
+    
+    included do
+      class_inheritable_accessor :indexes
+    end
+    
+    class UniqueIndex
+      def initialize(attribute_name, model_class, options)
+        @attribute_name = attribute_name
+        @model_class    = model_class
+      end
+      
+      def find(attribute_value)
+        # first find the key value
+        key = @model_class.connection.get(column_family, attribute_value.to_s, 'key')
+        # then pass to get
+        if key
+          @model_class.get(key.to_s)
+        else
+          @model_class.connection.remove(column_family, attribute_value.to_s)
+          nil
+        end
+      end
+      
+      def write(record)
+        @model_class.connection.insert(column_family, record.send(@attribute_name).to_s, {'key'=>record.key.to_s})
+      end
+      
+      def remove(record)
+        @model_class.connection.remove(column_family, record.send(@attribute_name).to_s)
+      end
+      
+      def column_family
+        @model_class.column_family + "By" + @attribute_name.to_s.camelize 
+      end
+      
+      def column_family_configuration
+        {:Name=>column_family, :CompareWith=>"UTF8Type"}
+      end
+    end
+    
+    class Index
+      def initialize(attribute_name, model_class, options)
+        @attribute_name = attribute_name
+        @model_class    = model_class
+        @reversed       = options[:reversed]
+      end
+      
+      def find(attribute_value, options = {})
+        cursor = CassandraObject::Cursor.new(@model_class, column_family, attribute_value.to_s, @attribute_name.to_s, :start_after=>options[:start_after], :reversed=>@reversed)
+        cursor.validator do |object|
+          object.send(@attribute_name) == attribute_value
+        end
+        cursor.find(options[:limit] || 100)
+      end
+      
+      def write(record)
+        @model_class.connection.insert(column_family, record.send(@attribute_name).to_s, {@attribute_name.to_s=>{new_key=>record.key.to_s}})
+      end
+      
+      def remove(record)
+      end
+      
+      def column_family
+        @model_class.column_family + "By" + @attribute_name.to_s.camelize 
+      end
+      
+      def new_key
+        SimpleUUID::UUID.new
+      end
+      
+      def column_family_configuration
+        {:Name=>column_family, :CompareWith=>"UTF8Type", :ColumnType=>"Super", :CompareSubcolumnsWith=>"TimeUUIDType"}
+      end
+      
+    end
+    
+    module ClassMethods
+      def column_family_configuration
+        if indexes
+          super + indexes.values.map(&:column_family_configuration)
+        else
+          super
+        end
+      end
+      
+      def index(attribute_name, options = {})
+        self.indexes ||= {}.with_indifferent_access
+        if options.delete(:unique)
+          self.indexes[attribute_name] = UniqueIndex.new(attribute_name, self, options)
+          class_eval <<-eom
+            def self.find_by_#{attribute_name}(value)
+              indexes[:#{attribute_name}].find(value)
+            end
+            
+            after_save do |record|
+              self.indexes[:#{attribute_name}].write(record)
+              true
+            end
+              
+            after_destroy do |record|
+              record.class.indexes[:#{attribute_name}].remove(record)
+              true
+            end
+          eom
+        else
+          self.indexes[attribute_name] = Index.new(attribute_name, self, options)
+          class_eval <<-eom
+            def self.find_all_by_#{attribute_name}(value, options = {})
+              self.indexes[:#{attribute_name}].find(value, options)
+            end
+            
+            after_save do |record|
+              record.class.indexes[:#{attribute_name}].write(record)
+              true
+            end
+              
+            after_destroy do |record|
+              record.class.indexes[:#{attribute_name}].remove(record)
+              true
+            end
+          eom
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/log_subscriber.rb

@@ -0,0 +1,17 @@
+module CassandraObject
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def multi_get(event)
+      name = 'CassandraObject multi_get (%.1fms)'
+      keys = event.payload[:keys].join(" ")
+
+      debug "  #{name}  (#{keys.size}) #{keys}"
+    end
+
+    def remove(event)
+    end
+
+    def insert(event)
+    end
+  end
+end
+CassandraObject::LogSubscriber.attach_to :cassandra_object

data/lib/cassandra_object/migrations.rb

@@ -0,0 +1,72 @@
+module CassandraObject
+  module Migrations
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_array :migrations
+      class_inheritable_accessor :current_schema_version
+      self.current_schema_version = 0
+    end
+    
+    class Migration
+      attr_reader :version
+      def initialize(version, block)
+        @version = version
+        @block = block
+      end
+      
+      def run(attrs)
+        @block.call(attrs)
+      end
+    end
+    
+    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|
+          record.attributes_changed!(original_attributes.diff(attributes).keys)
+        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

data/lib/cassandra_object/persistence.rb

@@ -0,0 +1,195 @@
+module CassandraObject
+  module Persistence
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_writer :write_consistency
+      class_inheritable_writer :read_consistency
+    end
+
+    VALID_READ_CONSISTENCY_LEVELS = [:one, :quorum, :all]
+    VALID_WRITE_CONSISTENCY_LEVELS = VALID_READ_CONSISTENCY_LEVELS + [:zero]
+
+    module ClassMethods
+      def consistency_levels(levels)
+        if levels.has_key?(:write)
+          unless valid_write_consistency_level?(levels[:write])
+            raise ArgumentError, "Invalid write consistency level. Valid levels are: #{VALID_WRITE_CONSISTENCY_LEVELS.inspect}. You gave me #{levels[:write].inspect}"
+          end
+          self.write_consistency = levels[:write]
+        end
+
+        if levels.has_key?(:read)
+          unless valid_read_consistency_level?(levels[:read])
+            raise ArgumentError, "Invalid read consistency level. Valid levels are #{VALID_READ_CONSISTENCY_LEVELS.inspect}. You gave me #{levels[:write].inspect}"
+          end
+          self.read_consistency = levels[:read]
+        end
+      end
+
+      def write_consistency
+        read_inheritable_attribute(:write_consistency) || :quorum
+      end
+
+      def read_consistency
+        read_inheritable_attribute(:read_consistency) || :quorum
+      end
+
+      def get(key, options = {})
+        multi_get([key], options).values.first
+      end
+
+      def multi_get(keys, options = {})
+        options = {:consistency => self.read_consistency, :limit => 100}.merge(options)
+        unless valid_read_consistency_level?(options[:consistency])
+          raise ArgumentError, "Invalid read consistency level: '#{options[:consistency]}'. Valid options are [:quorum, :one]"
+        end
+
+        attribute_results = ActiveSupport::Notifications.instrument("multi_get.cassandra_object", :keys => keys) do
+          connection.multi_get(column_family, keys.map(&:to_s), :count=>options[:limit], :consistency=>consistency_for_thrift(options[:consistency]))
+        end
+
+        attribute_results.inject(ActiveSupport::OrderedHash.new) do |memo, (key, attributes)|
+          if attributes.empty?
+            memo[key] = nil
+          else
+            memo[parse_key(key)] = instantiate(key, attributes)
+          end
+          memo
+        end
+      end
+
+      def remove(key)
+        connection.remove(column_family, key.to_s, :consistency => write_consistency_for_thrift)
+      end
+
+      def all(keyrange = ''..'', options = {})
+        results = connection.get_range(column_family, :start => keyrange.first, :finish => keyrange.last, :count=>(options[:limit] || 100))
+        keys = results.map(&:key)
+        keys.map {|key| get(key) }
+      end
+
+      def first(keyrange = ''..'', options = {})
+        all(keyrange, options.merge(:limit=>1)).first
+      end
+
+      def create(attributes)
+        new(attributes).tap do |object|
+          object.save
+        end
+      end
+
+      def write(key, attributes, schema_version)
+        key.tap do |key|
+          connection.insert(column_family, key.to_s, encode_columns_hash(attributes, schema_version), :consistency => write_consistency_for_thrift)
+        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.keys.include?(k)}
+        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("@attributes", decode_columns_hash(attributes).with_indifferent_access)
+        end
+      end
+
+      def encode_columns_hash(attributes, schema_version)
+        attributes.inject(Hash.new) do |memo, (column_name, value)|
+          memo[column_name.to_s] = model_attributes[column_name].converter.encode(value)
+          memo
+        end.merge({"schema_version" => schema_version.to_s})
+      end
+
+      def decode_columns_hash(attributes)
+        attributes.inject(Hash.new) do |memo, (column_name, value)|
+          memo[column_name.to_s] = model_attributes[column_name].converter.decode(value)
+          memo
+        end
+      end
+      
+      def column_family_configuration
+        [{:Name=>column_family, :CompareWith=>"UTF8Type"}]
+      end
+
+      protected
+      def valid_read_consistency_level?(level)
+        !!VALID_READ_CONSISTENCY_LEVELS.include?(level)
+      end
+
+      def valid_write_consistency_level?(level)
+        !!VALID_WRITE_CONSISTENCY_LEVELS.include?(level)
+      end
+
+      def write_consistency_for_thrift
+        consistency_for_thrift(write_consistency)
+      end
+
+      def read_consistency_for_thrift
+        consistency_for_thrift(read_consistency)
+      end
+
+      def consistency_for_thrift(consistency)
+        {
+          :zero   => Cassandra::Consistency::ZERO,
+          :one    => Cassandra::Consistency::ONE, 
+          :quorum => Cassandra::Consistency::QUORUM,
+          :all    => Cassandra::Consistency::ALL
+        }[consistency]
+      end
+    end
+
+    module InstanceMethods
+      def save
+        run_callbacks :save do
+          create_or_update
+        end
+      end
+      
+      def create_or_update
+        if new_record?
+          create
+        else
+          update
+        end
+        true
+      end
+      
+      def create
+        run_callbacks :create do
+          @key ||= self.class.next_key(self)
+          _write
+          @new_record = false
+          true
+        end
+      end
+      
+      def update
+        run_callbacks :update do
+          _write
+        end
+      end
+      
+      def _write
+        changed_attributes = changed.inject({}) { |h, n| h[n] = read_attribute(n); h }
+        self.class.write(key, changed_attributes, schema_version)
+      end
+
+      def new_record?
+        @new_record || false
+      end
+
+      def destroy
+        run_callbacks :destroy do 
+          self.class.remove(key)
+        end
+      end
+      
+      def reload
+        self.class.get(self.key)
+      end
+      
+    end
+  end
+end