cql-rb 1.1.0.pre3 → 1.1.0.pre6

data/README.md

@@ -118,7 +118,7 @@ A prepared statement can be run many times, but the CQL parsing will only be don
 
 At this time prepared statements are local to a single connection. Even if you connect to multiple nodes a prepared statement is only ever going to be executed against one of the nodes.
 
-# Consistency levels
+# Consistency
 
 The `#execute` (of `Client` and `PreparedStatement`) method supports setting the desired consistency level for the statement:
 
@@ -139,7 +139,7 @@ The possible values are:
 
 The default consistency level is `:quorum`.
 
-Consistency level is ignored for `USE`, `TRUNCATE`, `CREATE` and `ALTER` statements, and some (like `:any`) aren't allowed in all situations.
+Consistency is ignored for `USE`, `TRUNCATE`, `CREATE` and `ALTER` statements, and some (like `:any`) aren't allowed in all situations.
 
 ## CQL3
 

data/lib/cql/client.rb

@@ -147,13 +147,13 @@ module Cql
       # Execute the prepared statement with a list of values for the bound parameters.
       #
       # The number of arguments must equal the number of bound parameters.
-      # To set the consistency level for the request you pass a consistency
-      # level (as a symbol) as the last argument. Needless to say, if you pass
-      # the value for one bound parameter too few, and then a consistency level,
-      # or if you pass too many values, you will get weird errors.
+      # To set the consistency for the request you pass a consistency (as a
+      # symbol) as the last argument. Needless to say, if you pass the value for
+      # one bound parameter too few, and then a consistency, or if you pass too
+      # many values, you will get weird errors.
       #
       # @param args [Array] the values for the bound parameters, and optionally
-      #   the desired consistency level, as a symbol (defaults to :quorum)
+      #   the desired consistency, as a symbol (defaults to :quorum)
       # @raise [Cql::NotConnectedError] raised when the client is not connected
       # @raise [Cql::QueryError] raised when there is an error on the server side
       # @return [nil, Cql::Client::QueryResult] Most statements have no result and return
@@ -165,9 +165,13 @@ module Cql
   end
 end
 
+require 'cql/client/connection_manager'
+require 'cql/client/connection_helper'
+require 'cql/client/null_logger'
 require 'cql/client/column_metadata'
 require 'cql/client/result_metadata'
 require 'cql/client/query_result'
+require 'cql/client/keyspace_changer'
 require 'cql/client/asynchronous_client'
 require 'cql/client/asynchronous_prepared_statement'
 require 'cql/client/synchronous_client'

data/lib/cql/client/asynchronous_client.rb

@@ -5,41 +5,45 @@ module Cql
     # @private
     class AsynchronousClient < Client
       def initialize(options={})
-        @connection_timeout = options[:connection_timeout] || 10
-        @hosts = extract_hosts(options)
-        @port = options[:port] || 9042
+        @logger = options[:logger] || NullLogger.new
         @io_reactor = options[:io_reactor] || Io::IoReactor.new(Protocol::CqlProtocolHandler)
+        @hosts = extract_hosts(options)
+        @initial_keyspace = options[:keyspace]
+        @default_consistency = options[:default_consistency] || DEFAULT_CONSISTENCY
         @lock = Mutex.new
         @connected = false
         @connecting = false
         @closing = false
-        @initial_keyspace = options[:keyspace]
-        @credentials = options[:credentials]
         @request_runner = RequestRunner.new
+        @keyspace_changer = KeyspaceChanger.new
+        @connection_manager = ConnectionManager.new
+        port = options[:port] || DEFAULT_PORT
+        credentials = options[:credentials]
+        connection_timeout = options[:connection_timeout] || DEFAULT_CONNECTION_TIMEOUT
+        @connection_helper = ConnectionHelper.new(@io_reactor, port, credentials, connection_timeout, @logger)
       end
 
       def connect
         @lock.synchronize do
           return @connected_future if can_execute?
           @connecting = true
-          @connected_future = Future.new
-          @connections = []
-        end
-        when_not_closing do
-          setup_connections
-        end
-        @connected_future.on_complete do
-          @lock.synchronize do
-            @connecting = false
-            @connected = true
-          end
-        end
-        @connected_future.on_failure do
-          @lock.synchronize do
-            @connecting = false
-            @connected = false
+          @connected_future = begin
+            f = @connection_helper.connect(@hosts, @initial_keyspace)
+            if @closing
+              ff = @closed_future
+              ff = ff.flat_map { f }
+              ff = ff.fallback { f }
+            else
+              ff = f
+            end
+            ff.on_value do |connections|
+              @connection_manager.add_connections(connections)
+              register_event_listener(@connection_manager.random_connection)
+            end
+            ff.map { self }
           end
         end
+        @connected_future.on_complete(&method(:connected))
         @connected_future
       end
 
@@ -47,25 +51,19 @@ module Cql
         @lock.synchronize do
           return @closed_future if @closing
           @closing = true
-          @closed_future = Future.new
-        end
-        when_not_connecting do
-          f = @io_reactor.stop
-          f.on_complete { @closed_future.complete!(self) }
-          f.on_failure { |e| @closed_future.fail!(e) }
-        end
-        @closed_future.on_complete do
-          @lock.synchronize do
-            @closing = false
-            @connected = false
-          end
-        end
-        @closed_future.on_failure do
-          @lock.synchronize do
-            @closing = false
-            @connected = false
+          @closed_future = begin
+            f = @io_reactor.stop
+            if @connecting
+              ff = @connected_future
+              ff = f.flat_map { ff }
+              ff = f.fallback { ff }
+            else
+              ff = f
+            end
+            ff.map { self }
           end
         end
+        @closed_future.on_complete(&method(:closed))
         @closed_future
       end
 
@@ -74,55 +72,38 @@ module Cql
       end
 
       def keyspace
-        @lock.synchronize do
-          @connections.first.keyspace
-        end
+        @connection_manager.random_connection.keyspace
       end
 
       def use(keyspace)
         with_failure_handler do
-          connections = @lock.synchronize do
-            @connections.select { |c| c.keyspace != keyspace }
-          end
+          connections = @connection_manager.select { |c| c.keyspace != keyspace }
           if connections.any?
-            futures = connections.map { |connection| use_keyspace(keyspace, connection) }
-            Future.combine(*futures).map { nil }
+            futures = connections.map { |connection| @keyspace_changer.use_keyspace(keyspace, connection) }
+            Future.all(*futures).map { nil }
           else
-            Future.completed(nil)
+            Future.resolved
           end
         end
       end
 
       def execute(cql, consistency=nil)
         with_failure_handler do
-          consistency ||= DEFAULT_CONSISTENCY_LEVEL
-          execute_request(Protocol::QueryRequest.new(cql, consistency))
+          execute_request(Protocol::QueryRequest.new(cql, consistency || @default_consistency))
         end
       end
 
       def prepare(cql)
         with_failure_handler do
-          execute_request(Protocol::PrepareRequest.new(cql))
+          AsynchronousPreparedStatement.prepare(cql, @default_consistency, @connection_manager, @logger)
         end
       end
 
       private
 
-      KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$|^"\w[\w\d_]*"$/
-      DEFAULT_CONSISTENCY_LEVEL = :quorum
-      BIND_ALL_IP = '0.0.0.0'.freeze
-
-      class FailedConnection
-        attr_reader :error
-
-        def initialize(error)
-          @error = error
-        end
-
-        def connected?
-          false
-        end
-      end
+      DEFAULT_CONSISTENCY = :quorum
+      DEFAULT_PORT = 9042
+      DEFAULT_CONNECTION_TIMEOUT = 10
 
       def extract_hosts(options)
         if options[:hosts]
@@ -134,159 +115,91 @@ module Cql
         end
       end
 
-      def can_execute?
-        @connected || @connecting
-      end
-
-      def valid_keyspace_name?(name)
-        name =~ KEYSPACE_NAME_PATTERN
-      end
-
-      def with_failure_handler
-        return Future.failed(NotConnectedError.new) unless can_execute?
-        yield
-      rescue => e
-        Future.failed(e)
-      end
-
-      def when_not_connecting(&callback)
-        if @connecting
-          @connected_future.on_complete(&callback)
-          @connected_future.on_failure(&callback)
-        else
-          callback.call
-        end
-      end
-
-      def when_not_closing(&callback)
-        if @closing
-          @closed_future.on_complete(&callback)
-          @closed_future.on_failure(&callback)
-        else
-          callback.call
-        end
-      end
-
-      def discover_peers(seed_connections, initial_keyspace)
-        connected_seeds = seed_connections.select(&:connected?)
-        connection = connected_seeds.sample
-        return Future.completed([]) unless connection
-        request = Protocol::QueryRequest.new('SELECT peer, data_center, host_id, rpc_address FROM system.peers', :one)
-        peer_info = execute_request(request, connection)
-        peer_info.flat_map do |result|
-          seed_dcs = connected_seeds.map { |c| c[:data_center] }.uniq
-          unconnected_peers = result.select do |row|
-            seed_dcs.include?(row['data_center']) && connected_seeds.none? { |c| c[:host_id] == row['host_id'] }
+      def connected(f)
+        if f.resolved?
+          @lock.synchronize do
+            @connecting = false
+            @connected = true
           end
-          node_addresses = unconnected_peers.map do |row|
-            rpc_address = row['rpc_address'].to_s
-            if rpc_address == BIND_ALL_IP
-              row['peer'].to_s
-            else
-              rpc_address
-            end
+          @logger.info('Cluster connection complete')
+        else
+          @lock.synchronize do
+            @connecting = false
+            @connected = false
           end
-          if node_addresses.any?
-            connect_to_hosts(node_addresses, initial_keyspace, false)
-          else
-            Future.completed([])
+          f.on_failure do |e|
+            @logger.error('Failed connecting to cluster: %s' % e.message)
           end
+          close
         end
       end
 
-      def setup_connections
-        f = @io_reactor.start.flat_map do
-          connect_to_hosts(@hosts, @initial_keyspace, true)
-        end
-        f.on_failure do |e|
-          fail_connecting(e)
-        end
-        f.on_complete do |connections|
-          connected_connections = connections.select(&:connected?)
-          if connected_connections.any?
-            @connections = connected_connections
-            @connected_future.complete!(self)
+      def closed(f)
+        @lock.synchronize do
+          @closing = false
+          @connected = false
+          if f.resolved?
+            @logger.info('Cluster disconnect complete')
           else
-            fail_connecting(connections.first.error)
-          end
-        end
-      end
-
-      def fail_connecting(e)
-        close
-        if e.is_a?(Cql::QueryError) && e.code == 0x100
-          @connected_future.fail!(AuthenticationError.new(e.message))
-        else
-          @connected_future.fail!(e)
-        end
-      end
-
-      def connect_to_hosts(hosts, initial_keyspace, peer_discovery)
-        connection_futures = hosts.map do |host|
-          connect_to_host(host, initial_keyspace).recover do |error|
-            FailedConnection.new(error)
-          end
-        end
-        hosts_connected_future = Future.combine(*connection_futures)
-        if peer_discovery
-          hosts_connected_future.flat_map do |connections|
-            discover_peers(connections, initial_keyspace).map do |peer_connections|
-              connections + peer_connections
+            f.on_failure do |e|
+              @logger.error('Cluster disconnect failed: %s' % e.message)
             end
           end
-        else
-          hosts_connected_future
         end
       end
 
-      def connect_to_host(host, keyspace)
-        connected = @io_reactor.connect(host, @port, @connection_timeout)
-        connected.flat_map do |connection|
-          initialize_connection(connection, keyspace)
-        end
+      def can_execute?
+        !@closing && (@connecting || (@connected && @connection_manager.connected?))
       end
 
-      def initialize_connection(connection, keyspace)
-        started = execute_request(Protocol::StartupRequest.new, connection)
-        authenticated = started.flat_map { |response| maybe_authenticate(response, connection) }
-        identified = authenticated.flat_map { identify_node(connection) }
-        identified.flat_map { use_keyspace(keyspace, connection) }
+      def with_failure_handler
+        return Future.failed(NotConnectedError.new) unless can_execute?
+        yield
+      rescue => e
+        Future.failed(e)
       end
 
-      def identify_node(connection)
-        request = Protocol::QueryRequest.new('SELECT data_center, host_id FROM system.local', :one)
-        f = execute_request(request, connection)
-        f.on_complete do |result|
-          unless result.empty?
-            connection[:host_id] = result.first['host_id']
-            connection[:data_center] = result.first['data_center']
+      def register_event_listener(connection)
+        register_request = Protocol::RegisterRequest.new(Protocol::TopologyChangeEventResponse::TYPE, Protocol::StatusChangeEventResponse::TYPE)
+        execute_request(register_request, connection)
+        connection.on_closed do
+          if connected?
+            begin
+              register_event_listener(@connection_manager.random_connection)
+            rescue NotConnectedError
+              # we had started closing down after the connection check
+            end
+          end
+        end
+        connection.on_event do |event|
+          begin
+            if event.change == 'UP'
+              @logger.debug('Received UP event')
+              handle_topology_change
+            end
           end
         end
-        f
-      end
-
-      def use_keyspace(keyspace, connection)
-        return Future.completed(connection) unless keyspace
-        return Future.failed(InvalidKeyspaceNameError.new(%("#{keyspace}" is not a valid keyspace name))) unless valid_keyspace_name?(keyspace)
-        execute_request(Protocol::QueryRequest.new("USE #{keyspace}", :one), connection).map { connection }
       end
 
-      def maybe_authenticate(response, connection)
-        case response
-        when AuthenticationRequired
-          if @credentials
-            credentials_request = Protocol::CredentialsRequest.new(@credentials)
-            execute_request(credentials_request, connection).map { connection }
+      def handle_topology_change
+        seed_connections = @connection_manager.snapshot
+        f = @connection_helper.discover_peers(seed_connections, keyspace)
+        f.on_value do |connections|
+          connected_connections = connections.select(&:connected?)
+          if connected_connections.any?
+            @connection_manager.add_connections(connected_connections)
           else
-            Future.failed(AuthenticationError.new('Server requested authentication, but no credentials given'))
+            @logger.debug('Scheduling new peer discovery in 1s')
+            f = @io_reactor.schedule_timer(1)
+            f.on_value do
+              handle_topology_change
+            end
           end
-        else
-          Future.completed(connection)
         end
       end
 
       def execute_request(request, connection=nil)
-        f = @request_runner.execute(connection || @connections.sample, request)
+        f = @request_runner.execute(connection || @connection_manager.random_connection, request)
         f.map do |result|
           if result.is_a?(KeyspaceChanged)
             use(result.keyspace)

data/lib/cql/client/asynchronous_prepared_statement.rb

@@ -4,22 +4,64 @@ module Cql
   module Client
     # @private
     class AsynchronousPreparedStatement < PreparedStatement
-      def initialize(connection, statement_id, raw_metadata)
-        @connection = connection
-        @statement_id = statement_id
-        @raw_metadata = raw_metadata
-        @metadata = ResultMetadata.new(@raw_metadata)
+      # @private
+      def initialize(cql, default_consistency, connection_manager, logger)
+        @cql = cql
+        @default_consistency = default_consistency
+        @connection_manager = connection_manager
+        @logger = logger
         @request_runner = RequestRunner.new
       end
 
+      def self.prepare(cql, default_consistency, connection_manager, logger)
+        statement = new(cql, default_consistency, connection_manager, logger)
+        futures = connection_manager.map do |connection|
+          statement.prepare(connection)
+        end
+        Future.all(*futures).map { statement }
+      rescue => e
+        Future.failed(e)
+      end
+
       def execute(*args)
-        bound_args = args.shift(@raw_metadata.size)
-        consistency_level = args.shift || :quorum
-        request = Cql::Protocol::ExecuteRequest.new(@statement_id, @raw_metadata, bound_args, consistency_level)
-        @request_runner.execute(@connection, request)
+        connection = @connection_manager.random_connection
+        if connection[self]
+          run(args, connection)
+        else
+          prepare(connection).flat_map do
+            run(args, connection)
+          end
+        end
       rescue => e
         Future.failed(e)
       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)
+          end
+          @logger.debug('Statement prepared on new connection')
+        end
+        f.map { self }
+      end
+
+      private
+
+      def run(args, connection)
+        statement_id = connection[self]
+        bound_args = args.shift(@raw_metadata.size)
+        consistency = args.shift || @default_consistency
+        statement_id = connection[self]
+        request = Protocol::ExecuteRequest.new(statement_id, @raw_metadata, bound_args, consistency)
+        @request_runner.execute(connection, request)
+      end
     end
   end
 end