cassandra-driver 1.0.0 → 1.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTcyZDFmZGEzMGZhODU2MTRkYmRlMjhiNWIyYWI0OWVkODZmYmY3Mg==
+    ODg3NTI1OTYyMmViMzc5OWU4YjQyYTViYmQyMDFmZmNjOTIzMGExNg==
   data.tar.gz: !binary |-
-    MzQ5Y2M4YmI1YzQ3Yjk3MDU4YzI1YWJjYmZjYTc2YTE4NjA4ZTRmMQ==
+    NjI3OWQyZDc0NTM1MmE4M2VlMWVhM2EwMTRlMGVjYzdjODQyOGIzNw==
 SHA512:
   metadata.gz: !binary |-
-    NmFiNzc1M2E0NTk0YmIyY2VjNTcxZjI2ZDcwMGE5NmUzZDhhZGU5NmYyMTRj
-    M2NiZjgwNzdmMzJjOTA4YzBjNjVlYjRlNmJmZjE3MjZhOWY1ODRlOTQwM2Qy
-    YzYyNzc2MTFmYzNjOWNiZmI4NjY3Yjg4ZjBjYjJkMWRmMTY2Mzg=
+    ZGFhMWZjYWUyMTdlYzllODBmNGVjMTkzZjU5YWYyN2M3MjQwZmVhNTI3NzIz
+    ZGFiYTA3NzAyNWU0MWQ4Njg1OWFhNTViNTQ0NDFmMDU4NmQwMWQ3OTFkNjBj
+    NTdlM2ZjOTAwYTA5Njk4ZWQ2Nzk3ZjQ1OWM1MWU5YzcyODcwZmY=
   data.tar.gz: !binary |-
-    M2EzNzFhZDM5MTNkMTlhNzVhZTE1YzdmZGMyMWEyY2ZmZTc4N2YwMGIwMjll
-    ODhkNzFjODE3NmMxYTE5Y2U4MzA0ZjViMTQ3MzYyMjcwZDJkNjgyZjg1Y2Q2
-    NWY3MjRjM2QwY2VhMTU4MGIzOWM0YmY2MjI4ZmYyOTdhMDU0NDE=
+    YTQ0MDg5ZjI3Yzg5MGRiOGI1YTdlMjgwZGIxZjI1Y2ZkZDVhZWYwOGFkYTJi
+    MzIyOTY1OTY1ODgzMjhkYWY2ODYxYTIzZTRiYzI5OWRjODIwN2FmM2FlYTVk
+    YWFjOGNkMjY3OGJhYjhjZmE5ODMzMzgzMGNjNGU5ZmMyZTllYWI=

data/README.md

@@ -16,22 +16,29 @@ the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
 
 This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [Theo Hultberg](https://github.com/iconara) and we added support for:
 
-* [asynchronous execution](http://datastax.github.io/ruby-driver/features/asynchronous_io/)
-* one-off, [prepared](http://datastax.github.io/ruby-driver/features/basics/prepared_statements/) and [batch statements](http://datastax.github.io/ruby-driver/features/basics/batch_statements/)
-* automatic peer discovery and cluster metadata
-* various [load-balancing](http://datastax.github.io/ruby-driver/features/load_balancing/), [retry](http://datastax.github.io/ruby-driver/features/retry_policies/) and reconnection policies, [with ability to write your own](http://datastax.github.io/ruby-driver/features/load_balancing/implementing_a_policy/)
+* [Asynchronous execution](http://datastax.github.io/ruby-driver/features/asynchronous_io/)
+* One-off, [prepared](http://datastax.github.io/ruby-driver/features/basics/prepared_statements/) and [batch statements](http://datastax.github.io/ruby-driver/features/basics/batch_statements/)
+* Automatic peer discovery and cluster metadata with [support for change notifications](http://datastax.github.io/ruby-driver/features/state_listeners/)
+* Various [load-balancing](http://datastax.github.io/ruby-driver/features/load_balancing/), [retry](http://datastax.github.io/ruby-driver/features/retry_policies/) and [reconnection](http://datastax.github.io/ruby-driver/features/reconnection/) policies with [ability to write your own](http://datastax.github.io/ruby-driver/features/load_balancing/implementing_a_policy/)
 * [SSL encryption](http://datastax.github.io/ruby-driver/features/security/ssl_encryption/)
+* [Flexible and robust error handling](http://datastax.github.io/ruby-driver/features/error_handling/)
+* [Per-request execution information and tracing](http://datastax.github.io/ruby-driver/features/debugging/)
+* [Configurable address resolution](http://datastax.github.io/ruby-driver/features/address_resolution/)
+
+[Check out the slides from Ruby Driver Explained](https://speakerdeck.com/avalanche123/ruby-driver-explained) for a detailed overview of the Ruby Driver architecture.
 
 ## Compability
 
 This driver works exclusively with the Cassandra Query Language v3 (CQL3) and Cassandra's native protocol. The current version works with:
 
-* Apache Cassandra versions 1.2 and 2.0
+* Apache Cassandra versions 1.2, 2.0 and partially 2.1
 * DataStax Enterprise 3.1, 3.2, 4.0 and 4.5
 * Ruby (MRI) 1.9.3, 2.0 and 2.1
 * JRuby 1.7
 * Rubinius 2.2
 
+__Note__: Apache Cassandra 2.1 support is limited to the Cassandra 2.0 API, e.g. no user-defined types.
+
 __Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work.
 
 ## Quick start
@@ -57,7 +64,7 @@ end
 future.join
 ```
 
-The host you specify is just a seed node, the driver will automatically discover all peers in the cluster.
+__Note__: The host you specify is just a seed node, the driver will automatically discover all peers in the cluster.
 
 Read more:
 
@@ -70,34 +77,32 @@ Read more:
 Install via rubygems
 
 ```bash
-gem install cassandra-driver --pre
+gem install cassandra-driver
 ```
 
 Install via Gemfile
 
 ```ruby
-gem 'cassandra-driver', '~> 1.0.0.rc'
+gem 'cassandra-driver', '~> 1.0.0'
 ```
 
-Note: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://datastax.github.io/ruby-driver/features/#compression)
+__Note__: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://datastax.github.io/ruby-driver/features/#compression)
 
 
 ## Upgrading from cql-rb
 
 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.0.0
+## What's new in v1.1.0
 
 Current release introduces the following new features:
 
-* [Asynchronous execution](http://datastax.github.io/ruby-driver/features/asynchronous_io/)
-* One-off, [prepared](http://datastax.github.io/ruby-driver/features/basics/prepared_statements/) and [batch statements](http://datastax.github.io/ruby-driver/features/basics/batch_statements/)
-* Automatic peer discovery and cluster metadata with [support for change notifications](http://datastax.github.io/ruby-driver/features/state_listeners/)
-* Various [load-balancing](http://datastax.github.io/ruby-driver/features/load_balancing/), [retry](http://datastax.github.io/ruby-driver/features/retry_policies/) and reconnection policies, [with ability to write your own](http://datastax.github.io/ruby-driver/features/load_balancing/implementing_a_policy/)
-* [SSL encryption](http://datastax.github.io/ruby-driver/features/security/ssl_encryption/)
-* [Flexible and robust error handling](http://datastax.github.io/ruby-driver/features/error_handling/)
-* [Per-request execution information and tracing](http://datastax.github.io/ruby-driver/features/debugging/)
-* [Configurable address resolution](http://datastax.github.io/ruby-driver/features/address_resolution/)
+* 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
 
 ## Code examples
 

data/lib/cassandra.rb

@@ -25,7 +25,6 @@ require 'ipaddr'
 require 'set'
 require 'bigdecimal'
 require 'forwardable'
-require 'timeout'
 require 'digest'
 require 'stringio'
 require 'resolv'
@@ -51,7 +50,7 @@ module Cassandra
   # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L591-L603 Description of possible types of writes in Apache Cassandra native protocol spec v1
   WRITE_TYPES = [:simple, :batch, :unlogged_batch, :counter, :batch_log].freeze
 
-  # Creates a {Cassandra::Cluster} instance
+  # Creates a {Cassandra::Cluster Cluster instance}.
   #
   # @option options [Array<String, IPAddr>] :hosts (['127.0.0.1']) a list of
   #   initial addresses. Note that the entire list of cluster members will be
@@ -65,6 +64,10 @@ module Cassandra
   #   can skip this option if you specify only hosts from the local datacenter
   #   in `:hosts` option.
   #
+  # @option options [Boolean] :shuffle_replicas (true) whether replicas list
+  #   found by the default Token-Aware Load Balancing Policy should be
+  #   shuffled. See {Cassandra::LoadBalancing::Policies::TokenAware#initialize Token-Aware Load Balancing Policy}.
+  #
   # @option options [Numeric] :connect_timeout (10) connection timeout in
   #   seconds. Setting value to `nil` will reset it to 5 seconds.
   #
@@ -119,12 +122,33 @@ module Cassandra
   #   address resolver to use. Must be one of `:none` or
   #   `:ec2_multi_region`.
   #
+  # @option options [Boolean] :synchronize_schema (true) whether the driver
+  #   should automatically keep schema metadata synchronized. When enabled, the
+  #   driver updates schema metadata after receiving schema change
+  #   notifications from Cassandra. Setting this setting to `false` disables
+  #   automatic schema updates. Schema metadata is used by the driver to
+  #   determine cluster partitioners as well as to find partition keys and
+  #   replicas of prepared statements, this information makes token aware load
+  #   balancing possible. One can still {Cassandra::Cluster#refresh_schema refresh schema manually}.
+  #
+  # @option options [Numeric] :schema_refresh_delay (1) the driver will wait
+  #   for `:schema_refresh_delay` before fetching metadata after receiving a
+  #   schema change event. This timer is restarted every time a new schema
+  #   change event is received. Finally, when the timer expires or a maximum
+  #   wait time of `:schema_refresh_timeout` has been reached, a schema refresh
+  #   attempt will be made and the timeout is reset.
+  #
+  # @option options [Numeric] :schema_refresh_timeout (10) the maximum delay
+  #   before automatically refreshing schema. Such delay can occur whenever
+  #   multiple schema change events are continuously arriving within
+  #   `:schema_refresh_delay` interval.
+  #
   # @option options [Cassandra::Reconnection::Policy] :reconnection_policy
-  #   default: {Cassandra::Reconnection::Policies::Exponential}. Note that the
-  #   default policy is configured with `(0.5, 30, 2)`.
+  #   default: {Cassandra::Reconnection::Policies::Exponential Exponential}.
+  #   Note that the default policy is configured with `(0.5, 30, 2)`.
   #
   # @option options [Cassandra::Retry::Policy] :retry_policy default:
-  #   {Cassandra::Retry::Policies::Default}.
+  #   {Cassandra::Retry::Policies::Default Default Retry Policy}.
   #
   # @option options [Logger] :logger (none) logger. a {Logger} instance from the
   #   standard library or any object responding to standard log methods
@@ -145,7 +169,7 @@ module Cassandra
   #
   # @option options [Hash{String => String}] :credentials (none) a hash of credentials - to be used with [credentials authentication in cassandra 1.2](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L238-L250). Note that if you specified `:username` and `:password` options, those credentials are configured automatically.
   #
-  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v2.spec#L257-L273). Note that if you have specified `:username` and `:password`, then a {Cassandra::Auth::Providers::Password} will be used automatically.
+  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v2.spec#L257-L273). Note that if you have specified `:username` and `:password`, then a {Cassandra::Auth::Providers::Password Password Provider} will be used automatically.
   #
   # @option options [Cassandra::Compression::Compressor] :compressor (none) a
   #   custom compressor. Note that if you have specified `:compression`, an
@@ -153,7 +177,7 @@ module Cassandra
   #
   # @option options [Cassandra::AddressResolution::Policy]
   #   :address_resolution_policy default:
-  #   {Cassandra::AddressResolution::Policies::None} a custom address resolution
+  #   {Cassandra::AddressResolution::Policies::None No Resolution Policy} a custom address resolution
   #   policy. Note that if you have specified `:address_resolution`, an
   #   appropriate address resolution policy will be provided automatically.
   #
@@ -178,7 +202,7 @@ module Cassandra
     cluster_async(options).get
   end
 
-  # Creates a {Cassandra::Cluster} instance
+  # Creates a {Cassandra::Cluster Cluster instance}.
   #
   # @see Cassandra.cluster
   #
@@ -191,12 +215,12 @@ module Cassandra
         :consistency, :trace, :page_size, :compressor, :username, :password,
         :ssl, :server_cert, :client_cert, :private_key, :passphrase,
         :connect_timeout, :futures_factory, :datacenter, :address_resolution,
-        :address_resolution_policy, :idle_timeout, :heartbeat_interval, :timeout
+        :address_resolution_policy, :idle_timeout, :heartbeat_interval, :timeout,
+        :synchronize_schema, :schema_refresh_delay, :schema_refresh_timeout,
+        :shuffle_replicas
       ].include?(key)
     end
 
-    futures = options.fetch(:futures_factory, Future)
-
     has_username = options.has_key?(:username)
     has_password = options.has_key?(:password)
     if has_username || has_password
@@ -361,9 +385,23 @@ module Cassandra
       end
     end
 
+    if options.has_key?(:schema_refresh_delay)
+      timeout = options[:schema_refresh_delay]
+
+      Util.assert_instance_of(::Numeric, timeout) { ":schema_refresh_delay must be a number of seconds, #{timeout} given" }
+      Util.assert(timeout > 0) { ":schema_refresh_delay must be greater than 0, #{timeout} given" }
+    end
+
+    if options.has_key?(:schema_refresh_timeout)
+      timeout = options[:schema_refresh_timeout]
+
+      Util.assert_instance_of(::Numeric, timeout) { ":schema_refresh_timeout must be a number of seconds, #{timeout} given" }
+      Util.assert(timeout > 0) { ":schema_refresh_timeout must be greater than 0, #{timeout} given" }
+    end
+
     if options.has_key?(:load_balancing_policy)
       load_balancing_policy = options[:load_balancing_policy]
-      methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :distance, :plan]
+      methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown, :distance, :plan]
 
       Util.assert_responds_to_all(methods, load_balancing_policy) { ":load_balancing_policy #{load_balancing_policy.inspect} must respond to #{methods.inspect}, but doesn't" }
     end
@@ -382,9 +420,7 @@ module Cassandra
     end
 
     if options.has_key?(:listeners)
-      listeners = options[:listeners]
-
-      Util.assert_instance_of(::Enumerable, listeners) { ":listeners must be an Enumerable, #{listeners.inspect} given" }
+      options[:listeners] = Array(options[:listeners])
     end
 
     if options.has_key?(:consistency)
@@ -397,6 +433,10 @@ module Cassandra
       options[:trace] = !!options[:trace]
     end
 
+    if options.has_key?(:shuffle_replicas)
+      options[:shuffle_replicas] = !!options[:shuffle_replicas]
+    end
+
     if options.has_key?(:page_size)
       page_size = options[:page_size]
 
@@ -432,6 +472,10 @@ module Cassandra
       Util.assert_responds_to(:resolve, address_resolver) { ":address_resolution_policy must respond to :resolve, #{address_resolver.inspect} but doesn't" }
     end
 
+    if options.has_key?(:synchronize_schema)
+      options[:synchronize_schema] = !!options[:synchronize_schema]
+    end
+
     hosts = []
 
     Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
@@ -450,20 +494,14 @@ module Cassandra
     if hosts.empty?
       raise ::ArgumentError, ":hosts #{options[:hosts].inspect} could not be resolved to any ip address"
     end
+
+    hosts.shuffle!
   rescue => e
+    futures = options.fetch(:futures_factory) { Driver.new.futures_factory }
     futures.error(e)
   else
-    promise = futures.promise
-
-    Driver.new(options).connect(hosts).on_complete do |f|
-      if f.resolved?
-        promise.fulfill(f.value)
-      else
-        f.on_failure {|e| promise.break(e)}
-      end
-    end
-
-    promise.future
+    driver = Driver.new(options)
+    driver.connect(hosts)
   end
 end
 
@@ -475,6 +513,7 @@ require 'cassandra/protocol'
 require 'cassandra/auth'
 require 'cassandra/null_logger'
 
+require 'cassandra/executors'
 require 'cassandra/future'
 require 'cassandra/cluster'
 require 'cassandra/driver'

data/lib/cassandra/auth.rb

@@ -18,9 +18,9 @@
 
 module Cassandra
   module Auth
-    # An auth provider is a factory for {Cassandra::Auth::Authenticator} instances
-    # (or objects matching that interface). Its {#create_authenticator} will be
-    # called once for each connection that requires authentication.
+    # An auth provider is a factory for {Cassandra::Auth::Authenticator authenticator} instances (or objects matching that interface). Its
+    # {#create_authenticator} will be called once for each connection that
+    # requires authentication.
     #
     # If the authentication requires keeping state, keep that in the
     # authenticator instances, not in the auth provider.

data/lib/cassandra/cluster.rb

@@ -17,8 +17,7 @@
 #++
 
 module Cassandra
-  # Cluster represents a cassandra cluster. It serves as a {Cassandra::Session}
-  # factory and a collection of metadata.
+  # Cluster represents a cassandra cluster. It serves as a {Cassandra::Session session factory} factory and a collection of metadata.
   #
   # @see Cassandra::Cluster#connect Creating a new session
   # @see Cassandra::Cluster#each_host Getting all peers in the cluster
@@ -26,46 +25,11 @@ module Cassandra
   class Cluster
     extend Forwardable
 
-    # @!method host(address)
-    #   Find a host by its address
-    #   @param address [IPAddr, String] ip address
-    #   @return [Cassandra::Host, nil] host or nil
-    #
-    # @!method has_host?(address)
-    #   Determine if a host by a given address exists
-    #   @param address [IPAddr, String] ip address
-    #   @return [Boolean] true or false
-    def_delegators :@registry, :host, :has_host?
-
-    # @!method keyspace(name)
-    #   Find a keyspace by name
-    #   @param name [String] keyspace name
-    #   @return [Cassandra::Keyspace, nil] keyspace or nil
-    #
-    # @!method has_keyspace?(name)
-    #   Determine if a keyspace by a given name exists
-    #   @param name [String] keyspace name
-    #   @return [Boolean] true or false
-    def_delegators :@schema, :keyspace, :has_keyspace?
-
-    # @!method name
-    #   Return cluster's name
-    #   @return [String] cluster's name
-    #
-    # @!method find_replicas(keyspace, statement)
-    #   Return replicas for a given statement and keyspace
-    #   @note an empty list is returned when statement/keyspace information is
-    #     not enough to determine replica list.
-    #   @param keyspace [String] keyspace name
-    #   @param statement [Cassandra::Statement] statement for which to find
-    #     replicas
-    #   @return [Array<Cassandra::Host>] a list of replicas
-    def_delegators :@metadata, :name, :find_replicas
-
     # @private
-    def initialize(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, address_resolution_policy, connector, futures_factory)
+    def initialize(logger, io_reactor, executor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, address_resolution_policy, connector, futures_factory)
       @logger                = logger
       @io_reactor            = io_reactor
+      @executor              = executor
       @control_connection    = control_connection
       @registry              = cluster_registry
       @schema                = cluster_schema
@@ -78,8 +42,26 @@ module Cassandra
       @address_resolver      = address_resolution_policy
       @connector             = connector
       @futures               = futures_factory
+
+      @control_connection.on_close do |cause|
+        @load_balancing_policy.teardown(self) rescue nil
+      end
     end
 
+    # @!method name
+    #   Return cluster's name
+    #   @return [String] cluster's name
+    #
+    # @!method find_replicas(keyspace, statement)
+    #   Return replicas for a given statement and keyspace
+    #   @note an empty list is returned when statement/keyspace information is
+    #     not enough to determine replica list.
+    #   @param keyspace [String] keyspace name
+    #   @param statement [Cassandra::Statement] statement for which to find
+    #     replicas
+    #   @return [Array<Cassandra::Host>] a list of replicas
+    def_delegators :@metadata, :name, :find_replicas
+
     # Register a cluster state listener. State listener will start receiving
     # notifications about topology and schema changes
     #
@@ -115,6 +97,17 @@ module Cassandra
     end
     alias :hosts :each_host
 
+    # @!method host(address)
+    #   Find a host by its address
+    #   @param address [IPAddr, String] ip address
+    #   @return [Cassandra::Host, nil] host or nil
+    #
+    # @!method has_host?(address)
+    #   Determine if a host by a given address exists
+    #   @param address [IPAddr, String] ip address
+    #   @return [Boolean] true or false
+    def_delegators :@registry, :host, :has_host?
+
     # Yield or enumerate each keyspace defined in this cluster
     # @overload each_keyspace
     #   @yieldparam keyspace [Cassandra::Keyspace] current keyspace
@@ -128,6 +121,35 @@ module Cassandra
     end
     alias :keyspaces :each_keyspace
 
+    # @!method keyspace(name)
+    #   Find a keyspace by name
+    #   @param name [String] keyspace name
+    #   @return [Cassandra::Keyspace, nil] keyspace or nil
+    #
+    # @!method has_keyspace?(name)
+    #   Determine if a keyspace by a given name exists
+    #   @param name [String] keyspace name
+    #   @return [Boolean] true or false
+    def_delegators :@schema, :keyspace, :has_keyspace?
+
+    # @!method refresh_schema_async
+    #   Trigger an asynchronous schema metadata refresh
+    #   @return [Cassandra::Future<nil>] a future that will be fulfilled when
+    #     schema metadata has been refreshed
+    def_delegator :@control_connection, :refresh_schema_async_maybe_retry, \
+                                        :refresh_schema_async
+
+    # Synchronously refresh schema metadata
+    #
+    # @return [nil] nothing
+    # @raise [Cassandra::Errors::ClientError] when cluster is disconnected
+    # @raise [Cassandra::Error] other unexpected errors
+    #
+    # @see Cassandra::Cluster#refresh_schema_async
+    def refresh_schema
+      refresh_schema_async.get
+    end
+
     # Asynchronously create a new session, optionally scoped to a keyspace
     #
     # @param keyspace [String] optional keyspace to scope session to
@@ -191,11 +213,12 @@ module Cassandra
 
       @control_connection.close_async.on_complete do |f|
         if f.resolved?
-          @load_balancing_policy.teardown(self) rescue nil
           promise.fulfill(self)
         else
           f.on_failure {|e| promise.break(e)}
         end
+
+        @executor.shutdown
       end
 
       promise.future