cassandra-driver 1.0.0.rc.1 → 1.0.0

data/lib/cassandra/client/column_metadata.rb

@@ -1,54 +0,0 @@
-# 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 Client
-    # Represents metadata about a column in a query result set or prepared
-    # statement. Apart from the keyspace, table and column names there's also
-    # the type as a symbol (e.g. `:varchar`, `:int`, `:date`).
-    class ColumnMetadata
-      attr_reader :keyspace, :table, :column_name, :type
-
-      # @private
-      def initialize(*args)
-        @keyspace, @table, @column_name, @type = args
-      end
-
-      # @private
-      def to_ary
-        [@keyspace, @table, @column_name, @type]
-      end
-
-      def eql?(other)
-        self.keyspace == other.keyspace && self.table == other.table && self.column_name == other.column_name && self.type == other.type
-      end
-      alias_method :==, :eql?
-
-      def hash
-        @h ||= begin
-          h = 0
-          h = ((h & 33554431) * 31) ^ @keyspace.hash
-          h = ((h & 33554431) * 31) ^ @table.hash
-          h = ((h & 33554431) * 31) ^ @column_name.hash
-          h = ((h & 33554431) * 31) ^ @type.hash
-          h
-        end
-      end
-    end
-  end
-end

data/lib/cassandra/client/connector.rb

@@ -1,273 +0,0 @@
-# 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 Client
-    # @private
-    class ClusterConnector
-      def initialize(sequence, logger)
-        @sequence = sequence
-        @logger = logger
-      end
-
-      def connect_all(hosts, connections_per_node)
-        connections = hosts.flat_map do |host|
-          Array.new(connections_per_node) do
-            f = @sequence.connect(host)
-            f.on_value { |connection| register_logging(connection) }
-            f.recover do |error|
-              @logger.warn('Failed connecting to node at %s: %s' % [host, error.message])
-              FailedConnection.new(error, host)
-            end
-          end
-        end
-        Ione::Future.all(*connections).map do |connections|
-          connected_connections = connections.select(&:connected?)
-          if connected_connections.empty?
-            error = connections.first.error
-            raise(error, error.message, error.backtrace)
-          end
-          connected_connections
-        end
-      end
-
-      private
-
-      def register_logging(connection)
-        args = [connection[:host_id], connection.host, connection.port, connection[:data_center]]
-        @logger.info('Connected to node %s at %s:%d in data center %s' % args)
-        connection.on_closed do |cause|
-          message = 'Connection to node %s at %s:%d in data center %s closed' % args
-          if cause
-            message << (' unexpectedly: %s' % cause.message)
-            @logger.warn(message)
-          else
-            @logger.info(message)
-          end
-        end
-      end
-    end
-
-    # @private
-    class Connector
-      def initialize(steps)
-        @steps = steps.dup
-      end
-
-      def connect(host)
-        pending_connection = PendingConnection.new(host)
-        seed = Ione::Future.resolved(pending_connection)
-        f = @steps.reduce(seed) do |chain, step|
-          chain.flat_map do |pending_connection|
-            step.run(pending_connection)
-          end
-        end
-        f.map do |pending_connection|
-          pending_connection.connection
-        end
-      end
-    end
-
-    # @private
-    class ConnectStep
-      def initialize(io_reactor, protocol_handler_factory, port, connection_options, logger)
-        @io_reactor = io_reactor
-        @protocol_handler_factory = protocol_handler_factory
-        @port = port
-        @connection_options = connection_options
-        @logger = logger
-      end
-
-      def run(pending_connection)
-        @io_reactor.connect(pending_connection.host, @port, @connection_options, &@protocol_handler_factory).map do |connection|
-          pending_connection.with_connection(connection)
-        end
-      end
-    end
-
-    # @private
-    class CacheOptionsStep
-      def initialize(timeout = nil)
-        @timeout = timeout
-      end
-
-      def run(pending_connection)
-        f = pending_connection.execute(Protocol::OptionsRequest.new, @timeout)
-        f.on_value do |supported_options|
-          pending_connection[:cql_version] = supported_options['CQL_VERSION']
-          pending_connection[:compression] = supported_options['COMPRESSION']
-        end
-
-        f.map(pending_connection)
-      end
-    end
-
-    # @private
-    class InitializeStep
-      def initialize(compressor, logger)
-        @compressor = compressor
-        @logger = logger
-      end
-
-      def run(pending_connection)
-        compression = @compressor && @compressor.algorithm
-        supported_algorithms = pending_connection[:compression]
-        if compression && !supported_algorithms.include?(compression)
-          @logger.info("Compression with #{compression.inspect} is not supported by host at #{pending_connection.host}, supported algorithms are #{supported_algorithms.inspect}")
-          compression = nil
-        end
-        supported_cql_versions = pending_connection[:cql_version]
-        cql_version = (supported_cql_versions && !supported_cql_versions.empty?) ? supported_cql_versions.first : '3.1.0'
-
-        f = pending_connection.execute(Protocol::StartupRequest.new(cql_version, compression))
-        f.map do |startup_response|
-          if startup_response.is_a?(AuthenticationRequired)
-            pending_connection.with_authentication_class(startup_response.authentication_class)
-          else
-            pending_connection
-          end
-        end
-      end
-    end
-
-    # @private
-    class SaslAuthenticationStep
-      def initialize(auth_provider)
-        @auth_provider = auth_provider
-      end
-
-      def run(pending_connection)
-        if pending_connection.authentication_class
-          begin
-            authenticator = @auth_provider && @auth_provider.create_authenticator(pending_connection.authentication_class)
-            if authenticator
-              token = authenticator.initial_response
-              challenge_cycle(pending_connection, authenticator, token)
-            elsif @auth_provider
-              Ione::Future.failed(Errors::AuthenticationError.new('Auth provider does not support the required authentication class "%s" and/or protocol version %d' % [pending_connection.authentication_class, @protocol_version]))
-            else
-              Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate'))
-            end
-          rescue => e
-            Ione::Future.failed(Errors::AuthenticationError.new('Auth provider error (%s: %s)' % [e.class.name, e.message]))
-          end
-        else
-          Ione::Future.resolved(pending_connection)
-        end
-      end
-
-      def challenge_cycle(pending_connection, authenticator, response_token)
-        request = Protocol::AuthResponseRequest.new(response_token)
-        f = pending_connection.execute(request) { |raw_response| raw_response }
-        f.flat_map do |response|
-          case response
-          when Protocol::AuthChallengeResponse
-            token = authenticator.challenge_response(response.token)
-            challenge_cycle(pending_connection, authenticator, token)
-          when Protocol::AuthSuccessResponse
-            authenticator.authentication_successful(response.token) rescue nil
-            Ione::Future.resolved(pending_connection)
-          else
-            Ione::Future.resolved(pending_connection)
-          end
-        end
-      end
-    end
-
-    # @private
-    class CredentialsAuthenticationStep
-      def initialize(credentials)
-        @credentials = credentials
-      end
-
-      def run(pending_connection)
-        if pending_connection.authentication_class
-          if @credentials
-            request = Protocol::CredentialsRequest.new(@credentials)
-            pending_connection.execute(request).map(pending_connection)
-          else
-            Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate'))
-          end
-        else
-          Ione::Future.resolved(pending_connection)
-        end
-      end
-    end
-
-    # @private
-    class CachePropertiesStep
-      def run(pending_connection)
-        request = Protocol::QueryRequest.new('SELECT data_center, host_id FROM system.local', nil, nil, :one)
-        f = pending_connection.execute(request)
-        f.on_value do |result|
-          unless result.empty?
-            pending_connection[:host_id] = result.first['host_id']
-            pending_connection[:data_center] = result.first['data_center']
-          end
-        end
-        f.map(pending_connection)
-      end
-    end
-
-    # @private
-    class PendingConnection
-      attr_reader :host, :connection, :authentication_class
-
-      def initialize(host, connection=nil, authentication_class=nil)
-        @host = host
-        @connection = connection
-        @authentication_class = authentication_class
-        @request_runner = RequestRunner.new
-      end
-
-      def with_connection(connection)
-        self.class.new(host, connection, @authentication_class)
-      end
-
-      def with_authentication_class(authentication_class)
-        self.class.new(host, @connection, authentication_class)
-      end
-
-      def [](key)
-        @connection[key]
-      end
-
-      def []=(key, value)
-        @connection[key] = value
-      end
-
-      def execute(request, timeout = nil, &block)
-        @request_runner.execute(@connection, request, timeout, nil, &block)
-      end
-    end
-
-    # @private
-    class FailedConnection
-      attr_reader :error, :host
-
-      def initialize(error, host)
-        @error = error
-        @host = host
-      end
-
-      def connected?
-        false
-      end
-    end
-  end
-end

data/lib/cassandra/client/execute_options_decoder.rb

@@ -1,59 +0,0 @@
-# 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 Client
-    # @private
-    class ExecuteOptionsDecoder
-      def initialize(default_consistency)
-        @default_consistency = default_consistency
-        @default_options = {:consistency => @default_consistency}.freeze
-      end
-
-      def decode_options(*args)
-        if args.empty?
-          @default_options
-        elsif args.size == 1
-          decode_one(args.first)
-        else
-          args.each_with_object({}) do |options_or_consistency, result|
-            result.merge!(decode_one(options_or_consistency))
-          end
-        end
-      end
-
-      private
-
-      def decode_one(options_or_consistency)
-        return @default_options unless options_or_consistency
-        case options_or_consistency
-        when Symbol
-          {:consistency => options_or_consistency}
-        when Hash
-          if options_or_consistency.include?(:consistency)
-            options_or_consistency
-          else
-            options = options_or_consistency.dup
-            options[:consistency] = @default_consistency
-            options
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cassandra/client/peer_discovery.rb

@@ -1,50 +0,0 @@
-# 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 Client
-    # @private
-    class PeerDiscovery
-      def initialize(seed_connections)
-        @seed_connections = seed_connections
-        @connection = seed_connections.sample
-        @request_runner = RequestRunner.new
-      end
-
-      def new_hosts
-        request = Protocol::QueryRequest.new('SELECT peer, data_center, host_id, rpc_address FROM system.peers', nil, nil, :one)
-        response = @request_runner.execute(@connection, request)
-        response.map do |result|
-          result.each_with_object([]) do |row, new_peers|
-            if include?(row['host_id'], row['data_center'])
-              rpc_address = row['rpc_address'].to_s
-              rpc_address = row['peer'].to_s if rpc_address == '0.0.0.0'
-              new_peers << rpc_address
-            end
-          end
-        end
-      end
-
-      private
-
-      def include?(host_id, dc)
-        @seed_connections.any? { |c| c[:data_center] == dc } && @seed_connections.none? { |c| c[:host_id] == host_id }
-      end
-    end
-  end
-end

data/lib/cassandra/client/prepared_statement.rb

@@ -1,314 +0,0 @@
-# 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 Client
-    # A prepared statement are CQL queries that have been sent to the server
-    # to be precompiled, so that when executed only their ID and not the whole
-    # CQL string need to be sent. They support bound values, or placeholders
-    # for values.
-    #
-    # Using a prepared statement for any query that you execute more than once
-    # is highly recommended. Besides the benefit of having less network overhead,
-    # and less processing overhead on the server side, they don't require you
-    # to build CQL strings and escape special characters, or format non-character
-    # data such as UUIDs, different numeric types, or collections, in the
-    # correct way.
-    #
-    # You should only prepare a statement once and reuse the prepared statement
-    # object every time you want to execute that particular query. The statement
-    # object will make sure that it is prepared on all connections, and will
-    # (lazily, but transparently) make sure it is prepared on any new connections.
-    #
-    # It is an anti-pattern to prepare the same query over and over again. It is
-    # bad for performance, since every preparation requires a roundtrip to all
-    # connected servers, and because of some bookeeping that is done to support
-    # automatic preparation on new connections, it will lead to unnecessary
-    # extra memory usage. There is no performance benefit in creating multiple
-    # prepared statement objects for the same query.
-    #
-    # Prepared statement objects are completely thread safe and can be shared
-    # across all threads in your application.
-    #
-    # @see Cassandra::Client::Client#prepare
-    class PreparedStatement
-      # Metadata describing the bound values
-      #
-      # @return [ResultMetadata]
-      attr_reader :metadata
-
-      # Metadata about the result (i.e. rows) that is returned when executing
-      # this prepared statement.
-      #
-      # @return [ResultMetadata]
-      attr_reader :result_metadata
-
-      # Execute the prepared statement with a list of values to be bound to the
-      # statements parameters.
-      #
-      # The number of arguments must equal the number of bound parameters. You
-      # can also specify options as the last argument, or a symbol as a shortcut
-      # for just specifying the consistency.
-      #
-      # Because you can specify options, or not, there is an edge case where if
-      # the last parameter of your prepared statement is a map, and you forget
-      # to specify a value for your map, the options will end up being sent to
-      # Cassandra. Most other cases when you specify the wrong number of
-      # arguments should result in an `ArgumentError` or `TypeError` being
-      # raised.
-      #
-      # @example Preparing and executing an `INSERT` statement
-      #   statement = client.prepare(%(INSERT INTO metrics (id, time, value) VALUES (?, NOW(), ?)))
-      #   statement.execute(1234, 23432)
-      #   statement.execute(2345, 34543, tracing: true)
-      #   statement.execute(3456, 45654, consistency: :one)
-      #
-      # @example Preparing and executing a `SELECT` statement
-      #   statement = client.prepare(%(SELECT * FROM metrics WHERE id = ? AND time > ?))
-      #   result = statement.execute(1234, Time.now - 3600)
-      #   result.each do |row|
-      #     p row
-      #   end
-      #
-      # @param args [Array] the values for the bound parameters, and an optional
-      #   hash of options as last argument – see {Cassandra::Client::Client#execute}
-      #   for details on which options are available.
-      # @raise [ArgumentError] raised when number of argument does not match
-      #   the number of parameters needed to be bound to the statement.
-      # @raise [Cassandra::Errors::ClientError] raised when the client is not connected
-      # @raise [Cassandra::Errors::IoError] raised when there is an IO error, for example
-      #   if the server suddenly closes the connection
-      # @raise [Cassandra::Errors::QueryError] raised when there is an error on the server side
-      # @return [nil, Cassandra::Client::QueryResult, Cassandra::Client::VoidResult] Some
-      #   queries have no result and return `nil`, but `SELECT` statements
-      #   return an `Enumerable` of rows (see {Cassandra::Client::QueryResult}), and
-      #   `INSERT` and `UPDATE` return a similar type
-      #   (see {Cassandra::Client::VoidResult}).
-      def execute(*args)
-      end
-
-      # Yields a batch when called with a block. The batch is automatically
-      # executed at the end of the block and the result is returned.
-      #
-      # Returns a batch when called wihtout a block. The batch will remember
-      # the options given and merge these with any additional options given
-      # when {Cassandra::Client::PreparedStatementBatch#execute} is called.
-      #
-      # The batch yielded or returned by this method is not identical to the
-      # regular batch objects yielded or returned by {Cassandra::Client::Client#batch}.
-      # These prepared statement batch objects can be used only to add multiple
-      # executions of the same prepared statement.
-      #
-      # Please note that the batch object returned by this method _is not thread
-      # safe_.
-      #
-      # The type parameter can be ommitted and the options can then be given
-      # as first parameter.
-      #
-      # @example Executing a prepared statement in a batch
-      #   statement = client.prepare(%(INSERT INTO metrics (id, time, value) VALUES (?, NOW(), ?)))
-      #   statement.batch do |batch|
-      #     batch.add(1234, 23423)
-      #     batch.add(2346, 13)
-      #     batch.add(2342, 2367)
-      #     batch.add(4562, 1231)
-      #   end
-      #
-      # @see Cassandra::Client::PreparedStatementBatch
-      # @see Cassandra::Client::Client#batch
-      # @param [Symbol] type the type of batch, must be one of `:logged`,
-      #   `:unlogged` and `:counter`. The precise meaning of these  is defined
-      #   in the CQL specification.
-      # @yieldparam [Cassandra::Client::PreparedStatementBatch] batch the batch
-      # @return [Cassandra::Client::VoidResult, Cassandra::Client::Batch] when no block is
-      #   given the batch is returned, when a block is given the result of
-      #   executing the batch is returned (see {Cassandra::Client::Batch#execute}).
-      def batch(type=:logged, options={})
-      end
-    end
-
-    # @private
-    class AsynchronousPreparedStatement < PreparedStatement
-      # @private
-      def initialize(cql, execute_options_decoder, connection_manager, logger)
-        @cql = cql
-        @execute_options_decoder = execute_options_decoder
-        @connection_manager = connection_manager
-        @logger = logger
-        @request_runner = RequestRunner.new
-      end
-
-      def self.prepare(cql, execute_options_decoder, connection_manager, logger)
-        statement = new(cql, execute_options_decoder, connection_manager, logger)
-        futures = connection_manager.map do |connection|
-          statement.prepare(connection)
-        end
-        Ione::Future.all(*futures).map(statement)
-      rescue => e
-        Ione::Future.failed(e)
-      end
-
-      def execute(*args)
-        connection = @connection_manager.random_connection
-        if connection[self]
-          run(args, connection)
-        else
-          prepare(connection).flat_map do
-            run(args, connection)
-          end
-        end
-      rescue => e
-        Ione::Future.failed(e)
-      end
-
-      def batch(type=:logged, options=nil)
-        if type.is_a?(Hash)
-          options = type
-          type = :logged
-        end
-        b = AsynchronousBatch.new(type, @execute_options_decoder, @connection_manager, options)
-        pb = AsynchronousPreparedStatementBatch.new(self, b)
-        if block_given?
-          yield pb
-          pb.execute
-        else
-          pb
-        end
-      end
-
-      # @private
-      def prepare(connection)
-        prepare_request = Protocol::PrepareRequest.new(@cql)
-        f = @request_runner.execute(connection, prepare_request) do |response|
-          connection[self] = response.id
-          unless @raw_metadata
-            # NOTE: this is not thread safe, but the worst that could happen
-            # is that we assign the same data multiple times
-            @raw_metadata = response.metadata
-            @metadata = ResultMetadata.new(@raw_metadata)
-            @raw_result_metadata = response.result_metadata
-            if @raw_result_metadata
-              @result_metadata = ResultMetadata.new(@raw_result_metadata)
-            end
-          end
-          hex_id = response.id.each_byte.map { |x| x.to_s(16).rjust(2, '0') }.join('')
-          @logger.debug('Statement %s prepared on node %s (%s:%d)' % [hex_id, connection[:host_id].to_s, connection.host, connection.port])
-        end
-        f.map(self)
-      end
-
-      # @private
-      def prepared?(connection)
-        !!connection[self]
-      end
-
-      # @private
-      def add_to_batch(batch, connection, bound_args)
-        statement_id = connection[self]
-        unless statement_id
-          raise ::ArgumentError, "Statement was not prepared"
-        end
-        unless bound_args.size == @raw_metadata.size
-          raise ::ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
-        end
-        batch.add_prepared(statement_id, @raw_metadata, bound_args)
-      end
-
-      private
-
-      def run(args, connection)
-        bound_args = args.shift(@raw_metadata.size)
-        unless bound_args.size == @raw_metadata.size && args.size <= 1
-          raise ::ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
-        end
-        options = @execute_options_decoder.decode_options(args.last)
-        statement_id = connection[self]
-        request_metadata = @raw_result_metadata.nil?
-        request = Protocol::ExecuteRequest.new(statement_id, @raw_metadata, bound_args, request_metadata, options[:consistency], options[:serial_consistency], options[:page_size], options[:paging_state], options[:trace])
-        f = @request_runner.execute(connection, request, options[:timeout], @raw_result_metadata)
-        if options.include?(:page_size)
-          f = f.map { |result| AsynchronousPreparedPagedQueryResult.new(self, request, result, options) }
-        end
-        f
-      end
-    end
-
-    # @private
-    class SynchronousPreparedStatement < PreparedStatement
-      include SynchronousBacktrace
-
-      def initialize(async_statement)
-        @async_statement = async_statement
-        @metadata = async_statement.metadata
-        @result_metadata = async_statement.result_metadata
-      end
-
-      def execute(*args)
-        synchronous_backtrace do
-          result = @async_statement.execute(*args).value
-          result = SynchronousPagedQueryResult.new(result) if result.is_a?(PagedQueryResult)
-          result
-        end
-      end
-
-      def batch(type=:logged, options=nil, &block)
-        if block_given?
-          synchronous_backtrace { @async_statement.batch(type, options, &block).value }
-        else
-          SynchronousPreparedStatementBatch.new(@async_statement.batch(type, options))
-        end
-      end
-
-      def pipeline
-        pl = Pipeline.new(@async_statement)
-        yield pl
-        synchronous_backtrace { pl.value }
-      end
-
-      def async
-        @async_statement
-      end
-
-      # @private
-      def prepared?(connection)
-        @async_statement.prepared?(connection)
-      end
-
-      # @private
-      def add_to_batch(batch, connection, bound_arguments)
-        @async_statement.add_to_batch(batch, connection, bound_arguments)
-      end
-    end
-
-    # @private
-    class Pipeline
-      def initialize(async_statement)
-        @async_statement = async_statement
-        @futures = []
-      end
-
-      def execute(*args)
-        @futures << @async_statement.execute(*args)
-      end
-
-      def value
-        Ione::Future.all(*@futures).value
-      end
-    end
-  end
-end