cassandra-driver 0.1.0.alpha1 → 1.0.0.beta.1

data/lib/cassandra/client/column_metadata.rb

@@ -0,0 +1,54 @@
+# 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/connection_manager.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.
+#++
+
+module Cassandra
+  module Client
+    # @private
+    class ConnectionManager
+      include Enumerable
+
+      def initialize
+        @connections = []
+        @lock = Mutex.new
+      end
+
+      def add_connections(connections)
+        @lock.synchronize do
+          @connections.concat(connections)
+          connections.each do |connection|
+            connection.on_closed do
+              @lock.synchronize do
+                @connections.delete(connection)
+              end
+            end
+          end
+        end
+      end
+
+      def connected?
+        @lock.synchronize do
+          @connections.any?
+        end
+      end
+
+      def snapshot
+        @lock.synchronize do
+          @connections.dup
+        end
+      end
+
+      def random_connection
+        raise Errors::NotConnectedError unless connected?
+        @lock.synchronize do
+          @connections.sample
+        end
+      end
+
+      def each_connection(&callback)
+        return self unless block_given?
+        raise Errors::NotConnectedError unless connected?
+        @lock.synchronize do
+          @connections.each(&callback)
+        end
+      end
+      alias_method :each, :each_connection
+    end
+  end
+end

data/lib/cassandra/client/connector.rb

@@ -0,0 +1,272 @@
+# 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?
+            e = connections.first.error
+            if e.is_a?(Cassandra::Errors::QueryError) && e.code == 0x100
+              e = Errors::AuthenticationError.new(e.message)
+            end
+            raise e
+          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_timeout, logger)
+        @io_reactor = io_reactor
+        @protocol_handler_factory = protocol_handler_factory
+        @port = port
+        @connection_timeout = connection_timeout
+        @logger = logger
+      end
+
+      def run(pending_connection)
+        @io_reactor.connect(pending_connection.host, @port, @connection_timeout, &@protocol_handler_factory).map do |connection|
+          pending_connection.with_connection(connection)
+        end
+      end
+    end
+
+    # @private
+    class CacheOptionsStep
+      def run(pending_connection)
+        f = pending_connection.execute(Protocol::OptionsRequest.new)
+        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.warn(%[Compression algorithm "#{compression}" not supported (server supports "#{supported_algorithms.join('", "')}")])
+          compression = nil
+        end
+        @logger.debug('Using "%s" compression' % compression) if compression
+        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 no auth provider found'))
+            end
+          rescue => e
+            Ione::Future.failed(Errors::AuthenticationError.new('Auth provider raised an error: %s' % 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 no credentials provided'))
+          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, &block)
+        @request_runner.execute(@connection, request, nil, 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

@@ -0,0 +1,59 @@
+# 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