cassandra 0.5.6 → 0.5.6.1

data/lib/cassandra/columns.rb

@@ -0,0 +1,101 @@
+
+class Cassandra
+  # A bunch of crap, mostly related to introspecting on column types
+  module Columns #:nodoc:
+    private
+    
+    def is_super(column_family)
+      @is_super[column_family] ||= column_family_property(column_family, 'Type') == "Super"
+    end
+    
+    def column_name_class(column_family)
+      @column_name_class[column_family] ||= column_name_class_for_key(column_family, "CompareWith")
+    end
+    
+    def sub_column_name_class(column_family)
+      @sub_column_name_class[column_family] ||= column_name_class_for_key(column_family, "CompareSubcolumnsWith")
+    end
+    
+    def column_name_class_for_key(column_family, comparator_key)
+      property = column_family_property(column_family, comparator_key)
+      property =~ /.*\.(.*?)$/
+      case $1
+      when "LongType" then Long
+      when "LexicalUUIDType", "TimeUUIDType" then UUID
+      else 
+        String # UTF8, Ascii, Bytes, anything else
+      end
+    end
+
+    def column_family_property(column_family, key)
+      @schema[column_family][key]
+    rescue NoMethodError
+      raise AccessError, "Invalid column family \"#{column_family}\""    
+    end
+    
+    def multi_column_to_hash!(hash)
+      hash.each do |key, column_or_supercolumn|
+        hash[key] = (column_or_supercolumn.column.value if column_or_supercolumn.column)
+      end
+    end
+    
+    def multi_columns_to_hash!(column_family, hash)
+      hash.each do |key, columns| 
+        hash[key] = columns_to_hash(column_family, columns)
+      end
+    end
+
+    def multi_sub_columns_to_hash!(column_family, hash)
+      hash.each do |key, sub_columns| 
+        hash[key] = sub_columns_to_hash(column_family, sub_columns)
+      end
+    end
+    
+    def columns_to_hash(column_family, columns)
+      columns_to_hash_for_classes(columns, column_name_class(column_family), sub_column_name_class(column_family))
+    end
+
+    def sub_columns_to_hash(column_family, columns)
+      columns_to_hash_for_classes(columns, sub_column_name_class(column_family))
+    end
+    
+    def columns_to_hash_for_classes(columns, column_name_class, sub_column_name_class = nil)
+      hash = OrderedHash.new
+      Array(columns).each do |c|
+        c = c.super_column || c.column if c.is_a?(CassandraThrift::ColumnOrSuperColumn)
+        hash[column_name_class.new(c.name)] = case c
+        when CassandraThrift::SuperColumn            
+          columns_to_hash_for_classes(c.columns, sub_column_name_class) # Pop the class stack, and recurse
+        when CassandraThrift::Column
+          c.value
+        end
+      end
+      hash    
+    end
+        
+    def hash_to_columns(column_family, hash, timestamp)
+      hash.map do |column, value|
+        CassandraThrift::ColumnOrSuperColumn.new(:column => 
+          CassandraThrift::Column.new(
+            :name => column_name_class(column_family).new(column).to_s, 
+            :value => value, 
+            :timestamp => timestamp))
+      end    
+    end
+    
+    def hash_to_super_columns(column_family, hash, timestamp)
+      hash.map do |column, sub_hash|
+        sub_columns = sub_hash.map do |sub_column, value|
+          CassandraThrift::Column.new(
+            :name => sub_column_name_class(column_family).new(sub_column).to_s, 
+            :value => value, 
+            :timestamp => timestamp)
+        end    
+        CassandraThrift::ColumnOrSuperColumn.new(:super_column => 
+          CassandraThrift::SuperColumn.new(
+            :name => column_name_class(column_family).new(column).to_s, 
+            :columns => sub_columns))
+      end
+    end    
+  end
+end

data/lib/cassandra/comparable.rb

@@ -0,0 +1,28 @@
+
+class Cassandra
+  # Abstract base class for comparable numeric column name types
+  class Comparable
+    class TypeError < ::TypeError #:nodoc:
+    end
+  
+    def <=>(other)
+      self.to_i <=> other.to_i
+    end
+    
+    def hash
+      @bytes.hash
+    end
+    
+    def eql?(other)
+      other.is_a?(Comparable) and @bytes == other.to_s
+    end    
+    
+    def ==(other)
+      self.to_i == other.to_i
+    end
+    
+    def to_s
+      @bytes
+    end
+  end
+end

data/lib/cassandra/constants.rb

@@ -0,0 +1,12 @@
+
+class Cassandra
+  # A helper module you can include in your own class. Makes it easier 
+  # to work with Cassandra subclasses.
+  module Constants
+    include Cassandra::Consistency
+        
+    UUID = Cassandra::UUID
+    Long = Cassandra::Long
+    OrderedHash = Cassandra::OrderedHash
+  end
+end

data/lib/cassandra/debug.rb

@@ -0,0 +1,7 @@
+
+class CassandraThrift::Cassandra::Client
+  def send_message(*args)
+    pp args
+    super
+  end
+end

data/lib/cassandra/long.rb

@@ -0,0 +1,58 @@
+
+class Cassandra
+  # A temporally-ordered Long class for use in Cassandra column names
+  class Long < Comparable
+  
+    # FIXME Should unify with or subclass Cassandra::UUID
+    def initialize(bytes = nil)
+      case bytes
+      when self.class # Long
+        @bytes = bytes.to_s
+      when String
+        case bytes.size
+        when 8 # Raw byte array
+          @bytes = bytes
+        when 18 # Human-readable UUID-like representation; inverse of #to_guid
+          elements = bytes.split("-")
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (malformed UUID-like representation)" if elements.size != 3
+          @bytes = elements.join.to_a.pack('H32')
+        else
+          raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (invalid bytecount)"
+        end
+      when Integer
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (integer out of range)" if bytes < 0 or bytes > 2**64
+        @bytes = [bytes >> 32, bytes % 2**32].pack("NN")
+      when NilClass, Time
+        # Time.stamp is 52 bytes, so we have 12 bytes of entropy left over
+        int = ((bytes || Time).stamp << 12) + rand(2**12)
+        @bytes = [int >> 32, int % 2**32].pack("NN")
+      else
+        raise TypeError, "Expected #{bytes.inspect} to cast to a #{self.class} (unknown source class)"
+      end
+    end
+
+    def to_i
+      @to_i ||= begin
+        ints = @bytes.unpack("NN")
+        (ints[0] << 32) +
+        ints[1]
+      end
+    end
+    
+    def to_guid
+      "%08x-%04x-%04x" % @bytes.unpack("Nnn")
+    end    
+
+    def inspect
+      "<Cassandra::Long##{object_id} time: #{
+        Time.at((to_i >> 12) / 1_000_000).inspect
+      }, usecs: #{
+        (to_i >> 12) % 1_000_000
+      }, jitter: #{
+        to_i % 2**12
+      }, guid: #{
+        to_guid
+      }>"
+    end
+  end
+end

data/lib/cassandra/ordered_hash.rb

@@ -0,0 +1,135 @@
+
+class Cassandra
+  # Hash is ordered in Ruby 1.9!
+  if RUBY_VERSION >= '1.9'
+    OrderedHash = ::Hash
+  else  
+    #  Copyright (c) 2004-2009 David Heinemeier Hansson
+    #  
+    #  Permission is hereby granted, free of charge, to any person obtaining
+    #  a copy of this software and associated documentation files (the
+    #  "Software"), to deal in the Software without restriction, including
+    #  without limitation the rights to use, copy, modify, merge, publish,
+    #  distribute, sublicense, and/or sell copies of the Software, and to
+    #  permit persons to whom the Software is furnished to do so, subject to
+    #  the following conditions:
+    #  
+    #  The above copyright notice and this permission notice shall be
+    #  included in all copies or substantial portions of the Software.
+    #  
+    #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    #  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    #  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    #  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    #  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    #  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    #  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  
+    class OrderedHash < Hash #:nodoc: all
+      require 'enumerator'    
+    
+      def self.[](*array)
+        hash = new
+        array.each_slice(2) { |key, value| hash[key] = value }
+        hash
+      end
+
+      def initialize(*args, &block)
+        super
+        @keys = []
+      end
+
+      def initialize_copy(other)
+        super
+        # make a deep copy of keys
+        @keys = other.keys
+      end
+
+      def []=(key, value)
+        @keys << key if !has_key?(key)
+        super
+      end
+
+      def delete(key)
+        if has_key? key
+          index = @keys.index(key)
+          @keys.delete_at index
+        end
+        super
+      end
+      
+      def delete_if
+        super
+        sync_keys!
+        self
+      end
+
+      def reject!
+        super
+        sync_keys!
+        self
+      end
+
+      def reject(&block)
+        dup.reject!(&block)
+      end
+
+      def keys
+        @keys.dup
+      end
+
+      def values
+        @keys.collect { |key| self[key] }
+      end
+
+      def to_hash
+        self
+      end
+
+      def each_key
+        @keys.each { |key| yield key }
+      end
+
+      def each_value
+        @keys.each { |key| yield self[key]}
+      end
+
+      def each
+        @keys.each {|key| yield [key, self[key]]}
+      end
+
+      alias_method :each_pair, :each
+
+      def clear
+        super
+        @keys.clear
+        self
+      end
+
+      def shift
+        k = @keys.first
+        v = delete(k)
+        [k, v]
+      end
+
+      def merge!(other_hash)
+        other_hash.each {|k,v| self[k] = v }
+        self
+      end
+
+      def merge(other_hash)
+        dup.merge!(other_hash)
+      end
+
+      def inspect
+        "#<OrderedHash #{super}>"
+      end
+
+    private
+
+      def sync_keys!
+        @keys.delete_if {|k| !has_key?(k)}
+      end
+    end
+  end
+end

data/lib/cassandra/protocol.rb

@@ -0,0 +1,72 @@
+
+class Cassandra
+  # Inner methods for actually doing the Thrift calls
+  module Protocol #:nodoc:
+    private
+
+    def _mutate(mutation, consistency)
+      @client.batch_mutate(@keyspace, mutation, consistency)
+    end
+
+    def _count_columns(column_family, key, super_column, consistency)
+      @client.get_count(@keyspace, key,
+        CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
+        consistency
+      )
+    end
+
+    def _get_columns(column_family, key, columns, sub_columns, consistency)
+      result = if is_super(column_family)
+        if sub_columns
+          columns_to_hash(column_family, @client.get_slice(@keyspace, key,
+            CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => columns),
+            CassandraThrift::SlicePredicate.new(:column_names => sub_columns),
+            consistency))
+        else
+          columns_to_hash(column_family, @client.get_slice(@keyspace, key,
+            CassandraThrift::ColumnParent.new(:column_family => column_family),
+            CassandraThrift::SlicePredicate.new(:column_names => columns),
+            consistency))
+        end
+      else
+        columns_to_hash(column_family, @client.get_slice(@keyspace, key,
+          CassandraThrift::ColumnParent.new(:column_family => column_family),
+          CassandraThrift::SlicePredicate.new(:column_names => columns),
+          consistency))
+      end
+      sub_columns || columns.map { |name| result[name] }
+    end
+
+    def _multiget(column_family, keys, column, sub_column, count, start, finish, reversed, consistency)
+      # Single values; count and range parameters have no effect
+      if is_super(column_family) and sub_column
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :super_column => column, :column => sub_column)
+        multi_column_to_hash!(@client.multiget(@keyspace, keys, column_path, consistency))
+      elsif !is_super(column_family) and column
+        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column)
+        multi_column_to_hash!(@client.multiget(@keyspace, keys, column_path, consistency))
+
+      # Slices
+      else
+        predicate = CassandraThrift::SlicePredicate.new(:slice_range => 
+          CassandraThrift::SliceRange.new(
+            :reversed => reversed, 
+            :count => count, 
+            :start => start, 
+            :finish => finish))
+        
+        if is_super(column_family) and column
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
+          multi_sub_columns_to_hash!(column_family, @client.multiget_slice(@keyspace, keys, column_parent, predicate, consistency))
+        else
+          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
+          multi_columns_to_hash!(column_family, @client.multiget_slice(@keyspace, keys, column_parent, predicate, consistency))
+        end
+      end
+    end
+
+    def _get_range(column_family, start, finish, count, consistency)
+      @client.get_key_range(@keyspace, column_family, start, finish, count, consistency)
+    end
+  end
+end

data/lib/cassandra/safe_client.rb

@@ -0,0 +1,26 @@
+
+module CassandraThrift #:nodoc: all
+  module Cassandra
+  
+    class SafeClient  
+      def initialize(client, transport, reset = false)
+        @client = client 
+        @transport = transport
+        @reset = reset
+      end
+      
+      def reset_transport
+        @transport.close rescue nil
+        @transport.open
+      end
+      
+      def method_missing(*args)
+        reset_transport if @reset
+        @client.send(*args)
+      rescue IOError, UnavailableException, Thrift::ProtocolException, Thrift::ApplicationException, Thrift::TransportException
+        reset_transport
+        @client.send(*args)
+      end
+    end
+  end
+end