cassandra-driver 1.1.1 → 1.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjJiMTUxNjdlNWI3Y2M3Mzk3NzFiMjQ4NDEzMGNlMTJiYmQyM2Q2MA==
+    NzBmYWI0MTgyNjhhMWU2MGNjMjg0NWQzM2M5ODdkZTg4MWVkZjIzMQ==
   data.tar.gz: !binary |-
-    ZTIzZjE2NzFjNTI5YTEyZDUxMWUxMjdiYzEwOTg2Nzc0YzhjZDFjZA==
+    ZmNlZTUxNGEwNDBmYTdiM2U1N2U1MDUzODRkZDM0ZjBjNTA3YzRkOA==
 SHA512:
   metadata.gz: !binary |-
-    YmNiNDQxMmI3OTdhN2FhOTA3Njc2NjlhMmE1ZTkzNTRmOWZkNjVjNTRiZTc5
-    MjViMDFkMWU1NzRhODIxY2UxMWUxNGVjMGE1N2Y0ZTZlMzQ1NDA5YjFlNDcw
-    MDk3ZTdjNjM2YjUyMjIwOTZmY2VkN2M4OTY3NGVmNWUzYTgwZGM=
+    Nzg5OGIzNzVlNzkyY2U4MWM3NjQwNTIwMDRkNWM0M2EwYjliYmM2MDg1NjA3
+    NjZhYmEzYjBiNTdkMWY1MWM2OWY5OTJmYmEzNWMzMzdiYjliNTM4NDE1OWM4
+    MDc3N2Y1YWFhMDI3MzU3NjQxODYyZGExMDU4YjM5ODYwYTkyMzE=
   data.tar.gz: !binary |-
-    YmMwN2E5NmIyNWJlNTE3ZjEyMzM0MDI4MmU0NzFlMTM5MGQ5YjkzYWE3ZTk4
-    OGI2NDZjNTI0MzA1NjdlMjUxYTBiMTFkY2VmZTZmNWEwZjk1MWFiMjlmNDc3
-    ZmViMDVkNjFkMGU3ZGNmYTgwZjg2YzkxODI5YTE0NzE4NzMxMGI=
+    MjVhYTZmZjEwYjFjMDY5ZTU2NzIzYmQ1ZGU3MzE3OWMxYTMzMzYwN2NjZmMx
+    ZGFiZGI2NTg1ZjJhMzlmYTc4MDI1MmUxNWI0ZjA5YjVmODVlYmRlOWQzYmEy
+    YWM5NWEwNjE0ODM4YWFiYmY1OTFjZDJlYzIyZmU4MmQ1YWRkNDY=

data/README.md

@@ -93,16 +93,12 @@ __Note__: if you want to use compression you should also install [snappy](http:/
 
 Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API. In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/master/examples/cql-rb-wrapper.rb) to assist you with gradual upgrade.
 
-## What's new in v1.1.1
+## What's new in v1.2.0
 
-Current release introduces the following new features:
+Bug Fixes:
 
-* Ability to disable automatic schema synchronization
-* Schema change event storm protection using a sliding delay
-* [`Cassandra::LoadBalancing::Policy#teardown`](http://datastax.github.io/ruby-driver/api/load_balancing/policy/#teardown-instance_method) for cleaning up resources
-* [`Cassandra::Cluster#refresh_schema`](http://datastax.github.io/ruby-driver/api/cluster/#refresh_schema-instance_method) for manually refreshing schema metadata
-* Host list randomization to prevent hotspots between multiple clients
-* Future listeners run in a dedicated threadpool to not block the reactor
+* [RUBY-83] Timestamps loses microseconds when retrieved from database
+* [RUBY-85] Driver doesn't always reconnect
 
 ## Code examples
 
@@ -147,6 +143,10 @@ Prereleases will be stable, in the sense that they will have finished and proper
 
 Please [refer to the usage documentation for more information on common pitfalls](http://datastax.github.io/ruby-driver/features/)
 
+## Contributing
+
+For contributing read [CONTRIBUTING.md](https://github.com/datastax/ruby-driver/blob/master/README.md)
+
 ## Credits
 
 This driver is based on the original work of [Theo Hultberg](https://github.com/iconara) on [cql-rb](https://github.com/iconara/cql-rb/) and adds a series of advanced features that are common across all other DataStax drivers for Apache Cassandra.

data/lib/cassandra/cluster/client.rb

@@ -36,10 +36,10 @@ module Cassandra
         @address_resolver            = address_resolution_policy
         @connection_options          = connection_options
         @futures                     = futures_factory
-        @connecting_hosts            = ::Hash.new
         @connections                 = ::Hash.new
         @prepared_statements         = ::Hash.new
         @preparing_statements        = ::Hash.new
+        @pending_connections         = ::Hash.new
         @keyspace                    = nil
         @state                       = :idle
 
@@ -47,6 +47,8 @@ module Cassandra
       end
 
       def connect
+        connecting_hosts = ::Hash.new
+
         synchronize do
           return CLIENT_CLOSED     if @state == :closed || @state == :closing
           return @connected_future if @state == :connecting || @state == :connected
@@ -54,9 +56,24 @@ module Cassandra
           @state = :connecting
           @registry.each_host do |host|
             distance = @load_balancing_policy.distance(host)
-            next if distance == :ignore
 
-            @connecting_hosts[host] = distance
+            case distance
+            when :ignore
+              next
+            when :local
+              pool_size = @connection_options.connections_per_local_node
+            when :remote
+              pool_size = @connection_options.connections_per_remote_node
+            else
+              @logger.error("Not connecting to #{host.ip} - invalid load balancing distance. Distance must be one of #{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
+              next
+            end
+
+            connecting_hosts[host] = pool_size
+            @pending_connections[host] = 0
+            @prepared_statements[host] = {}
+            @preparing_statements[host] = {}
+            @connections[host] = ConnectionPool.new
           end
         end
 
@@ -65,8 +82,8 @@ module Cassandra
           @registry.add_listener(self)
           @schema.add_listener(self)
 
-          futures = @connecting_hosts.map do |(host, distance)|
-            f = connect_to_host(host, distance)
+          futures = connecting_hosts.map do |(host, pool_size)|
+            f = connect_to_host(host, pool_size)
             f.recover do |error|
               FailedConnection.new(error, host)
             end
@@ -125,30 +142,40 @@ module Cassandra
       end
 
       def host_up(host)
-        distance = nil
+        pool_size = 0
 
         synchronize do
-          return Ione::Future.resolved if @connecting_hosts.include?(host)
-
           distance = @load_balancing_policy.distance(host)
-          return Ione::Future.resolved if distance == :ignore
+          case distance
+          when :ignore
+            return Ione::Future.resolved
+          when :local
+            pool_size = @connection_options.connections_per_local_node
+          when :remote
+            pool_size = @connection_options.connections_per_remote_node
+          else
+            @logger.error("Not connecting to #{host.ip} - invalid load balancing distance. Distance must be one of #{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
+            return Ione::Future.resolved
+          end
 
-          @connecting_hosts[host] = distance
+          @pending_connections[host] ||= 0
+          @prepared_statements[host] = {}
+          @preparing_statements[host] = {}
+          @connections[host] = ConnectionPool.new
         end
 
-        connect_to_host_maybe_retry(host, distance).map(nil)
+        connect_to_host_maybe_retry(host, pool_size)
       end
 
       def host_down(host)
         pool = nil
 
         synchronize do
-          return Ione::Future.resolved if !@connections.has_key?(host) && !@connecting_hosts.include?(host)
+          return Ione::Future.resolved unless @connections.has_key?(host)
 
-          @connecting_hosts.delete(host)
+          @pending_connections.delete(host) unless @pending_connections[host] > 0
           @prepared_statements.delete(host)
           @preparing_statements.delete(host)
-
           pool = @connections.delete(host)
         end
 
@@ -299,93 +326,89 @@ module Cassandra
         Ione::Future.all(*futures).map(self)
       end
 
-      def connect_to_host_maybe_retry(host, distance)
-        f = connect_to_host(host, distance)
-
-        f.on_failure do |e|
-          connect_to_host_with_retry(host, @reconnection_policy.schedule)
-        end
-
-        f
+      def connect_to_host_maybe_retry(host, pool_size)
+        connect_to_host(host, pool_size).fallback do |e|
+          @logger.error("Scheduling initial connection retry to #{host.ip} (#{e.class.name}: #{e.message})")
+          connect_to_host_with_retry(host, pool_size, @reconnection_policy.schedule)
+        end.map(nil)
       end
 
-      def connect_to_host_with_retry(host, schedule)
+      def connect_to_host_with_retry(host, pool_size, schedule)
         interval = schedule.next
 
         @logger.debug("Reconnecting to #{host.ip} in #{interval} seconds")
 
         f = @reactor.schedule_timer(interval)
         f.flat_map do
-          distance = nil
-
-          synchronize do
-            if @connecting_hosts.include?(host)
-              distance = @load_balancing_policy.distance(host)
-            end
-          end
-
-          if distance && distance != :ignore
-            connect_to_host(host, distance).fallback do |e|
-              connect_to_host_with_retry(host, schedule)
-            end
-          else
-            NO_CONNECTIONS
+          connect_to_host(host, pool_size).fallback do |e|
+            @logger.error("Scheduling connection retry to #{host.ip} (#{e.class.name}: #{e.message})")
+            connect_to_host_with_retry(host, pool_size, schedule)
           end
         end
       end
 
-      def connect_to_host(host, distance)
-        case distance
-        when :ignore
-          return NO_CONNECTIONS
-        when :local
-          pool_size = @connection_options.connections_per_local_node
-        when :remote
-          pool_size = @connection_options.connections_per_remote_node
-        else
-          @logger.error("Invalid load balancing distance, not connecting to #{host.ip}. Distance must be one of #{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
-          return NO_CONNECTIONS
-        end
-
-        pool = nil
-        existing_connections = 0
+      def connect_to_host(host, pool_size)
+        size = 0
 
         synchronize do
+          unless @connections.include?(host)
+            @logger.info("Not connecting to #{host.ip} - host is currently down")
+            return NO_CONNECTIONS
+          end
+
           pool = @connections[host]
-        end
+          size = pool_size - pool.size
 
-        existing_connections = pool.size if pool
-        pool = nil
-        missing_connections  = (pool_size - existing_connections)
-        return Ione::Future.resolved if missing_connections <= 0
+          if size <= 0
+            @logger.info("Not connecting to #{host.ip} - host is already fully connected")
+            return NO_CONNECTIONS
+          end
+
+          size -= @pending_connections[host]
 
-        f = @connector.connect_many(host, missing_connections)
+          if size <= 0
+            @logger.info("Not connecting to #{host.ip} - host is already pending connections")
+            return NO_CONNECTIONS
+          end
+
+          @pending_connections[host] += size
+        end
+
+        @logger.debug("Creating #{size} connections to #{host.ip}")
+        f = @connector.connect_many(host, size)
 
         f.on_value do |connections|
+          @logger.debug("Created #{connections.size} connections to #{host.ip}")
+
           pool = nil
 
           synchronize do
-            @connecting_hosts.delete(host)
-            @prepared_statements[host] = {}
-            @preparing_statements[host] = {}
-            pool = @connections[host] ||= ConnectionPool.new
-          end
+            @pending_connections[host] -= size
 
-          pool.add_connections(connections)
+            if @connections.include?(host)
+              pool = @connections[host]
+            else
+              @pending_connections.delete(host) unless @pending_connections[host] > 0
+            end
+          end
 
-          connections.each do |connection|
-            connection.on_closed do
-              distance = nil
+          if pool
+            pool.add_connections(connections)
 
-              synchronize do
-                if !(@state == :closed || @state == :closing) && !@connecting_hosts.include?(host) && @connections.include?(host)
-                  distance = @load_balancing_policy.distance(host)
-                  @connecting_hosts[host] = distance unless distance == :ignore
-                end
+            connections.each do |connection|
+              connection.on_closed do |cause|
+                connect_to_host_maybe_retry(host, pool_size) if cause
               end
-
-              connect_to_host_maybe_retry(host, distance).map(nil) if distance
             end
+          else
+            connections.each {|c| c.close}
+          end
+        end
+
+        f.on_failure do |error|
+          synchronize do
+            @pending_connections[host] -= size
+            @pending_connections.delete(host) unless @pending_connections[host] > 0 || @connections.include?(host)
           end
         end
 

data/lib/cassandra/cluster/connector.rb

@@ -116,12 +116,12 @@ module Cassandra
       UNCLAIMED_TIMEOUT = 5 # close unclaimed connections in five seconds
 
       def do_connect(host)
-        f = @reactor.connect(host.ip.to_s, @connection_options.port, {:timeout => @connection_options.connect_timeout, :ssl => @connection_options.ssl}) do |connection|
+        @reactor.connect(host.ip.to_s, @connection_options.port, {:timeout => @connection_options.connect_timeout, :ssl => @connection_options.ssl}) do |connection|
           raise Errors::ClientError, 'Not connected, reactor stopped' unless connection
           Protocol::CqlProtocolHandler.new(connection, @reactor, @connection_options.protocol_version, @connection_options.compressor, @connection_options.heartbeat_interval, @connection_options.idle_timeout)
-        end
-        f = f.flat_map do |connection|
-          request_options(connection).flat_map do |options|
+        end.flat_map do |connection|
+          f = request_options(connection)
+          f = f.flat_map do |options|
             compression = @connection_options.compression
             supported_algorithms = options['COMPRESSION']
 
@@ -135,19 +135,30 @@ module Cassandra
 
             startup_connection(connection, cql_version, compression)
           end
-        end
-        f.fallback do |error|
-          case error
-          when Errors::ProtocolError
-            synchronize do
-              if @connection_options.protocol_version > 1
-                @logger.info("Host #{host.ip} doesn't support protocol version #{@connection_options.protocol_version}, downgrading")
-                @connection_options.protocol_version -= 1
-                do_connect(host)
-              else
-                Ione::Future.failed(error)
+          f.fallback do |error|
+            case error
+            when Errors::ProtocolError
+              synchronize do
+                if @connection_options.protocol_version > 1
+                  @logger.info("Host #{host.ip} doesn't support protocol version #{@connection_options.protocol_version}, downgrading")
+                  @connection_options.protocol_version -= 1
+                  do_connect(host)
+                else
+                  Ione::Future.failed(error)
+                end
               end
+            when Errors::TimeoutError
+              future = Ione::CompletableFuture.new
+              connection.close(error).on_complete do |f|
+                future.fail(error)
+              end
+              future
+            else
+              Ione::Future.failed(error)
             end
+          end
+        end.fallback do |error|
+          case error
           when Error
             Ione::Future.failed(error)
           else

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -337,7 +337,7 @@ module Cassandra
           @request_queue_out.clear
         end
         promises_to_fail.each do |promise|
-          promise.fail(request_failure_cause)
+          promise.fail(request_failure_cause) unless promise.timed_out?
         end
         if cause
           @closed_promise.fail(cause)

data/lib/cassandra/protocol/type_converter.rb

@@ -188,7 +188,11 @@ module Cassandra
       def bytes_to_timestamp(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
         timestamp = buffer.read_long
-        Time.at(timestamp/1000.0)
+
+        seconds = timestamp / 1_000
+        microsenconds = (timestamp % 1_000) * 1_000
+
+        Time.at(seconds, microsenconds)
       end
 
       def bytes_to_varchar(buffer, size_bytes)
@@ -339,7 +343,7 @@ module Cassandra
 
       def timestamp_to_bytes(buffer, value, size_bytes)
         if value
-          ms = (value.to_f * 1000).to_i
+          ms = (value.to_r.to_f * 1000).to_i
           size_to_bytes(buffer, 8, size_bytes)
           buffer.append_long(ms)
         else
@@ -382,4 +386,4 @@ module Cassandra
       end
     end
   end
-end
+end

data/lib/cassandra/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Cassandra
-  VERSION = '1.1.1'.freeze
+  VERSION = '1.2.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra-driver
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Theo Hultberg
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-15 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione