cassandra-mavericks 0.21.1

data/conf/1.2/log4j-server.properties

@@ -0,0 +1,44 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# for production, you should probably set pattern to %c instead of %l.
+# (%l is slower.)
+
+# output messages into a rolling log file as well as stdout
+log4j.rootLogger=INFO,stdout,R
+
+# stdout
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%5p %d{HH:mm:ss,SSS} %m%n
+
+# rolling log file
+log4j.appender.R=org.apache.log4j.RollingFileAppender
+log4j.appender.R.maxFileSize=20MB
+log4j.appender.R.maxBackupIndex=50
+log4j.appender.R.layout=org.apache.log4j.PatternLayout
+log4j.appender.R.layout.ConversionPattern=%5p [%t] %d{ISO8601} %F (line %L) %m%n
+# Edit the next line to point to your logs directory
+log4j.appender.R.File=/var/log/cassandra/system.log
+
+# Application logging options
+#log4j.logger.org.apache.cassandra=DEBUG
+#log4j.logger.org.apache.cassandra.db=DEBUG
+#log4j.logger.org.apache.cassandra.service.StorageProxy=DEBUG
+
+# Adding this to avoid thrift logging disconnect errors.
+log4j.logger.org.apache.thrift.server.TNonblockingServer=ERROR
+

data/conf/1.2/schema.json

@@ -0,0 +1,72 @@
+{"Twitter":{
+    "Users":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "UserAudits":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "UserCounters":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard",
+      "default_validation_class":"CounterColumnType"},
+    "UserCounterAggregates":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super",
+      "default_validation_class":"CounterColumnType"},
+    "UserRelationships":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "Usernames":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "Statuses":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "StatusAudits":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "StatusRelationships":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "Indexes":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "TimelinishThings":{
+      "comparator_type":"org.apache.cassandra.db.marshal.BytesType",
+      "column_type":"Standard"}
+  },
+"Multiblog":{
+    "Blogs":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"},
+    "Comments":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"}
+  },
+"MultiblogLong":{
+    "Blogs":{
+      "comparator_type":"org.apache.cassandra.db.marshal.LongType",
+      "column_type":"Standard"},
+    "Comments":{
+      "comparator_type":"org.apache.cassandra.db.marshal.LongType",
+      "column_type":"Standard"}
+  },
+"TypeConversions":{
+    "UUIDColumnConversion":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"},
+    "SuperUUID":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Super"},
+    "CompositeColumnConversion":{
+      "comparator_type":"org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.IntegerType,org.apache.cassandra.db.marshal.UTF8Type)",
+      "column_type":"Standard"},
+    "DynamicComposite":{
+      "comparator_type":"org.apache.cassandra.db.marshal.DynamicCompositeType(u=>org.apache.cassandra.db.marshal.UUIDType,t=>org.apache.cassandra.db.marshal.TimeUUIDType,s=>org.apache.cassandra.db.marshal.UTF8Type,b=>org.apache.cassandra.db.marshal.BytesType,a=>org.apache.cassandra.db.marshal.AsciiType,l=>org.apache.cassandra.db.marshal.LongType,x=>org.apache.cassandra.db.marshal.LexicalUUIDType,i=>org.apache.cassandra.db.marshal.IntegerType)",
+      "column_type":"Standard"}
+  }
+}

data/conf/1.2/schema.txt

@@ -0,0 +1,57 @@
+create keyspace Twitter with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use Twitter;
+create column family Users with comparator = 'UTF8Type';
+create column family UserAudits with comparator = 'UTF8Type';
+create column family UserCounters with comparator = 'UTF8Type' and
+  default_validation_class = CounterColumnType;
+create column family UserCounterAggregates with column_type = 'Super'
+  and comparator = 'UTF8Type' and
+  subcomparator = 'UTF8Type' and
+  default_validation_class = CounterColumnType;
+create column family UserRelationships with
+  comparator = 'UTF8Type' and
+  column_type = 'Super' and
+  subcomparator = 'TimeUUIDType';
+create column family Usernames with comparator = 'UTF8Type';
+create column family Statuses
+  with comparator = 'UTF8Type'
+  and column_metadata = [
+    {column_name: 'tags', validation_class: 'BytesType', index_type: 'KEYS'}
+  ];
+create column family StatusAudits with comparator = 'UTF8Type';
+create column family StatusRelationships with
+  comparator = 'UTF8Type' and
+  column_type = 'Super' and
+  subcomparator = 'TimeUUIDType';
+create column family Indexes with
+  comparator = 'UTF8Type' and
+  column_type = 'Super';
+create column family TimelinishThings with
+  comparator = 'BytesType';
+
+create keyspace Multiblog with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use Multiblog;
+create column family Blogs with comparator = 'TimeUUIDType';
+create column family Comments with comparator = 'TimeUUIDType';
+
+
+create keyspace MultiblogLong with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use MultiblogLong;
+create column family Blogs with comparator = 'LongType';
+create column family Comments with comparator = 'LongType';
+
+create keyspace TypeConversions with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use TypeConversions;
+create column family UUIDColumnConversion with comparator = TimeUUIDType;
+create column family SuperUUID with comparator = TimeUUIDType and column_type = Super;
+create column family CompositeColumnConversion with comparator = 'CompositeType(IntegerType, UTF8Type)';
+create column family DynamicComposite with comparator ='DynamicCompositeType
+   (a=>AsciiType,b=>BytesType,i=>IntegerType,x=>LexicalUUIDType,l=>LongType,t=>TimeUUIDType,s=>UTF8Type,u=>UUIDType)';

data/ext/cassandra_native.c

@@ -0,0 +1,69 @@
+#include <ruby.h>
+#include <arpa/inet.h>
+
+VALUE parts_ivar_id, types_ivar_id, hash_ivar_id;
+
+VALUE rb_cassandra_composite_fast_unpack(VALUE self, VALUE packed_string_value) {
+  int index = 0;
+  int message_length = RSTRING_LEN(packed_string_value);
+  char *packed_string = (char *)RSTRING_PTR(packed_string_value);
+
+  VALUE parts = rb_ary_new();
+  while (index < message_length) {
+    uint16_t length = ntohs(((uint16_t *)(packed_string+index))[0]);
+    VALUE part = rb_str_new(packed_string+index+2, length);
+    rb_ary_push(parts, part);
+    index += length + 3;
+  }
+
+  rb_ivar_set(self, parts_ivar_id, parts);
+  rb_ivar_set(self, hash_ivar_id, rb_funcall(packed_string_value, rb_intern("hash"), 0));
+
+  return Qnil;
+}
+
+VALUE rb_cassandra_dynamic_composite_fast_unpack(VALUE self, VALUE packed_string_value) {
+  int index = 0;
+  int message_length = RSTRING_LEN(packed_string_value);
+  char *packed_string = (char *)RSTRING_PTR(packed_string_value);
+  uint16_t length;
+
+  VALUE parts = rb_ary_new();
+  VALUE types = rb_ary_new();
+  while (index < message_length) {
+    if (packed_string[index] & 0x80) {
+      VALUE type = rb_str_new(packed_string + index + 1, 1);
+      rb_ary_push(types, type);
+      index += 2;
+    } else {
+      length = ntohs(((uint16_t *)(packed_string+index))[0]);
+      VALUE type = rb_str_new(packed_string + index + 2, length);
+      rb_ary_push(types, type);
+      index += 2 + length;
+    }
+
+    length = ntohs(((uint16_t *)(packed_string+index))[0]);
+    VALUE part = rb_str_new(packed_string + index + 2, length);
+    rb_ary_push(parts, part);
+    index += length + 3;
+  }
+
+  rb_ivar_set(self, parts_ivar_id, parts);
+  rb_ivar_set(self, types_ivar_id, types);
+  rb_ivar_set(self, hash_ivar_id, rb_funcall(packed_string_value, rb_intern("hash"), 0));
+
+  return Qnil;
+}
+
+void Init_cassandra_native(void) {
+  VALUE cassandra_module = rb_const_get(rb_cObject, rb_intern("Cassandra"));
+  VALUE cassandra_composite_class = rb_define_class_under(cassandra_module, "Composite", rb_cObject);
+  rb_define_method(cassandra_composite_class, "fast_unpack", rb_cassandra_composite_fast_unpack, 1);
+
+  VALUE dynamic_composite = rb_const_get(cassandra_module, rb_intern("DynamicComposite"));
+  rb_define_method(dynamic_composite, "fast_unpack", rb_cassandra_dynamic_composite_fast_unpack, 1);
+
+  parts_ivar_id = rb_intern("@parts");
+  types_ivar_id = rb_intern("@types");
+  hash_ivar_id = rb_intern("@hash");
+}

data/ext/extconf.rb

@@ -0,0 +1,9 @@
+if (defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/) or ENV['OS'] == "Windows_NT"
+  File.open('Makefile', 'w'){|f| f.puts "all:\n\ninstall:\n" }
+else
+  require 'mkmf'
+
+  $CFLAGS = "-g -O2 -Wall -Werror"
+
+  create_makefile 'cassandra_native'
+end

data/lib/cassandra.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+gem 'thrift_client-mavericks', '~> 0.7'
+require 'thrift_client'
+gem 'simple_uuid' , '~> 0.2.0'
+require 'simple_uuid'
+
+require 'json' unless defined?(JSON)
+
+here = File.expand_path(File.dirname(__FILE__))
+
+class Cassandra ; end
+unless Cassandra.respond_to?(:VERSION)
+  require "#{here}/cassandra/0.8"
+end
+
+$LOAD_PATH << "#{here}/../vendor/#{Cassandra.VERSION}/gen-rb"
+require "#{here}/../vendor/#{Cassandra.VERSION}/gen-rb/cassandra"
+
+$LOAD_PATH << "#{here}"
+
+require 'cassandra/helpers'
+require 'cassandra/array'
+require 'cassandra/time'
+require 'cassandra/comparable'
+require 'cassandra/long'
+require 'cassandra/composite'
+require 'cassandra/dynamic_composite'
+require 'cassandra/ordered_hash'
+require 'cassandra/columns'
+require 'cassandra/protocol'
+require 'cassandra/batch'
+require "cassandra/#{Cassandra.VERSION}/columns"
+require "cassandra/#{Cassandra.VERSION}/protocol"
+require "cassandra/cassandra"
+require "cassandra/#{Cassandra.VERSION}/cassandra"
+unless Cassandra.VERSION.eql?("0.6")
+  require "cassandra/column_family"
+  require "cassandra/keyspace"
+end
+require 'cassandra/constants'
+require 'cassandra/debug' if ENV['DEBUG']
+
+begin
+  require "cassandra_native"
+rescue LoadError
+  puts "Unable to load cassandra_native extension. Defaulting to pure Ruby libraries."
+end

data/lib/cassandra/0.6.rb

@@ -0,0 +1,7 @@
+class Cassandra
+  def self.VERSION
+    "0.6"
+  end
+end
+
+require "#{File.expand_path(File.dirname(__FILE__))}/../cassandra"

data/lib/cassandra/0.6/cassandra.rb

@@ -0,0 +1,113 @@
+class Cassandra
+  def self.DEFAULT_TRANSPORT_WRAPPER
+    Thrift::BufferedTransport
+  end
+
+  ##
+  # Issues a login attempt using the username and password specified.
+  #
+  # * username
+  # * password
+  #
+  def login!(username, password)
+    @auth_request = CassandraThrift::AuthenticationRequest.new
+    @auth_request.credentials = {'username' => username, 'password' => password}
+    client.login(@keyspace, @auth_request)
+  end
+
+  def inspect
+    "#<Cassandra:#{object_id}, @keyspace=#{keyspace.inspect}, @schema={#{
+      schema(false).map {|name, hash| ":#{name} => #{hash['type'].inspect}"}.join(', ')
+    }}, @servers=#{servers.inspect}>"
+  end
+
+  ##
+  # Returns an array of available keyspaces.
+  #
+  def keyspaces
+    @keyspaces ||= client.describe_keyspaces()
+  end
+
+  ##
+  # Remove all rows in the column family you request.
+  #
+  # * column_family
+  # * options
+  #   * consitency
+  #   * timestamp
+  #
+  def clear_column_family!(column_family, options = {})
+    each_key(column_family) do |key|
+      remove(column_family, key, options)
+    end
+  end
+  alias truncate! clear_column_family!
+
+  # Remove all rows in the keyspace. Supports options <tt>:consistency</tt> and
+  # <tt>:timestamp</tt>.
+  # FIXME May not currently delete all records without multiple calls. Waiting
+  # for ranged remove support in Cassandra.
+  def clear_keyspace!(options = {})
+    schema.keys.each { |column_family| clear_column_family!(column_family, options) }
+  end
+
+  # Open a batch operation and yield self. Inserts and deletes will be queued
+  # until the block closes, and then sent atomically to the server.  Supports
+  # the <tt>:consistency</tt> option, which overrides the consistency set in
+  # the individual commands.
+  def batch(options = {})
+    _, _, _, options = 
+      extract_and_validate_params(schema.keys.first, "", [options], WRITE_DEFAULTS)
+
+    @batch = []
+    yield(self)
+    compacted_map,seen_clevels = compact_mutations!
+    clevel = if options[:consistency] != nil # Override any clevel from individual mutations if 
+               options[:consistency]
+             elsif seen_clevels.length > 1 # Cannot choose which CLevel to use if there are several ones
+               raise "Multiple consistency levels used in the batch, and no override...cannot pick one" 
+             else # if no consistency override has been provided but all the clevels in the batch are the same: use that one
+               seen_clevels.first
+             end
+
+    _mutate(compacted_map,clevel)
+  ensure
+    @batch = nil
+  end
+
+  protected
+
+  def schema(load=true)
+    if !load && !@schema
+      []
+    else
+      @schema ||= client.describe_keyspace(@keyspace)
+    end
+  end
+
+  def client
+    reconnect! if @client.nil?
+    @client
+  end
+
+  def reconnect!
+    @servers = all_nodes
+    @client = new_client
+  end
+
+  def all_nodes
+    if @auto_discover_nodes
+      temp_client = new_client
+      begin
+        ips = ::JSON.parse(temp_client.get_string_property('token map')).values
+        port = @servers.first.split(':').last
+        ips.map{|ip| "#{ip}:#{port}" }
+      ensure 
+        temp_client.disconnect!
+      end
+    else
+      @servers
+    end
+  end
+
+end

data/lib/cassandra/0.6/columns.rb

@@ -0,0 +1,78 @@
+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_family_property(column_family, key)
+      unless schema[column_family]
+        raise AccessError, "Invalid column family \"#{column_family}\""
+      end
+      schema[column_family][key]
+    end
+
+    def _standard_insert_mutation(column_family, column_name, value, timestamp, _=nil)
+      CassandraThrift::Mutation.new(
+        :column_or_supercolumn => CassandraThrift::ColumnOrSuperColumn.new(
+          :column => CassandraThrift::Column.new(
+            :name      => column_name_class(column_family).new(column_name).to_s,
+            :value     => value,
+            :timestamp => timestamp
+          )
+        )
+      )
+    end
+
+    def _super_insert_mutation(column_family, super_column_name, sub_columns, timestamp, _=nil)
+      CassandraThrift::Mutation.new(:column_or_supercolumn => 
+        CassandraThrift::ColumnOrSuperColumn.new(
+          :super_column => CassandraThrift::SuperColumn.new(
+            :name => column_name_class(column_family).new(super_column_name).to_s,
+            :columns => sub_columns.collect { |sub_column_name, sub_column_value|
+              CassandraThrift::Column.new(
+                :name      => sub_column_name_class(column_family).new(sub_column_name).to_s,
+                :value     => sub_column_value.to_s,
+                :timestamp => timestamp
+              )
+            }
+          )
+        )
+      )
+    end
+
+    # General info about a deletion object within a mutation
+    # timestamp - required. If this is the only param, it will cause deletion of the whole key at that TS
+    # supercolumn - opt. If passed, the deletes will only occur within that supercolumn (only subcolumns 
+    #               will be deleted). Otherwise the normal columns will be deleted.
+    # predicate - opt. Defines how to match the columns to delete. if supercolumn passed, the slice will 
+    #               be scoped to subcolumns of that supercolumn.
+    
+    # Deletes a single column from the containing key/CF (and possibly supercolumn), at a given timestamp. 
+    # Although mutations (as opposed to 'remove' calls) support deleting slices and lists of columns in one shot, this is not implemented here.
+    # The main reason being that the batch function takes removes, but removes don't have that capability...so we'd need to change the remove
+    # methods to use delete mutation calls...although that might have performance implications. We'll leave that refactoring for later.
+    def _delete_mutation(cf, column, subcolumn, timestamp, options={})
+      deletion_hash = {:timestamp => timestamp}
+      if is_super(cf)
+        deletion_hash[:super_column] = column if column
+        deletion_hash[:predicate] = CassandraThrift::SlicePredicate.new(:column_names => [subcolumn]) if subcolumn
+      else
+        deletion_hash[:predicate] = CassandraThrift::SlicePredicate.new(:column_names => [column]) if column
+      end
+      CassandraThrift::Mutation.new(
+        :deletion => CassandraThrift::Deletion.new(deletion_hash)
+      )
+    end
+  end
+end