eurydice 1.0.0-java

data/.gitignore

@@ -0,0 +1 @@
+/ext

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format doc
+

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use jruby-1.6.2@eurydice

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+gemspec
+
+group :development do
+  gem 'jruby-openssl'
+  gem 'rake'
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    eurydice (1.0.0-java)
+      pelops-jars (= 1.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bouncy-castle-java (1.5.0146.1)
+    cassandra-jars (0.8.0-java)
+    diff-lcs (1.1.2)
+    jruby-openssl (0.7.4)
+      bouncy-castle-java
+    pelops-jars (1.2-java)
+      cassandra-jars (~> 0.8.0)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  eurydice!
+  jruby-openssl
+  rake
+  rspec

data/README.mdown

@@ -0,0 +1,25 @@
+# Eurydice
+
+Eurydice is a Cassandra client library for JRuby built on top of [Pelops](https://github.com/s7/scale7-pelops).
+
+See the `examples` directory and the specs for usage.
+
+## Installation & requirements
+
+Tested with JRuby 1.6.2 in 1.9 mode and Cassandra 0.8.1.
+
+    gem install eurydice
+    
+This will also install two dependencies: `pelops-jars` and `cassandra-jars` which contain the Pelops and Cassandra JAR files.
+
+## Contributors
+
+Theo Hultberg, [@iconara](http://twitter.com/iconara)
+
+## License
+
+Eurydice is licensed under the [MIT License](http://www.opensource.org/licenses/mit-license.php), the same as Pelops.
+
+## Eurydice?
+
+Eurydice was the daughter of Pelops (but she's not _that_ [Eurydice](http://en.wikipedia.org/wiki/Eurydice)).

data/eurydice.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+$: << File.expand_path('../lib', __FILE__)
+
+require 'eurydice/version'
+
+
+Gem::Specification.new do |s|
+  s.name        = 'eurydice'
+  s.version     = Eurydice::VERSION
+  s.platform    = 'java'
+  s.authors     = ['Theo Hultberg']
+  s.email       = ['theo@burtcorp.com']
+  s.homepage    = 'http://github.com/iconara/eurydice'
+  s.summary     = %q{Ruby wrapper for the Pelops library}
+  s.description = %q{}
+
+  s.rubyforge_project = 'eurydice'
+  
+  s.add_dependency 'pelops-jars', '= 1.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = %w(lib)
+end

data/examples/01_connect.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require_relative 'common'
+
+
+# Connect to the default host (localhost) and port (9160), these can be
+# overridden by passing then :host and :port options.
+cluster = Eurydice.connect
+
+# Get a reference to a keyspace, it will be created if it does not exist
+# (pass the option :create => false to not automatically create the keyspace).
+keyspace = cluster.keyspace('my_keyspace')
+
+# Clean up by dropping the keyspace
+keyspace.drop!
+
+# Finally disconnect everything
+Eurydice.disconnect!

data/examples/02_create_keyspace.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require_relative 'common'
+
+
+cluster = Eurydice.connect
+
+# Get a reference to a keyspace, but don't automatically create it, instead
+# we will create it explicitly, and with a few options.
+keyspace = cluster.keyspace('my_keyspace', :create => false)
+
+# Create the keyspace with some options, the possible options can be found
+# here: http://www.datastax.com/docs/0.8/configuration/storage_configuration
+keyspace.create!(
+  :strategy_class => 'org.apache.cassandra.locator.NetworkTopologyStrategy',
+  :strategy_options => {:replication_factor => 3}
+)
+
+keyspace.drop!

data/examples/03_create_column_family.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require_relative 'common'
+
+
+cluster = Eurydice.connect
+keyspace = cluster.keyspace('my_keyspace')
+
+# Get a reference to a column family, but don't automatically create it, 
+# instead we will create it explicitly, and with a few options.
+column_family = keyspace.column_family('my_family', :create => false)
+
+# Create the column family with some options, the possible options can be found
+# here: http://www.datastax.com/docs/0.8/configuration/storage_configuration
+column_family.create!(
+  :key_validation_class => :ascii,    # the type of the row keys
+  :comparator_type => :ascii,         # the type of the column keys
+  :default_validation_class => :utf8, # the type of the column values
+  :column_metadata => {
+    'name' => {
+      :validation_class => :utf8,     # you can declare the types of columns
+      :index_name => 'name_index',    # and set up indexing
+      :index_type => :keys
+    }
+  }
+)
+
+keyspace.drop!

data/examples/04_storing_data.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require_relative 'common'
+
+
+cluster = Eurydice.connect
+keyspace = cluster.keyspace('my_keyspace')
+column_family = keyspace.column_family('employees')
+
+# Insert a few rows representing employees
+column_family.insert('employee:1', {'name' => 'Sam', 'role' => 'Developer'})
+column_family.insert('employee:2', {'name' => 'Phil', 'role' => 'Accountant'})
+column_family.insert('employee:3', {'name' => 'Steve', 'role' => 'Developer'})
+column_family.insert('employee:4', {'name' => 'Julie', 'role' => 'CEO'})
+
+# #insert is actually an alias for #update, in some cases it feels more 
+# natural to say "insert" than "update", but in the end the operations are the
+# same -- adding a column to a row (and adding a column that is already there
+# replaces the old value).
+column_family.update('employee:3', {'email' => 'steve@acme.com'})
+column_family.update('employee:3', {'role' => 'tester'})
+
+# If you want to insert numbers you must be explicit, unfortunately. Use the
+# :validations option to pass a hash of property types. Currently the only one
+# besides the default is :long (the default is to make the value a string and
+# then creating a byte array from the string, this works with the :bytes, 
+# :ascii and :utf8 validations [read "column value types"] if the string has
+# the right encoding).
+column_family.update('employee:2', {'age' => 44}, :validations => {'age' => :long})
+
+# You can specify :consistency_level as :one, :quorum, :all or :any (default is :one)
+column_family.update('employee:4', {'email' => 'boss@acme.com'}, :consistency_level => :quorum)
+
+# :cl is an alias for :consistency_level
+column_family.update('employee:1', {'email' => 'sam@acme.com'}, :cl => :one)
+
+keyspace.drop!

data/examples/05_loading_data.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require_relative 'common'
+
+
+cluster = Eurydice.connect
+keyspace = cluster.keyspace('my_keyspace')
+column_family = keyspace.column_family('employees', :create => false)
+column_family.create!(:column_metadata => {'name' => {:validation_class => :utf8, :index_name => 'name_index', :index_type => :keys}})
+column_family.insert('employee:1', {'name' => 'Sam', 'role' => 'Developer'})
+column_family.insert('employee:2', {'name' => 'Phil', 'role' => 'Accountant'})
+column_family.insert('employee:3', {'name' => 'Steve', 'role' => 'Developer'})
+column_family.insert('employee:4', {'name' => 'Julie', 'role' => 'CEO'})
+column_family.update('employee:3', {'email' => 'steve@acme.com'})
+column_family.update('employee:3', {'role' => 'tester'})
+column_family.update('employee:2', {'age' => 44}, :validations => {'age' => :long})
+column_family.update('employee:4', {'email' => 'boss@acme.com'}, :consistency_level => :quorum)
+column_family.update('employee:1', {'email' => 'sam@acme.com'}, :cl => :one)
+
+# Load a single row
+employee1 = column_family.get('employee:1')
+puts "employee:1 => #{employee1['name']}, #{employee1['role']}"
+
+# Load multiple rows
+employees = column_family.get(%w(employee:2 employee:3 employee:4))
+employees.each do |row_key, employee|
+  puts "#{row_key} => #{employee['name']}, #{employee['role']}"
+end
+
+puts '---'
+
+# Load only the specified columns
+employee1 = column_family.get('employee:1', :columns => %w(name))
+puts "employee:1 => #{employee1['name']}"
+
+employees = column_family.get(%w(employee:2 employee:3 employee:4), :columns => %w(name))
+employees.each do |row_key, employee|
+  puts "#{row_key} => #{employee['name']}"
+end
+
+puts '---'
+
+# Load only the value from a single column
+employee1_name = column_family.get_column('employee:1', 'name')
+puts "employee:1 => #{employee1_name}"
+
+puts '---'
+
+# If you've stored a number you have to specify :validations when loading, too
+employee2 = column_family.get('employee:2', :validations => {'age' => :long})
+puts "employee:2 => #{employee2['name']}, #{employee2['age']}"
+
+puts '---'
+
+# You can check if a row exists
+puts "Is there a employee:5? #{column_family.key?('employee:0') ? 'yes' : 'no'}"
+
+# #row_exists? is an alias for #key?
+puts "Is there a employee:1? #{column_family.row_exists?('employee:1') ? 'yes' : 'no'}"
+
+puts '---'
+
+# You can specify :consistency_level as :one, :quorum, :all or :any
+employee1 = column_family.get('employee:1', :consistency_level => :quorum)
+puts "employee:1 => #{employee1['email']}"
+
+puts '---'
+
+# If you have a row with lots of columns, you can iterate over them (in order)
+# with #each_column. Under the hood they will be loaded in batches
+column_family.update('employee:5', Hash[(0...1000).map { |i| ["property#{i}", "value#{i}"] }])
+count = 0
+column_family.each_column('employee:5') do |column_name, column_value|
+  count += 1
+end
+puts "There were #{count} columns"
+
+puts '---'
+
+# Cassandra has basic secondary indexes, which can be used when querying
+column_family.insert('employees:6', {'name' => 'Sam'})
+column_family.insert('employees:7', {'name' => 'Sam'})
+employees_named_sam = column_family.get_indexed('name', :==, 'Sam')
+puts "There are #{employees_named_sam.size} employees named 'Sam'"
+
+keyspace.drop!

data/examples/06_cluster_info.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require_relative 'common'
+
+
+cluster = Eurydice.connect
+
+# List the keyspaces
+puts 'Keyspaces:'
+cluster.keyspaces.each_with_index do |keyspace_name, i|
+  puts "#{i + 1}: #{keyspace_name}"
+end
+
+puts '---'
+
+# List the nodes in the cluster
+puts 'Nodes:'
+cluster.nodes.each_with_index do |node_address, i|
+  puts "#{i + 1}: #{node_address}"
+end

data/examples/common.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'eurydice'

data/lib/cassandra.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+
+module Thrift
+  import 'org.apache.thrift.transport.TTransportException'
+end
+
+module Cassandra
+  import 'org.apache.cassandra.thrift.ConsistencyLevel'
+  import 'org.apache.cassandra.thrift.IndexType'
+  import 'org.apache.cassandra.thrift.Column'
+  import 'org.apache.cassandra.thrift.KsDef'
+  import 'org.apache.cassandra.thrift.CfDef'
+  import 'org.apache.cassandra.thrift.ColumnDef'
+  import 'org.apache.cassandra.thrift.InvalidRequestException'
+  import 'org.apache.cassandra.thrift.SlicePredicate'
+  import 'org.apache.cassandra.thrift.SliceRange'
+  import 'org.apache.cassandra.thrift.IndexOperator'
+  
+  CONSISTENCY_LEVELS = {
+    :one    => Cassandra::ConsistencyLevel::ONE,
+    :quorum => Cassandra::ConsistencyLevel::QUORUM,
+    :all    => Cassandra::ConsistencyLevel::ALL,
+    :any    => Cassandra::ConsistencyLevel::ANY
+  }.freeze
+
+  MARSHAL_TYPES = {
+    :bytes        => 'org.apache.cassandra.db.marshal.BytesType'.freeze,
+    :ascii        => 'org.apache.cassandra.db.marshal.AsciiType'.freeze,
+    :utf8         => 'org.apache.cassandra.db.marshal.UTF8Type'.freeze,
+    :long         => 'org.apache.cassandra.db.marshal.LongType'.freeze,
+    :lexical_uuid => 'org.apache.cassandra.db.marshal.LexicalUUIDType'.freeze,
+    :time_uuid    => 'org.apache.cassandra.db.marshal.TimeUUIDType'.freeze
+  }.freeze
+  
+  INDEX_OPERATORS = {
+    :==  => IndexOperator::EQ,
+    :eq  => IndexOperator::EQ,
+    :>   => IndexOperator::GT,
+    :gt  => IndexOperator::GT,
+    :>=  => IndexOperator::GTE,
+    :gte => IndexOperator::GTE,
+    :<   => IndexOperator::LT,
+    :lt  => IndexOperator::LT,
+    :<=  => IndexOperator::LTE,
+    :lte => IndexOperator::LTE
+  }.freeze
+  
+  class KsDef
+    def self.from_h(h)
+      ks_def = h.reduce(self.new) do |ks_def, (field_name, field_value)|
+        case field_name.to_sym
+        when :strategy_options
+          field_value = Hash[field_value.map { |k, v| [k.to_s, v.to_s] }]
+        when :column_families
+          field_name = 'cf_defs'
+          field_value = field_value.map { |cf_name, cf_def_h| CfDef.from_h(cf_def_h.merge(:name => cf_name, :keyspace => h[:name])) }
+        end
+        field = self::_Fields.find_by_name(field_name.to_s)
+        raise ArgumentError, %(No field named "#{field_name}") unless field
+        ks_def.set_field_value(field, field_value)
+        ks_def
+      end
+      ks_def.cf_defs = java.util.Collections.emptyList unless ks_def.cf_defs
+      ks_def
+    end
+    
+    def to_h
+      self.class.metaDataMap.reduce({}) do |acc, (field, field_meta_data)|
+        field_name = field.field_name.to_sym
+        field_value = get_field_value(field)
+        case field_name.to_sym
+        when :cf_defs
+          cf_hs = field_value.map { |cf_def| cf_def.to_h }
+          acc[:column_families] = Hash[cf_hs.map { |cf_h| [cf_h[:name], cf_h] }]
+        when :strategy_options
+          acc[field_name] = Hash[field_value.map { |pair| [pair.first.to_sym, pair.last] }] # JRuby 1.6.2 Java Map doesn't splat when yielding
+        else
+          acc[field_name] = field_value
+        end
+        acc
+      end
+    end
+  end
+  
+  class CfDef
+    def self.from_h(h)
+      h.reduce(self.new) do |cf_def, (field_name, field_value)|
+        case field_name.to_sym
+        when :column_type
+          field_value = field_value.to_s.capitalize
+        when :key_validation_class, :default_validation_class, :comparator_type, :subcomparator_type
+          field_value = Cassandra::MARSHAL_TYPES.fetch(field_value, field_value)
+        when :column_metadata
+          field_value = field_value.map do |column_name, column_def_h|
+            Cassandra::ColumnDef.from_h(column_def_h.merge(:name => column_name))
+          end
+        end
+        field = self::_Fields.find_by_name(field_name.to_s)
+        raise ArgumentError, %(No field named "#{field_name}") unless field
+        cf_def.set_field_value(field, field_value)
+        cf_def
+      end
+    end
+    
+    def to_h
+      self.class.metaDataMap.reduce({:column_metadata => {}}) do |acc, (field, field_meta_data)|
+        field_name = field.field_name.to_sym
+        case field_name
+        when :column_metadata
+          column_hs = get_field_value(field).map { |col_def| col_def.to_h }
+          acc[field_name] = Hash[column_hs.map { |col_h| [col_h[:name], col_h] }]
+        when :column_type
+          acc[field_name] = get_field_value(field).downcase.to_sym
+        else
+          acc[field_name] = get_field_value(field)
+        end
+        acc
+      end
+    end
+  end
+  
+  class ColumnDef
+    def self.from_h(h)
+      h.reduce(self.new) do |col_def, (field_name, field_value)|
+        case field_name.to_sym
+        when :name
+          field_value = Eurydice::Pelops::ByteHelpers.to_nio_bytes(field_value)
+        when :index_type
+          field_value = Cassandra::IndexType.valueOf(field_value.to_s.upcase)
+        when :validation_class
+          field_value = MARSHAL_TYPES.fetch(field_value, field_value)
+        end
+        field = self::_Fields.find_by_name(field_name.to_s)
+        raise ArgumentError, %(No field named "#{field_name}") unless field
+        col_def.set_field_value(field, field_value)
+        col_def
+      end
+    end
+    
+    def to_h
+      self.class.metaDataMap.reduce({}) do |acc, (field, field_meta_data)|
+        field_name = field.field_name.to_sym
+        acc[field_name] = begin
+          case field_name
+          when :name
+            Eurydice::Pelops::ByteHelpers.nio_bytes_to_s(get_field_value(field))
+          when :index_type
+            value = get_field_value(field)
+            value.toString.downcase.to_sym if value
+          else
+            get_field_value(field)
+          end
+        end
+        acc
+      end
+    end
+  end
+end

data/lib/eurydice/pelops/cluster.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Eurydice
+  module Pelops
+    class Cluster
+      def initialize(cluster, driver=::Pelops::Pelops)
+        @cluster = cluster
+        @driver = driver
+      end
+    
+      def connected?
+        @driver.create_cluster_manager(@cluster).cassandra_version
+        true
+      rescue Exception => e
+        false
+      end
+    
+      def keyspace(keyspace_name, options={})
+        pool_name = options.fetch(:pool_name, "eurydice_#{keyspace_name}_pool")
+        create = options.fetch(:create, true)
+        @driver.add_pool(pool_name, @cluster, keyspace_name)
+        keyspace = Keyspace.new(keyspace_name, @cluster, pool_name, @driver)
+        keyspace.create! if create && !keyspace.exists?
+        keyspace
+      end
+    
+      def keyspaces
+        keyspace_manager.keyspace_names.map { |ks_def| ks_def.name }
+      end
+      
+      def nodes
+        @cluster.nodes.map { |n| n.address }
+      end
+    
+    private
+  
+      def keyspace_manager
+        @keyspace_manager ||= @driver.create_keyspace_manager(@cluster)
+      end
+    end
+  end
+end