cassandra-driver 1.0.0.beta.2-java

data/lib/cassandra/cluster.rb

@@ -0,0 +1,215 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed 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.
+#++
+
+module Cassandra
+  # Cluster represents a cassandra cluster. It serves as a {Cassandra::Session}
+  # factory and a collection of metadata.
+  #
+  # @see Cassandra::Cluster#connect Creating a new session
+  # @see Cassandra::Cluster#each_host Getting all peers in the cluster
+  # @see Cassandra::Cluster#each_keyspace Getting all existing keyspaces
+  class Cluster
+    extend Forwardable
+
+    # @!method host(address)
+    #   Find a host by its address
+    #   @param address [IPAddr, String] ip address
+    #   @return [Cassandra::Host, nil] host or nil
+    #
+    # @!method has_host?(address)
+    #   Determine if a host by a given address exists
+    #   @param address [IPAddr, String] ip address
+    #   @return [Boolean] true or false
+    def_delegators :@registry, :host, :has_host?
+
+    # @!method keyspace(name)
+    #   Find a keyspace by name
+    #   @param name [String] keyspace name
+    #   @return [Cassandra::Keyspace, nil] keyspace or nil
+    #
+    # @!method has_keyspace?(name)
+    #   Determine if a keyspace by a given name exists
+    #   @param name [String] keyspace name
+    #   @return [Boolean] true or false
+    def_delegators :@schema, :keyspace, :has_keyspace?
+
+    # @!method name
+    #   Return cluster's name
+    #   @return [String] cluster's name
+    #
+    # @!method find_replicas(keyspace, statement)
+    #   Return replicas for a given statement and keyspace
+    #   @note an empty list is returned when statement/keyspace information is
+    #     not enough to determine replica list.
+    #   @param keyspace [String] keyspace name
+    #   @param statement [Cassandra::Statement] statement for which to find
+    #     replicas
+    #   @return [Array<Cassandra::Host>] a list of replicas
+    def_delegators :@metadata, :name, :find_replicas
+
+    # @private
+    def initialize(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory)
+      @logger                = logger
+      @io_reactor            = io_reactor
+      @control_connection    = control_connection
+      @registry              = cluster_registry
+      @schema                = cluster_schema
+      @metadata              = cluster_metadata
+      @execution_options     = execution_options
+      @connection_options    = connection_options
+      @load_balancing_policy = load_balancing_policy
+      @reconnection_policy   = reconnection_policy
+      @retry_policy          = retry_policy
+      @connector             = connector
+      @futures               = futures_factory
+    end
+
+    # Register a cluster state listener. State listener will start receiving
+    # notifications about topology and schema changes
+    #
+    # @param listener [Cassandra::Listener] cluster state listener
+    # @return [self]
+    def register(listener)
+      @registry.add_listener(listener)
+      @schema.add_listener(listener)
+      self
+    end
+
+    # Unregister a cluster state listener. State listener will stop receiving
+    # notifications about topology and schema changes
+    #
+    # @param listener [Cassandra::Listener] cluster state listener
+    # @return [self]
+    def unregister(listener)
+      @registry.remove_listener(listener)
+      @schema.remove_listener(listener)
+      self
+    end
+
+    # Yield or enumerate each member of this cluster
+    # @overload each_host
+    #   @yieldparam host [Cassandra::Host] current host
+    #   @return [Cassandra::Cluster] self
+    # @overload each_host
+    #   @return [Array<Cassandra::Host>] a list of hosts
+    def each_host(&block)
+      r = @registry.each_host(&block)
+      return self if r == @registry
+      r
+    end
+    alias :hosts :each_host
+
+    # Yield or enumerate each keyspace defined in this cluster
+    # @overload each_keyspace
+    #   @yieldparam keyspace [Cassandra::Keyspace] current keyspace
+    #   @return [Cassandra::Cluster] self
+    # @overload each_keyspace
+    #   @return [Array<Cassandra::Keyspace>] a list of keyspaces
+    def each_keyspace(&block)
+      r = @schema.each_keyspace(&block)
+      return self if r == @schema
+      r
+    end
+    alias :keyspaces :each_keyspace
+
+    # Asynchronously create a new session, optionally scoped to a keyspace
+    #
+    # @param keyspace [String] optional keyspace to scope session to
+    #
+    # @return [Cassandra::Future<Cassandra::Session>] a future new session that
+    #   can prepare and execute statements
+    def connect_async(keyspace = nil)
+      if !keyspace.nil? && !keyspace.is_a?(::String)
+        return @futures.error(::ArgumentError.new("keyspace must be a string, #{keyspace.inspect} given"))
+      end
+
+      client  = Client.new(@logger, @registry, @schema, @io_reactor, @connector, @load_balancing_policy, @reconnection_policy, @retry_policy, @connection_options, @futures)
+      session = Session.new(client, @execution_options, @futures)
+      promise = @futures.promise
+
+      client.connect.on_complete do |f|
+        if f.resolved?
+          if keyspace
+            f = session.execute_async("USE #{keyspace}")
+
+            f.on_success {promise.fulfill(session)}
+            f.on_failure {|e| promise.break(e)}
+          else
+            promise.fulfill(session)
+          end
+        else
+          f.on_failure {|e| promise.break(e)}
+        end
+      end
+
+      promise.future
+    end
+
+    # Synchronously create a new session, optionally scoped to a keyspace
+    #
+    # @param keyspace [String] optional keyspace to scope session to
+    # @raise  [ArgumentError] if keyspace is not a String
+    # @return [Cassandra::Session] a new session that can prepare and execute
+    #   statements
+    #
+    # @see Cassandra::Cluster#connect_async
+    def connect(keyspace = nil)
+      connect_async(keyspace).get
+    end
+
+    # Asynchronously closes all sessions managed by this cluster
+    #
+    # @return [Cassandra::Future<Cassandra::Cluster>] a future that resolves to
+    #   self once closed
+    def close_async
+      promise = @futures.promise
+
+      @control_connection.close_async.on_complete do |f|
+        if f.resolved?
+          promise.fulfill(self)
+        else
+          f.on_failure {|e| promise.break(e)}
+        end
+      end
+
+      promise.future
+    end
+
+    # Synchronously closes all sessions managed by this cluster
+    #
+    # @return [self] this cluster
+    #
+    # @see Cassandra::Cluster#close_async
+    def close
+      close_async.get
+    end
+
+    # @return [String] a CLI-friendly cluster representation
+    def inspect
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+end
+
+require 'cassandra/cluster/client'
+require 'cassandra/cluster/connector'
+require 'cassandra/cluster/control_connection'
+require 'cassandra/cluster/metadata'
+require 'cassandra/cluster/options'
+require 'cassandra/cluster/registry'
+require 'cassandra/cluster/schema'

data/lib/cassandra/column.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed 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.
+#++
+
+module Cassandra
+  # Represents a cassandra column
+  # @see Cassandra::Table#each_column
+  # @see Cassandra::Table#column
+  class Column
+    # @private
+    class Index
+      # @return [String] index name
+      attr_reader :name
+      # @return [String] custom index class name
+      attr_reader :custom_class_name
+
+      # @private
+      def initialize(name, custom_class_name = nil)
+        @name              = name
+        @custom_class_name = custom_class_name
+      end
+    end
+
+    # @return [String] column name
+    attr_reader :name
+    # @private
+    # @return [Symbol, Array(Symbol, Symbol)] column type
+    attr_reader :type
+    # @return [Symbol] column order (`:asc` or `:desc`)
+    attr_reader :order
+    # @private
+    # @return [Cassandra::Column::Index, nil] column index
+    attr_reader :index
+    # @private
+    # @return [Boolean] whether the column is static
+    attr_reader :static
+
+    # @private
+    def initialize(name, type, order, index = nil, is_static = false)
+      @name     = name
+      @type     = type
+      @order    = order
+      @index    = index
+      @static   = is_static
+    end
+
+    # @return [Boolean] whether the column is static
+    def static?
+      @static
+    end
+
+    # @return [String] a cql representation of this column
+    def to_cql
+      type = case @type
+      when Array
+        type, *args = @type
+        "#{type.to_s}<#{args.map(&:to_s).join(', ')}>"
+      else
+        @type.to_s
+      end
+
+      cql = "#{@name} #{type}"
+      cql << ' static' if @static
+      cql
+    end
+
+    # @return [Boolean] whether this column is equal to the other
+    def eql?(other)
+      other.is_a?(Column) &&
+        @name == other.name &&
+        @type == other.type &&
+        @order == other.order &&
+        @index == other.index &&
+        @static == other.static?
+    end
+    alias :== :eql?
+  end
+end

data/lib/cassandra/compression/compressors/lz4.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed 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.
+#++
+
+begin
+  require 'lz4-ruby'
+rescue LoadError => e
+  raise LoadError, %[LZ4 support requires the "lz4-ruby" gem: #{e.message}], e.backtrace
+end
+
+module Cassandra
+  module Compression
+    module Compressors
+      # A compressor that uses the LZ4 compression library.
+      #
+      # @note This compressor requires the
+      #   [lz4-ruby](http://rubygems.org/gems/lz4-ruby) gem (v0.3.2 or later
+      #   required).
+      # @note No need to instantiate this class manually, use `compression:
+      #   :lz4` option when calling {Cassandra.connect} and one will be created
+      #   automatically for you.
+      class Lz4 < Compressor
+        # @return [String] `'lz4'`
+        attr_reader :algorithm
+
+        # @param [Integer] min_size (64) Don't compress frames smaller than
+        #   this size (see {#compress?}).
+        def initialize(min_size=64)
+          @algorithm = 'lz4'.freeze
+          @min_size = min_size
+        end
+
+        # @return [true, false] will return false for frames smaller than the
+        #   `min_size` given to the constructor.
+        # @see Cassandra::Compression::Compressor#compress?
+        def compress?(str)
+          str.bytesize > @min_size
+        end
+
+        # @see Cassandra::Compression::Compressor#compress
+        def compress(str)
+          [str.bytesize, ::LZ4::Raw.compress(str.to_s).first].pack(BUFFER_FORMAT)
+        end
+
+        # @see Cassandra::Compression::Compressor#decompress
+        def decompress(str)
+          decompressed_size, compressed_data = str.to_s.unpack(BUFFER_FORMAT)
+          ::LZ4::Raw.decompress(compressed_data, decompressed_size).first
+        end
+
+        private
+
+        # @private
+        BUFFER_FORMAT = 'Na*'.freeze
+      end
+    end
+  end
+end

data/lib/cassandra/compression/compressors/snappy.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed 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.
+#++
+
+begin
+  require 'snappy'
+rescue LoadError => e
+  raise LoadError, %[Snappy support requires the "snappy" gem: #{e.message}], e.backtrace
+end
+
+module Cassandra
+  module Compression
+    module Compressors
+      # A compressor that uses the Snappy compression library.
+      #
+      # @note This compressor requires the
+      #   [snappy](http://rubygems.org/gems/snappy) gem (v0.0.10 or later for
+      #   JRuby support).
+      # @note No need to instantiate this class manually, use `compression:
+      #   :snappy` option when calling {Cassandra.connect} and one will be
+      #   created automatically for you.
+      class Snappy < Compressor
+        # @return [String] `'snappy'`
+        attr_reader :algorithm
+
+        # @param [Integer] min_size (64) Don't compress frames smaller than
+        #   this size (see {#compress?}).
+        def initialize(min_size=64)
+          @algorithm = 'snappy'.freeze
+          @min_size = min_size
+        end
+
+        # @return [true, false] will return false for frames smaller than the
+        #   `min_size` given to the constructor.
+        # @see Cassandra::Compression::Compressor#compress?
+        def compress?(str)
+          str.bytesize > @min_size
+        end
+
+        # @see Cassandra::Compression::Compressor#compress
+        def compress(str)
+          ::Snappy.deflate(str)
+        end
+
+        # @see Cassandra::Compression::Compressor#decompress
+        def decompress(str)
+          ::Snappy.inflate(str)
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/compression.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed 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.
+#++
+
+module Cassandra
+  module Compression
+    # @abstract Compressors given to {Cassandra.connect} as the `:compressor`
+    #   option don't need to be subclasses of this class, but need to implement
+    #   the same methods. This class exists only for documentation purposes.
+    class Compressor
+      # @!method algorithm
+      #
+      # Returns the name of the algorithm this compressor supports,
+      # e.g. "snappy" or "lz4".
+      #
+      # @return [String] algorithm
+
+      # @!method compress?(frame)
+      #
+      # Before compressing a frame the compressor will be asked if it wants
+      # to compress it or not. One reason it could say no is if the frame is
+      # small enough that compression would be unlikely to decrease its size.
+      #
+      # If your operations consist mostly of small prepared statement
+      # executions it might not be useful to compress the frames being sent
+      # _to_ Cassandra, but enabling compression can still be useful on the
+      # frames coming _from_ Cassandra. Making this method always return
+      # false disables request compression, but will still make the client
+      # tell Cassandra that it supports compressed frames.
+      #
+      # The bytes given to {#compress?} are the same as to {#compress}
+      #
+      # @param frame [String] the bytes of the frame to be compressed
+      # @return [true, false] whether to perform compression or not
+
+      # @!method compress(frame)
+      #
+      # Compresses the raw bytes of a frame.
+      #
+      # @param frame [String] the bytes of the frame to be compressed
+      # @return [String] the compressed frame
+
+      # @!method decompress(compressed_frame)
+      #
+      # Decompresses the raw bytes of a compressed frame.
+      #
+      # @param compressed_frame [String] the bytes of the compressed frame to
+      #   be uncompressed
+      # @return [String] uncompressed bytes
+    end
+  end
+end

data/lib/cassandra/driver.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed 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.
+#++
+
+module Cassandra
+  # @private
+  class Driver
+    def self.let(name, &block)
+      define_method(name)        { @instances[name] ||= @defaults.fetch(name) { instance_eval(&block) } }
+      define_method(:"#{name}=") { |object| @instances[name] = object }
+    end
+
+    let(:io_reactor)       { Io::IoReactor.new }
+    let(:cluster_registry) { Cluster::Registry.new(logger) }
+    let(:cluster_schema)   { Cluster::Schema.new(schema_type_parser) }
+    let(:cluster_metadata) { Cluster::Metadata.new(
+                               cluster_registry,
+                               cluster_schema,
+                               {
+                                 'org.apache.cassandra.dht.Murmur3Partitioner'     => murmur3_partitioner,
+                                 'org.apache.cassandra.dht.ByteOrderedPartitioner' => ordered_partitioner,
+                                 'org.apache.cassandra.dht.RandomPartitioner'      => random_partitioner
+                               }.freeze,
+                               {
+                                 'org.apache.cassandra.locator.SimpleStrategy'          => simple_replication_strategy,
+                                 'org.apache.cassandra.locator.NetworkTopologyStrategy' => network_topology_replication_strategy
+                               }.freeze,
+                               no_replication_strategy
+                              )
+                           }
+    let(:futures_factory)  { Future }
+
+    let(:schema_type_parser) { Cluster::Schema::TypeParser.new }
+
+    let(:simple_replication_strategy)           { Cluster::Schema::ReplicationStrategies::Simple.new }
+    let(:network_topology_replication_strategy) { Cluster::Schema::ReplicationStrategies::NetworkTopology.new }
+    let(:no_replication_strategy)               { Cluster::Schema::ReplicationStrategies::None.new }
+
+    let(:murmur3_partitioner) { Cluster::Schema::Partitioners::Murmur3.new }
+    let(:ordered_partitioner) { Cluster::Schema::Partitioners::Ordered.new }
+    let(:random_partitioner)  { Cluster::Schema::Partitioners::Random.new }
+
+    let(:connector) { Cluster::Connector.new(logger, io_reactor, cluster_registry, connection_options) }
+
+    let(:control_connection) { Cluster::ControlConnection.new(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, connector) }
+
+    let(:cluster) { Cluster.new(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory) }
+
+    let(:execution_options) do
+      Execution::Options.new({
+        :consistency => consistency,
+        :trace       => trace,
+        :page_size   => page_size
+      })
+    end
+
+    let(:connection_options) { Cluster::Options.new(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node) }
+
+    let(:port)                  { 9042 }
+    let(:protocol_version)      { 2 }
+    let(:connect_timeout)       { 10 }
+    let(:ssl)                   { false }
+    let(:logger)                { Client::NullLogger.new  }
+    let(:compressor)            { nil }
+    let(:credentials)           { nil }
+    let(:auth_provider)         { nil }
+    let(:load_balancing_policy) { LoadBalancing::Policies::RoundRobin.new }
+    let(:reconnection_policy)   { Reconnection::Policies::Exponential.new(0.5, 30, 2) }
+    let(:retry_policy)          { Retry::Policies::Default.new }
+    let(:consistency)           { :quorum }
+    let(:trace)                 { false }
+    let(:page_size)             { nil }
+
+    let(:connections_per_local_node)  { 2 }
+    let(:connections_per_remote_node) { 1 }
+
+    let(:listeners) { [] }
+
+    def initialize(defaults = {})
+      @defaults  = defaults
+      @instances = {}
+    end
+
+    def connect(addresses)
+      load_balancing_policy.setup(cluster)
+      cluster_registry.add_listener(load_balancing_policy)
+      cluster_registry.add_listener(control_connection)
+      listeners.each do |listener|
+        cluster.register(listener)
+      end
+
+      addresses.each {|address| cluster_registry.host_found(address)}
+
+      control_connection.connect_async.map(cluster)
+    end
+  end
+end

data/lib/cassandra/errors.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed 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.
+#++
+
+module Cassandra
+  # Base class for all Errors raised by the driver 
+  # @see Cassandra::Errors
+  class Error < StandardError
+  end
+
+  module Errors
+    # @!parse class IoError < StandardError; end
+    # @private
+    IoError = Ione::IoError
+
+    # This error type represents errors sent by the server, the `code` attribute
+    # can be used to find the exact type, and `cql` contains the request's CQL,
+    # if any. `message` contains the human readable error message sent by the
+    # server.
+    class QueryError < Error
+      # @return [Integer] error code
+      attr_reader :code
+      # @return [String] original CQL used
+      attr_reader :cql
+      # @return [Hash{Symbol => String, Integer}] various error details
+      attr_reader :details
+
+      # @private
+      def initialize(code, message, cql=nil, details=nil)
+        super(message)
+        @code = code
+        @cql = cql
+        @details = details
+      end
+    end
+
+    # This error is thrown when not hosts could be reached during connection or query execution.
+    class NoHostsAvailable < Error
+      # @return [Hash{Cassandra::Host => Exception}] a map of hosts to underlying exceptions
+      attr_reader :errors
+
+      # @private
+      def initialize(errors = {})
+        super("no hosts available, check #errors property for details")
+
+        @errors = errors
+      end
+    end
+
+    # Client error represents bad driver state or configuration
+    #
+    # @see Cassandra::Errors::AuthenticationError
+    class ClientError < Error
+    end
+
+    # Raised when cannot authenticate to Cassandra
+    class AuthenticationError < ClientError
+    end
+
+    # @private
+    NotConnectedError = Class.new(Error)
+    # @private
+    NotPreparedError = Class.new(Error)
+  end
+end