eurydice 1.0.0-java

data/lib/eurydice/pelops/column_family.rb

@@ -0,0 +1,217 @@
+# encoding: utf-8
+
+module Eurydice
+  module Pelops
+    class ColumnFamily
+      include ExceptionHelpers
+      include ByteHelpers
+    
+      attr_reader :name, :keyspace
+    
+      def initialize(keyspace, name)
+        @keyspace, @name = keyspace, name
+      end
+    
+      def definition(reload=true)
+        @definition = nil if reload
+        @definition ||= @keyspace.definition(true)[:column_families][@name]
+      end
+    
+      def exists?
+        !!definition(true)
+      end
+    
+      def create!(options={})
+        thrift_exception_handler do
+          @keyspace.column_family_manger.add_column_family(Cassandra::CfDef.from_h(options.merge(:keyspace => @keyspace.name, :name => @name)))
+        end
+      end
+    
+      def drop!
+        thrift_exception_handler do
+          @keyspace.column_family_manger.drop_column_family(@name)
+        end
+      end
+    
+      def truncate!
+        thrift_exception_handler do
+          @keyspace.column_family_manger.truncate_column_family(@name)
+        end
+      end
+    
+      def delete(row_key, options={})
+        thrift_exception_handler do
+          deletor = @keyspace.create_row_deletor
+          deletor.delete_row(@name, row_key, get_cl(options))
+        end
+      end
+    
+      def delete_column(row_key, column_key, options={})
+        thrift_exception_handler do
+          mutator = @keyspace.create_mutator
+          mutator.delete_column(@name, row_key, to_pelops_bytes(column_key))
+          mutator.execute(get_cl(options))
+        end
+      end
+    
+      def delete_columns(row_key, column_keys, options={})
+        thrift_exception_handler do
+          mutator = @keyspace.create_mutator
+          mutator.delete_columns(@name, row_key, column_keys.map { |k| to_pelops_bytes(k) })
+          mutator.execute(get_cl(options))
+        end
+      end
+    
+      def update(row_key, properties, options={})
+        thrift_exception_handler do
+          types = options[:validations] || {}
+          key_type = options[:comparator]
+          mutator = @keyspace.create_mutator
+          columns = properties.map do |k, v|
+            key = to_pelops_bytes(k, key_type)
+            value = to_pelops_bytes(v, types[k])
+            ttl = options.fetch(:ttl, mutator.class::NO_TTL)
+            mutator.new_column(key, value, ttl)
+          end
+          mutator.write_columns(@name, row_key, columns)
+          mutator.execute(get_cl(options))
+        end
+      end
+      alias_method :insert, :update
+    
+      def key?(row_key, options={})
+        thrift_exception_handler do
+          selector = @keyspace.create_selector
+          predicate = Cassandra::SlicePredicate.new
+          count = selector.get_column_count(@name, row_key, get_cl(options))
+          count > 0
+        end
+      end
+      alias_method :row_exists?, :key?
+    
+      def get(row_or_rows, options={})
+        case row_or_rows
+        when Array then get_multi(row_or_rows, options)
+        else get_single(row_or_rows, options)
+        end
+      end
+      alias_method :get_row, :get
+      alias_method :get_rows, :get
+      
+      def get_column(row_key, column_key, options={})
+        thrift_exception_handler do
+          selector = @keyspace.create_selector
+          column = selector.get_column_from_row(@name, row_key, column_key, get_cl(options))
+          byte_array_to_s(column.get_value)
+        end
+      rescue NotFoundError => e
+        nil
+      end
+      
+      def each_column(row_key, options={})
+        thrift_exception_handler do
+          reversed = options.fetch(:reversed, false)
+          batch_size = options.fetch(:batch_size, 100)
+          start_beyond = options.fetch(:start_beyond, nil)
+          start_beyond = to_pelops_bytes(start_beyond) if start_beyond
+          selector = @keyspace.create_selector
+          iterator = selector.iterate_columns_from_row(@name, to_pelops_bytes(row_key), start_beyond, reversed, batch_size, get_cl(options))
+          if block_given?
+            iterator.each do |column|
+              yield column_to_kv(column, options)
+            end
+          else
+            Enumerator.new do |y|
+              iterator.each do |column|
+                y << column_to_kv(column, options)
+              end
+            end
+          end
+        end
+      end
+      
+      def get_indexed(column_key, operator, value, options={})
+        thrift_exception_handler do
+          selector = @keyspace.create_selector
+          op = Cassandra::INDEX_OPERATORS[operator]
+          max_rows = options.fetch(:max_row_count, 20)
+          types = options[:validations] || {}
+          key_type = options[:comparator]
+          raise ArgumentError, %(Unsupported index operator: "#{operator}") unless op
+          index_expression = selector.class.new_index_expression(to_pelops_bytes(column_key, key_type), op, to_pelops_bytes(value, types[column_key]))
+          index_clause = selector.class.new_index_clause(empty_pelops_bytes, max_rows, index_expression)
+          column_predicate = create_column_predicate(options)
+          rows = selector.get_indexed_columns(@name, index_clause, column_predicate, get_cl(options))
+          rows_to_h(rows, options)
+        end
+      end
+      
+    private
+    
+      def get_single(row_key, options={})
+        thrift_exception_handler do
+          selector = @keyspace.create_selector
+          column_predicate = create_column_predicate(options)
+          columns = selector.get_columns_from_row(@name, to_pelops_bytes(row_key), column_predicate, get_cl(options))
+          columns_to_h(columns, options)
+        end
+      end
+    
+      def get_multi(row_keys, options={})
+        thrift_exception_handler do
+          selector = @keyspace.create_selector
+          column_predicate = create_column_predicate(options)
+          byte_row_keys = row_keys.map { |rk| to_pelops_bytes(rk) }
+          rows = selector.get_columns_from_rows(@name, byte_row_keys, column_predicate, get_cl(options))
+          rows_to_h(rows, options)
+        end
+      end
+      
+      def create_column_predicate(options)
+        max_column_count = options.fetch(:max_column_count, java.lang.Integer::MAX_VALUE)
+        reversed = options.fetch(:reversed, false)
+        case options[:columns]
+        when Range
+          ::Pelops::Selector.new_columns_predicate(to_pelops_bytes(options[:columns].begin), to_pelops_bytes(options[:columns].end), reversed, max_column_count)
+        when Array
+          ::Pelops::Selector.new_columns_predicate(*options[:columns].map { |col| to_pelops_bytes(col) })
+        else
+          ::Pelops::Selector.new_columns_predicate_all(reversed, max_column_count)
+        end
+      end
+    
+      def rows_to_h(rows, options)
+        rows.reduce({}) do |acc, (row_key, columns)|
+          columns_h = columns_to_h(columns, options)
+          acc[pelops_bytes_to_s(row_key)] = columns_h if columns_h && !columns_h.empty?
+          acc
+        end
+      end
+  
+      def columns_to_h(columns, options)
+        if columns.empty?
+          nil
+        else
+          columns.reduce({}) do |acc, column|
+            key, value = column_to_kv(column, options)
+            acc[key] = value
+            acc
+          end
+        end
+      end
+      
+      def column_to_kv(column, options)
+        types = options[:validations] || {}
+        key_type = options[:comparator]
+        key = byte_array_to_s(column.get_name, key_type)
+        value = byte_array_to_s(column.get_value, types[key])
+        return key, value
+      end
+  
+      def get_cl(options)
+        cl = options.fetch(:consistency_level, options.fetch(:cl, :one))
+        Cassandra::CONSISTENCY_LEVELS[cl]
+      end
+    end
+  end
+end

data/lib/eurydice/pelops/keyspace.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+module Eurydice
+  module Pelops
+    class Keyspace
+      include ExceptionHelpers
+    
+      attr_reader :name
+    
+      def initialize(name, cluster, pool_name, driver)
+        @name = name
+        @cluster = cluster
+        @pool_name = pool_name
+        @driver = driver
+      end
+    
+      def definition(reload=false)
+        thrift_exception_handler do
+          @definition = nil if reload
+          @definition ||= keyspace_manager.get_keyspace_schema(@name).to_h
+          @definition
+        end
+      end
+        
+      def exists?
+        keyspace_manager.keyspace_names.map { |ks_def| ks_def.name }.include?(@name)
+      end
+    
+      def create!(options={})
+        thrift_exception_handler do
+          ks_def = Cassandra::KsDef.from_h({:strategy_class => 'org.apache.cassandra.locator.LocalStrategy'}.merge(options).merge(:name => @name))
+          keyspace_manager.add_keyspace(ks_def)
+          @driver.add_pool(@pool_name, @cluster, @name)
+        end
+      end
+    
+      def drop!
+        keyspace_manager.drop_keyspace(@name)
+      rescue Exception => e
+        transform_thrift_exception(e)
+      end
+    
+      def column_families(reload=false)
+        definition(reload)[:column_families].keys
+      end
+    
+      def column_family(name, options={})
+        create = options.fetch(:create, true)
+        cf = ColumnFamily.new(self, name)
+        cf.create! if create && !cf.exists?
+        cf
+      end
+    
+      def create_mutator
+        @driver.create_mutator(@pool_name)
+      end
+    
+      def create_selector
+        @driver.create_selector(@pool_name)
+      end
+    
+      def create_row_deletor
+        @driver.create_row_deletor(@pool_name)
+      end
+
+      def keyspace_manager
+        @keyspace_manager ||= @driver.create_keyspace_manager(@cluster)
+      end
+    
+      def column_family_manger
+        @column_family_manger ||= @driver.create_column_family_manager(@cluster, @name)
+      end
+    end
+  end
+end

data/lib/eurydice/pelops.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+require 'pelops-jars'
+require 'eurydice'
+require 'cassandra'
+
+
+module Pelops
+  import 'org.scale7.cassandra.pelops.Cluster'
+  import 'org.scale7.cassandra.pelops.Pelops'
+  import 'org.scale7.cassandra.pelops.Selector'
+  import 'org.scale7.cassandra.pelops.Bytes'
+  import 'org.scale7.cassandra.pelops.exceptions.InvalidRequestException'
+  import 'org.scale7.cassandra.pelops.exceptions.NotFoundException'
+  import 'org.scale7.cassandra.pelops.exceptions.ApplicationException'
+end
+
+module Eurydice
+  def self.connect
+    Pelops.connect
+  end
+  
+  def self.disconnect!
+    Pelops.disconnect!
+  end
+  
+  module Pelops
+    def self.connect(options={})
+      host = options.fetch(:host, 'localhost')
+      port = options.fetch(:port, 9160)
+      pool_name = options.fetch(:pool_name, 'eurydice')
+      Cluster.new(::Pelops::Cluster.new(host, port))
+    end
+  
+    def self.keyspace(keyspace_name, host='localhost', port=9160, pool_name='eurydice')
+      cluster = ::Pelops::Cluster.new(host, port)
+      ::Pelops::Pelops.add_pool(pool_name, cluster, keyspace_name)
+      Keyspace.new(keyspace_name, cluster, pool_name)
+    end
+  
+    def self.disconnect!
+      ::Pelops::Pelops.shutdown
+    end
+
+    module ByteHelpers
+      extend self
+      
+      def empty_pelops_bytes
+        ::Pelops::Bytes::EMPTY
+      end
+      
+      def to_pelops_bytes(obj, type=nil)
+        case type
+        when :long
+          ::Pelops::Bytes.from_long(obj)
+        else
+          ::Pelops::Bytes.new(obj.to_s.to_java_bytes)
+        end
+      end
+      
+      def to_nio_bytes(str)
+        to_pelops_bytes(str).bytes
+      end
+      
+      def to_byte_array(str)
+        str.to_java_bytes
+      end
+      
+      def pelops_bytes_to_s(pb)
+        String.from_java_bytes(pb.to_byte_array)
+      end
+      
+      def nio_bytes_to_s(nb)
+        pelops_bytes_to_s(::Pelops::Bytes.new(nb))
+      end
+      
+      def byte_array_to_s(ba, type=nil)
+        case type
+        when :long
+          ::Pelops::Bytes.new(ba).to_long
+        else
+          String.from_java_bytes(ba)
+        end
+      end
+    end
+
+    module ExceptionHelpers
+      def transform_thrift_exception(e)
+        if e.respond_to?(:cause)
+          case e.cause
+          when Cassandra::InvalidRequestException, ::Pelops::InvalidRequestException
+            message = e.cause.why
+            backtrace = e.backtrace
+            error_class = begin
+              case message
+              when /Keyspace already exists/
+              then KeyspaceExistsError
+              else InvalidRequestError
+              end
+            end
+            raise error_class, message, backtrace
+          when ::Pelops::NotFoundException
+            raise NotFoundError, e.cause.message, e.backtrace
+          when ::Pelops::ApplicationException
+            raise EurydiceError, e.cause.message, e.backtrace
+          when Thrift::TTransportException
+            raise TimeoutError, e.cause.message, e.backtrace
+          end
+        end
+        raise e
+      end
+    
+      def thrift_exception_handler
+        yield
+      rescue Exception => e
+        transform_thrift_exception(e)
+      end
+    end
+  end
+end
+
+require_relative 'pelops/cluster'
+require_relative 'pelops/keyspace'
+require_relative 'pelops/column_family'

data/lib/eurydice/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+
+module Eurydice
+  VERSION = '1.0.0'
+end

data/lib/eurydice.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'java'
+require 'eurydice/pelops'
+
+module Eurydice
+  class EurydiceError < StandardError; end
+  class InvalidRequestError < EurydiceError; end
+  class KeyspaceExistsError < InvalidRequestError; end
+  class NotFoundError < EurydiceError; end
+  class TimeoutError < EurydiceError; end
+end

data/spec/eurydice/pelops/cluster_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../../spec_helper'
+
+
+module Eurydice
+  module Pelops
+    describe Cluster do
+      it 'can connect' do
+        @cluster = Eurydice.connect
+        @cluster.should be_connected
+      end
+  
+      describe '#keyspace' do
+        before do
+          @cluster = Eurydice.connect
+          @keyspace_name = "eurydice_test_space_#{rand(1000)}"
+          if @cluster.keyspaces.include?(@keyspace_name)
+            @cluster.keyspace(@keyspace_name).drop!
+          end
+        end
+        
+        after do
+          @keyspace.drop! rescue nil
+        end
+    
+        it 'creates a keyspace' do
+          @keyspace = @cluster.keyspace(@keyspace_name)
+          @keyspace.exists?.should be_true
+        end
+  
+        it 'defers the creation of a keyspace with :create => false' do
+          @keyspace = @cluster.keyspace(@keyspace_name, :create => false)
+          @keyspace.exists?.should be_false
+          @keyspace.create!
+          @keyspace.exists?.should be_true
+        end
+      end
+    end
+  end
+end