cql-rb 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad8c87f3d7ccc81d5b43765b4702882db21aab6f
-  data.tar.gz: c997140f2444a259a62c79a90118f7a1d634b3d1
+  metadata.gz: 076ceeab9f5eff0e9ab577f1e433b087342a8457
+  data.tar.gz: 049f3ecd2f935016bdd4bb08a87648163609600b
 SHA512:
-  metadata.gz: d409efa148092c538432f7d7ad0aa19dfd72370e1596415c5a69a8bb7a9918d0a5ca674f29a24115aa7cc62945c41ac8278f87540bd5e20becaabcf5039cfc44
-  data.tar.gz: ee05afbf07ba5453e50bdaffe3a3c761a4419285fb8132d2241b334e32c9f25ee4da2f527b100d6f58a0c3fcbd4f6b56de9de873d2a9bac54dc0486d5c1c4c6e
+  metadata.gz: e08c27d6a73bd4fc11573958ae2216affc238180d90d92c32aee98b20103a8614e6c1b693845b000c465b4ba9fd04b25c45a9ba012535a91e635974d832c66e5
+  data.tar.gz: 0e897851f1dab23f7eaa7ac1380071f4fa2bf0511a16911a5976156d197a533ba83b0fc05a2ee925050b9bc8b96f3ebf31a937158eddd222503b6e68c5343a7d

data/lib/cql.rb

@@ -17,6 +17,7 @@ module Cql
   Io = Ione::Io
 end
 
+require 'cql/error_codes'
 require 'cql/uuid'
 require 'cql/time_uuid'
 require 'cql/compression'

data/lib/cql/client.rb

@@ -6,6 +6,8 @@ module Cql
   # if any. `message` contains the human readable error message sent by the
   # server.
   class QueryError < CqlError
+    include ErrorCodes
+
     attr_reader :code, :cql, :details
 
     def initialize(code, message, cql=nil, details=nil)

data/lib/cql/client/client.rb

@@ -365,7 +365,7 @@ module Cql
       def connect_with_protocol_version_fallback
         f = create_cluster_connector.connect_all(@hosts, @connections_per_node)
         f.fallback do |error|
-          if error.is_a?(QueryError) && error.code == 0x0a && @protocol_version > 1
+          if error.is_a?(QueryError) && error.code == QueryError::PROTOCOL_ERROR && @protocol_version > 1
             @logger.warn('Could not connect using protocol version %d (will try again with %d): %s' % [@protocol_version, @protocol_version - 1, error.message])
             @protocol_version -= 1
             connect_with_protocol_version_fallback

data/lib/cql/client/connector.rb

@@ -24,7 +24,7 @@ module Cql
           connected_connections = connections.select(&:connected?)
           if connected_connections.empty?
             e = connections.first.error
-            if e.is_a?(Cql::QueryError) && e.code == 0x100
+            if e.is_a?(QueryError) && e.code == QueryError::BAD_CREDENTIALS
               e = AuthenticationError.new(e.message)
             end
             raise e

data/lib/cql/client/prepared_statement.rb

@@ -150,7 +150,13 @@ module Cql
       def execute(*args)
         connection = @connection_manager.random_connection
         if connection[self]
-          run(args, connection)
+          f = run(args, connection)
+          f.fallback do |e|
+            raise e unless e.is_a?(QueryError) && e.code == QueryError::UNPREPARED
+            prepare(connection).flat_map do
+              run(args, connection)
+            end
+          end
         else
           prepare(connection).flat_map do
             run(args, connection)
@@ -216,11 +222,12 @@ module Cql
       private
 
       def run(args, connection)
-        bound_args = args.shift(@raw_metadata.size)
-        unless bound_args.size == @raw_metadata.size && args.size <= 1
+        bound_args = args.take(@raw_metadata.size)
+        remaining_args = args.drop(@raw_metadata.size)
+        unless bound_args.size == @raw_metadata.size && remaining_args.size <= 1
           raise ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
         end
-        options = @execute_options_decoder.decode_options(args.last)
+        options = @execute_options_decoder.decode_options(remaining_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])

data/lib/cql/error_codes.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+module Cql
+  module ErrorCodes
+    # Something unexpected happened. This indicates a server-side bug.
+    SERVER_ERROR = 0x0000
+
+    # Some client message triggered a protocol violation (for instance a QUERY
+    # message is sent before a STARTUP one has been sent).
+    PROTOCOL_ERROR = 0x000A
+
+    # CREDENTIALS request failed because Cassandra did not accept the provided credentials.
+    BAD_CREDENTIALS = 0x0100
+
+    # Unavailable exception.
+    #
+    # Details:
+    #
+    # * `:cl` - The consistency level of the query having triggered the exception.
+    # * `:required` - An int representing the number of nodes that should be alive to respect `:cl`.
+    # * `:alive` - An int representing the number of replica that were known to be
+    #   alive when the request has been processed (since an unavailable
+    #   exception has been triggered, there will be `:alive` < `:required`.
+    UNAVAILABLE = 0x1000
+
+    # The request cannot be processed because the coordinator node is overloaded.
+    OVERLOADED = 0x1001
+
+    # The request was a read request but the coordinator node is bootstrapping.
+    IS_BOOTSTRAPPING = 0x1002
+
+    # Error during a truncation error.
+    TRUNCATE_ERROR = 0x1003
+
+    # Timeout exception during a write request.
+    #
+    # Details:
+    #
+    # * `:cl` - The consistency level of the query having triggered the exception.
+    # * `:received` - An int representing the number of nodes having acknowledged the request.
+    # * `:blockfor` - The number of replica whose acknowledgement is required to achieve `:cl`.
+    # * `:write_type` - A string that describe the type of the write that timeouted. The value of that string can be one of:
+    #   - `"SIMPLE"`: the write was a non-batched non-counter write.
+    #   - `"BATCH"`: the write was a (logged) batch write. If this type is received, it means the batch log
+    #     has been successfully written (otherwise a `"BATCH_LOG"` type would have been send instead).
+    #   - `"UNLOGGED_BATCH"`: the write was an unlogged batch. Not batch log write has been attempted.
+    #   - `"COUNTER"`: the write was a counter write (batched or not).
+    #   - `"BATCH_LOG"`: the timeout occured during the write to the batch log when a (logged) batch write was requested.
+    WRITE_TIMEOUT = 0x1100
+
+    # Timeout exception during a read request.
+    #
+    # Details:
+    #
+    # * `:cl` - The consistency level of the query having triggered the exception
+    # * `:received` -  An int representing the number of nodes having answered the request.
+    # * `:blockfor` -  The number of replica whose response is required to achieve `:cl`.
+    #   Please note that it is possible to have `:received` >= `:blockfor` if
+    #   `:data_present` is false. And also in the (unlikely) case were `:cl` is
+    #   achieved but the coordinator node timeout while waiting for read-repair
+    #   acknowledgement.
+    # * `:data_present` - If `true`, it means the replica that was asked for data has not responded.
+    READ_TIMEOUT = 0x1200
+
+    # The submitted query has a syntax error.
+    SYNTAX_ERROR = 0x2000
+
+    # The logged user doesn't have the right to perform the query.
+    UNAUTHORIZED = 0x2100
+
+    # The query is syntactically correct but invalid.
+    INVALID = 0x2200
+
+    # The query is invalid because of some configuration issue.
+    CONFIG_ERROR = 0x2300
+
+    # The query attempted to create a keyspace or a table that was already existing.
+    #
+    # Details:
+    #
+    # * `:ks` - A string representing either the keyspace that already exists, or the
+    #   keyspace in which the table that already exists is.
+    # * `:table` -  A string representing the name of the table that already exists. If the
+    #   query was attempting to create a keyspace, `:table` will be present but
+    #   will be the empty string.
+    ALREADY_EXISTS = 0x2400
+
+    # Can be thrown while a prepared statement tries to be executed if the
+    # provide prepared statement ID is not known by this host.
+    #
+    # Details:
+    #
+    # * `:id` - The unknown ID.
+    UNPREPARED = 0x2500
+  end
+end

data/lib/cql/protocol/responses/detailed_error_response.rb

@@ -13,24 +13,24 @@ module Cql
       def self.decode(code, message, protocol_version, buffer, length, trace_id=nil)
         details = {}
         case code
-        when 0x1000 # unavailable
+        when UNAVAILABLE
           details[:cl] = buffer.read_consistency
           details[:required] = buffer.read_int
           details[:alive] = buffer.read_int
-        when 0x1100 # write_timeout
+        when WRITE_TIMEOUT
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
           details[:blockfor] = buffer.read_int
           details[:write_type] = buffer.read_string
-        when 0x1200 # read_timeout
+        when READ_TIMEOUT
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
           details[:blockfor] = buffer.read_int
           details[:data_present] = buffer.read_byte != 0
-        when 0x2400 # already_exists
+        when ALREADY_EXISTS
           details[:ks] = buffer.read_string
           details[:table] = buffer.read_string
-        when 0x2500
+        when UNPREPARED
           details[:id] = buffer.read_short_bytes
         end
         new(code, message, details)

data/lib/cql/protocol/responses/error_response.rb

@@ -3,6 +3,8 @@
 module Cql
   module Protocol
     class ErrorResponse < Response
+      include ErrorCodes
+
       attr_reader :code, :message
 
       def initialize(*args)
@@ -13,7 +15,7 @@ module Cql
         code = buffer.read_int
         message = buffer.read_string
         case code
-        when 0x1000, 0x1100, 0x1200, 0x2400, 0x2500
+        when UNAVAILABLE, WRITE_TIMEOUT, READ_TIMEOUT, ALREADY_EXISTS, UNPREPARED
           new_length = length - 4 - 4 - message.bytesize
           DetailedErrorResponse.decode(code, message, protocol_version, buffer, new_length)
         else

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '2.0.4'.freeze
+  VERSION = '2.0.5'.freeze
 end

data/spec/cql/client/prepared_statement_spec.rb

@@ -295,6 +295,25 @@ module Cql
           statement.execute(11, 'hello', trace: true).value
           tracing.should be_true
         end
+
+        it 'prepares the statement again when it is lost' do
+          prepare_requests = 0
+          connections.each do |c|
+            c[:num_prepare] = 0
+            c.handle_request do |r, t|
+              if r.is_a?(Protocol::ExecuteRequest) && c[:num_prepare] == 1
+                Protocol::ErrorResponse.new(0x2500, 'Unprepared')
+              else
+                if r == Protocol::PrepareRequest.new(cql)
+                  c[:num_prepare] += 1
+                end
+                handle_request(c, r, t)
+              end
+            end
+          end
+          statement.execute(11, 'hello').value
+          connections.map { |c| c[:num_prepare] }.should include(2)
+        end
       end
 
       describe '#batch' do

data/spec/integration/client_spec.rb

@@ -108,6 +108,13 @@ describe 'A CQL client' do
       counters = result.each_with_object({}) { |row, acc| acc[row['id']] = row['count'] }
       counters.should eql('foo' => 11, 'bar' => 3)
     end
+
+    it 'handles altered tables' do
+      result1 = statement.execute('sue')
+      client.execute('ALTER TABLE users ADD password VARCHAR')
+      result2 = statement.execute('sue')
+      result2.to_a.should eql(result1.to_a)
+    end
   end
 
   context 'with multiple connections' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-26 00:00:00.000000000 Z
+date: 2015-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
@@ -54,6 +54,7 @@ files:
 - lib/cql/compression.rb
 - lib/cql/compression/lz4_compressor.rb
 - lib/cql/compression/snappy_compressor.rb
+- lib/cql/error_codes.rb
 - lib/cql/protocol.rb
 - lib/cql/protocol/cql_byte_buffer.rb
 - lib/cql/protocol/cql_protocol_handler.rb