cassandra 0.5.5 → 0.5.6

data/lib/cassandra/columns.rb

@@ -1,87 +0,0 @@
-
-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 assert_column_name_classes(column_family, columns, sub_columns = nil)      
-      {Array(columns) => column_name_class(column_family), 
-        Array(sub_columns) => sub_column_name_class(column_family)}.each do |columns, klass|
-        columns.each do |column|         
-          raise Comparable::TypeError, "Expected #{column.inspect} to be a #{klass}" if !column.is_a?(klass)
-        end 
-      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)
-      assert_column_name_classes(column_family, hash.keys)
-      hash.map do |column, value|
-        CassandraThrift::ColumnOrSuperColumn.new(:column => 
-          CassandraThrift::Column.new(:name => column.to_s, :value => value, :timestamp => timestamp))
-      end    
-    end
-    
-    def hash_to_super_columns(column_family, hash, timestamp)
-      assert_column_name_classes(column_family, hash.keys)      
-      hash.map do |column, sub_hash|
-        assert_column_name_classes(column_family, nil, sub_hash.keys)
-        sub_columns = sub_hash.map do |sub_column, value|
-          CassandraThrift::Column.new(:name => sub_column.to_s, :value => value, :timestamp => timestamp)
-        end    
-        CassandraThrift::ColumnOrSuperColumn.new(:super_column => 
-          CassandraThrift::SuperColumn.new(:name => column.to_s, :columns => sub_columns))
-      end
-    end    
-  end
-end

data/lib/cassandra/comparable.rb

@@ -1,28 +0,0 @@
-
-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

@@ -1,12 +0,0 @@
-
-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

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

data/lib/cassandra/long.rb

@@ -1,55 +0,0 @@
-
-class Cassandra
-  # A temporally-ordered Long class for use in Cassandra column names
-  class Long < Comparable
-
-    def initialize(bytes = nil)
-      case bytes
-      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, "Malformed UUID-like representation" if elements.size != 3
-          @bytes = elements.join.to_a.pack('H32')
-        else
-          raise TypeError, "8 bytes required for byte array, or 18 characters required for UUID-like representation"
-        end
-      when Integer
-        raise TypeError, "Integer must be between 0 and 2**64" 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, "Can't convert from #{bytes.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

@@ -1,135 +0,0 @@
-
-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

@@ -1,74 +0,0 @@
-
-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 _get(column_family, key, 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)
-        @client.get(@keyspace, key, column_path, consistency).column.value
-      elsif !is_super(column_family) and column
-        column_path = CassandraThrift::ColumnPath.new(:column_family => column_family, :column => column)
-        @client.get(@keyspace, key, column_path, consistency).column.value
-
-      # Slices
-      else
-        # FIXME Comparable types in range are not enforced
-        predicate = CassandraThrift::SlicePredicate.new(:slice_range => 
-          CassandraThrift::SliceRange.new(
-            :reversed => reversed, 
-            :count => count, 
-            :start => start.to_s, 
-            :finish => finish.to_s))
-        
-        if is_super(column_family) and column
-          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => column)
-          sub_columns_to_hash(column_family, @client.get_slice(@keyspace, key, column_parent, predicate, consistency))
-        else
-          column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
-          columns_to_hash(column_family, @client.get_slice(@keyspace, key, column_parent, predicate, consistency))
-        end
-      end
-    end
-
-    def _get_range(column_family, start, finish, count, consistency)
-      # FIXME Consistency is ignored
-      @client.get_key_range(@keyspace, column_family, start.to_s, finish.to_s, count)
-    end
-  end
-end

data/lib/cassandra/safe_client.rb

@@ -1,21 +0,0 @@
-
-module CassandraThrift #:nodoc: all
-  module Cassandra
-    class SafeClient  
-      def initialize(client, transport)
-        @client = client 
-        @transport = transport
-      end
-      
-      def method_missing(*args)
-        @client.send(*args)
-      rescue IOError, UnavailableException
-        @transport.close rescue nil
-        @transport.open
-        raise if defined?(once)
-        once = true
-        retry
-      end
-    end
-  end
-end

data/lib/cassandra/time.rb

@@ -1,11 +0,0 @@
-
-class Time
-  def self.stamp
-    Time.now.stamp
-  end
-  
-  def stamp
-    to_i * 1_000_000 + usec
-  end
-end
-        

data/lib/cassandra/uuid.rb

@@ -1,109 +0,0 @@
-
-class Cassandra
-
-  # UUID format version 1, as specified in RFC 4122, with jitter in place of the mac address and sequence counter.
-  class UUID < Comparable
-
-    class InvalidVersion < StandardError #:nodoc:
-    end
-
-    GREGORIAN_EPOCH_OFFSET = 0x01B2_1DD2_1381_4000 # Oct 15, 1582
-
-    VARIANT = 0b1000_0000_0000_0000
-
-    def initialize(bytes = nil)
-      case bytes
-      when String
-        case bytes.size
-        when 16 # Raw byte array
-          @bytes = bytes
-        when 36 # Human-readable UUID representation; inverse of #to_guid
-          elements = bytes.split("-")
-          raise TypeError, "Malformed UUID representation" if elements.size != 5
-          @bytes = elements.join.to_a.pack('H32')
-        else
-          raise TypeError, "16 bytes required for byte array, or 36 characters required for UUID representation"
-        end
-
-      when Integer
-        raise TypeError, "Integer must be between 0 and 2**128" if bytes < 0 or bytes > 2**128
-        @bytes = [
-          (bytes >> 96) & 0xFFFF_FFFF,
-          (bytes >> 64) & 0xFFFF_FFFF,
-          (bytes >> 32) & 0xFFFF_FFFF,
-          bytes & 0xFFFF_FFFF
-        ].pack("NNNN")
-
-      when NilClass, Time
-        time = (bytes || Time).stamp * 10 + GREGORIAN_EPOCH_OFFSET
-        # See http://github.com/spectra/ruby-uuid/
-        @bytes = [
-          time & 0xFFFF_FFFF,
-          time >> 32,
-          ((time >> 48) & 0x0FFF) | 0x1000,
-          # Top 3 bytes reserved
-          rand(2**13) | VARIANT,
-          rand(2**16),
-          rand(2**32)
-        ].pack("NnnnnN")
-
-      else
-        raise TypeError, "Can't convert from #{bytes.class}"
-      end
-    end
-
-    def to_i
-      ints = @bytes.unpack("NNNN")
-      (ints[0] << 96) +
-      (ints[1] << 64) +
-      (ints[2] << 32) +
-      ints[3]
-    end
-
-    def version
-      time_high = @bytes.unpack("NnnQ")[2]
-      version = (time_high & 0xF000).to_s(16)[0].chr.to_i
-      version > 0 and version < 6 ? version : -1
-    end
-
-    def variant
-      @bytes.unpack('QnnN')[1] >> 13
-    end
-
-    def to_guid
-      elements = @bytes.unpack("NnnCCa6")
-      node = elements[-1].unpack('C*')
-      elements[-1] = '%02x%02x%02x%02x%02x%02x' % node
-      "%08x-%04x-%04x-%02x%02x-%s" % elements
-    end
-
-    def seconds
-      total_usecs / 1_000_000
-    end
-
-    def usecs
-      total_usecs % 1_000_000
-    end
-
-    def <=>(other)
-      total_usecs <=> other.send(:total_usecs)
-    end
-
-    def inspect(long = false)
-      "<Cassandra::UUID##{object_id} time: #{
-        Time.at(seconds).inspect
-      }, usecs: #{
-        usecs
-      } jitter: #{
-        @bytes.unpack('QQ')[1]
-      }" + (long ? ", version: #{version}, variant: #{variant}, guid: #{to_guid}>" :  ">")
-    end
-
-    private
-
-    def total_usecs
-      elements = @bytes.unpack("NnnQ")
-      (elements[0] + (elements[1] << 32) + ((elements[2] & 0x0FFF) << 48) - GREGORIAN_EPOCH_OFFSET) / 10
-    end
-  end
-end