cassandra-driver 1.0.0.beta.1 → 1.0.0.beta.2

data/lib/cassandra/cluster/schema/replication_strategies/none.rb

@@ -0,0 +1,39 @@
+# 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
+  class Cluster
+    class Schema
+      # @private
+      module ReplicationStrategies
+        # @private
+        class None
+          def replication_map(token_hosts, token_ring, replication_options)
+            replication_map = ::Hash.new
+
+            token_hosts.each do |token, host|
+              replication_map[token] = [host].freeze
+            end
+
+            replication_map
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/replication_strategies/simple.rb

@@ -0,0 +1,44 @@
+# 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
+  class Cluster
+    class Schema
+      # @private
+      module ReplicationStrategies
+        # @private
+        class Simple
+          def replication_map(token_hosts, token_ring, replication_options)
+            factor = Integer(replication_options['replication_factor'])
+            size   = token_ring.size
+            factor = size if size < factor
+            replication_map = ::Hash.new
+
+            token_ring.each_with_index do |token, i|
+              replication_map[token] = factor.times.map do |j|
+                token_hosts[token_ring[(i + j) % size]]
+              end.freeze
+            end
+
+            replication_map
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/type_parser.rb

@@ -45,7 +45,7 @@ module Cassandra
           "org.apache.cassandra.db.marshal.MapType"           => :map,
           "org.apache.cassandra.db.marshal.SetType"           => :set,
           "org.apache.cassandra.db.marshal.ListType"          => :list
-        }
+        }.freeze
 
         def parse(string)
           create_result(parse_node(string))

data/lib/cassandra/compression.rb

@@ -18,7 +18,7 @@
 
 module Cassandra
   module Compression
-    # @note Compressors given to {Cassandra.connect} as the `:compressor`
+    # @abstract Compressors given to {Cassandra.connect} as the `:compressor`
     #   option don't need to be subclasses of this class, but need to implement
     #   the same methods. This class exists only for documentation purposes.
     class Compressor

data/lib/cassandra/driver.rb

@@ -27,15 +27,38 @@ module Cassandra
     let(:io_reactor)       { Io::IoReactor.new }
     let(:cluster_registry) { Cluster::Registry.new(logger) }
     let(:cluster_schema)   { Cluster::Schema.new(schema_type_parser) }
+    let(:cluster_metadata) { Cluster::Metadata.new(
+                               cluster_registry,
+                               cluster_schema,
+                               {
+                                 'org.apache.cassandra.dht.Murmur3Partitioner'     => murmur3_partitioner,
+                                 'org.apache.cassandra.dht.ByteOrderedPartitioner' => ordered_partitioner,
+                                 'org.apache.cassandra.dht.RandomPartitioner'      => random_partitioner
+                               }.freeze,
+                               {
+                                 'org.apache.cassandra.locator.SimpleStrategy'          => simple_replication_strategy,
+                                 'org.apache.cassandra.locator.NetworkTopologyStrategy' => network_topology_replication_strategy
+                               }.freeze,
+                               no_replication_strategy
+                              )
+                           }
     let(:futures_factory)  { Future }
 
     let(:schema_type_parser) { Cluster::Schema::TypeParser.new }
 
+    let(:simple_replication_strategy)           { Cluster::Schema::ReplicationStrategies::Simple.new }
+    let(:network_topology_replication_strategy) { Cluster::Schema::ReplicationStrategies::NetworkTopology.new }
+    let(:no_replication_strategy)               { Cluster::Schema::ReplicationStrategies::None.new }
+
+    let(:murmur3_partitioner) { Cluster::Schema::Partitioners::Murmur3.new }
+    let(:ordered_partitioner) { Cluster::Schema::Partitioners::Ordered.new }
+    let(:random_partitioner)  { Cluster::Schema::Partitioners::Random.new }
+
     let(:connector) { Cluster::Connector.new(logger, io_reactor, cluster_registry, connection_options) }
 
-    let(:control_connection) { Cluster::ControlConnection.new(logger, io_reactor, cluster_registry, cluster_schema, load_balancing_policy, reconnection_policy, connector) }
+    let(:control_connection) { Cluster::ControlConnection.new(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, connector) }
 
-    let(:cluster) { Cluster.new(logger, io_reactor, control_connection, cluster_registry, cluster_schema, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory) }
+    let(:cluster) { Cluster.new(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory) }
 
     let(:execution_options) do
       Execution::Options.new({
@@ -45,11 +68,12 @@ module Cassandra
       })
     end
 
-    let(:connection_options) { Cluster::Options.new(protocol_version, credentials, auth_provider, compressor, port, connection_timeout, connections_per_local_node, connections_per_remote_node) }
+    let(:connection_options) { Cluster::Options.new(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node) }
 
     let(:port)                  { 9042 }
     let(:protocol_version)      { 2 }
-    let(:connection_timeout)    { 10 }
+    let(:connect_timeout)       { 10 }
+    let(:ssl)                   { false }
     let(:logger)                { Client::NullLogger.new  }
     let(:compressor)            { nil }
     let(:credentials)           { nil }
@@ -72,6 +96,7 @@ module Cassandra
     end
 
     def connect(addresses)
+      load_balancing_policy.setup(cluster)
       cluster_registry.add_listener(load_balancing_policy)
       cluster_registry.add_listener(control_connection)
       listeners.each do |listener|

data/lib/cassandra/execution/options.rb

@@ -45,6 +45,9 @@ module Cassandra
         page_size = page_size && Integer(page_size)
         timeout   = timeout   && Integer(timeout)
 
+        raise ::ArgumentError, ":page_size must be greater than 0, #{page_size.inspect} given" if page_size && page_size <= 0
+        raise ::ArgumentError, ":timeout must be greater than 0, #{timeout.inspect} given" if timeout && timeout <= 0
+
         @consistency        = consistency
         @page_size          = page_size
         @trace              = !!trace

data/lib/cassandra/host.rb

@@ -20,28 +20,32 @@ module Cassandra
   class Host
     # @return [IPAddr] host ip
     attr_reader :ip
-    # @note Host id can be `nil` before cluster connected.
+    # @note Host id can be `nil` before cluster has connected.
     # @return [Cassandra::Uuid, nil] host id.
     attr_reader :id
-    # @note Host datacenter can be `nil` before cluster connected.
+    # @note Host datacenter can be `nil` before cluster has connected.
     # @return [String, nil] host datacenter
     attr_reader :datacenter
-    # @note Host rack can be `nil` before cluster connected.
+    # @note Host rack can be `nil` before cluster has connected.
     # @return [String, nil] host rack
     attr_reader :rack
-    # @note Host's cassandra version can be `nil` before cluster connected.
+    # @note Host's cassandra version can be `nil` before cluster has connected.
     # @return [String, nil] version of cassandra that a host is running
     attr_reader :release_version
+    # @note Host tokens will be empty before cluster has connected.
+    # @return [Array<String>] a list of tokens owned by this host
+    attr_reader :tokens
     # @return [Symbol] host status. Must be `:up` or `:down`
     attr_reader :status
 
     # @private
-    def initialize(ip, id = nil, rack = nil, datacenter = nil, release_version = nil, status = :up)
+    def initialize(ip, id = nil, rack = nil, datacenter = nil, release_version = nil, tokens = EMPTY_LIST, status = :up)
       @ip              = ip
       @id              = id
       @rack            = rack
       @datacenter      = datacenter
       @release_version = release_version
+      @tokens          = tokens
       @status          = status
     end
 

data/lib/cassandra/keyspace.rb

@@ -78,11 +78,16 @@ module Cassandra
     # Yield or enumerate each table defined in this keyspace
     # @overload each_table
     #   @yieldparam table [Cassandra::Table] current table
-    #   @return [Array<Cassandra::Table>] a list of tables
+    #   @return [Cassandra::Keyspace] self
     # @overload each_table
-    #   @return [Enumerator<Cassandra::Table>] an enumerator
+    #   @return [Array<Cassandra::Table>] a list of tables
     def each_table(&block)
-      @tables.values.each(&block)
+      if block_given?
+        @tables.each_value(&block)
+        self
+      else
+        @tables.values
+      end
     end
     alias :tables :each_table
 
@@ -103,7 +108,15 @@ module Cassandra
 
     # @private
     def update_table(table)
-      Keyspace.new(@name, @durable_writes, @replication, @tables.merge(table.name => table))
+      tables = @tables.dup
+      tables[table.name] = table
+      Keyspace.new(@name, @durable_writes, @replication, tables)
+    end
+
+    # @private
+    def create_partition_key(table, values)
+      table = @tables[table]
+      table && table.create_partition_key(values)
     end
 
     # @private

data/lib/cassandra/listener.rb

@@ -19,9 +19,9 @@
 module Cassandra
   # Cassandra state listener.
   #
-  # @note Actual state listener implementations don't need to inherit from this
-  #   class as long as they conform to its interface. This class exists solely
-  #   for documentation purposes
+  # @abstract Actual state listener implementations don't need to inherit from
+  #   this class as long as they conform to its interface. This class exists
+  #   solely for documentation purposes
   #
   # @see Cassandra::Cluster#register
   class Listener

data/lib/cassandra/load_balancing.rb

@@ -22,34 +22,36 @@ module Cassandra
     # {Cassandra::LoadBalancing::Policy#distance} must return
     DISTANCES = [:ignore, :local, :remote].freeze
 
-    # @note Actual load balancing policies don't need to extend this class,
+    # @abstract Actual load balancing policies don't need to extend this class,
     #   only implement its methods. This class exists for documentation
-    #   purposes only
+    #   purposes only.
     class Policy
-      # @abstract implementation should be provided by an actual policy
+      # Allows policy to initialize with the cluster instance. This method is
+      # called once before connecting to the cluster.
+      # @param cluster [Cassandra::Cluster] current cluster instance
+      # @return [void]
+      def setup(cluster)
+      end
+
       # @see Cassandra::Listener#host_up
       def host_up(host)
       end
 
-      # @abstract implementation should be provided by an actual policy
       # @see Cassandra::Listener#host_down
       def host_down(host)
       end
 
-      # @abstract implementation should be provided by an actual policy
       # @see Cassandra::Listener#host_found
       def host_found(host)
       end
 
-      # @abstract implementation should be provided by an actual policy
       # @see Cassandra::Listener#host_lost
       def host_lost(host)
       end
 
-      # Returns a distance that lets the driver to determine host many
-      #   connections (if any) to open to the host
+      # Returns a distance that determines how many connections (if any) the
+      # driver will open to the host.
       #
-      # @abstract implementation should be provided by an actual policy
       # @param host [Cassandra::Host] a host instance
       # @return [Symbol] distance to host. Must be one of
       #   {Cassandra::LoadBalancing::DISTANCES}
@@ -62,7 +64,6 @@ module Cassandra
       #
       # @note Hosts that should be ignored, must not be included in the Plan
       #
-      # @abstract implementation should be provided by an actual policy
       # @param keyspace [String] current keyspace of the {Cassandra::Session}
       # @param statement [Cassandra::Statement] actual statement to be executed
       # @param options [Cassandra::Execution::Options] execution options to be used
@@ -80,7 +81,7 @@ module Cassandra
 
     # A load balancing plan is used to determine the order of hosts for running
     # queries, preparing statements and establishing connections.
-    # @note Plans returned by {Cassandra::LoadBalancing::Policy}
+    # @abstract Plans returned by {Cassandra::LoadBalancing::Policy#plan}
     #   implementations don't need to extend this class, only implement its
     #   methods. This class exists for documentation purposes only.
     class Plan

data/lib/cassandra/load_balancing/policies.rb

@@ -13,6 +13,7 @@
 # limitations under the License.
 #++
 
-require 'cassandra/load_balancing/policies/round_robin'
 require 'cassandra/load_balancing/policies/dc_aware_round_robin'
+require 'cassandra/load_balancing/policies/round_robin'
+require 'cassandra/load_balancing/policies/token_aware'
 require 'cassandra/load_balancing/policies/white_list'

data/lib/cassandra/load_balancing/policies/dc_aware_round_robin.rb

@@ -124,7 +124,7 @@ module Cassandra
           if LOCAL_CONSISTENCIES.include?(options.consistency) && !@use_remote
             remote = EMPTY_ARRAY
           else
-            remote   = @remote
+            remote = @remote
           end
 
           position = @position

data/lib/cassandra/load_balancing/policies/round_robin.rb

@@ -52,12 +52,22 @@ module Cassandra
           mon_initialize
         end
 
+        # Adds this host to rotation
+        #
+        # @param host [Cassandra::Host] a host instance
+        # @return [Cassandra::LoadBalancing::Policies::RoundRobin] self
+        # @see Cassandra::Listener#host_up
         def host_up(host)
           synchronize { @hosts = @hosts.dup.push(host) }
 
           self
         end
 
+        # Removes this host from rotation
+        #
+        # @param host [Cassandra::Host] a host instance
+        # @return [Cassandra::LoadBalancing::Policies::RoundRobin] self
+        # @see Cassandra::Listener#host_down
         def host_down(host)
           synchronize do
             @hosts = @hosts.dup
@@ -67,18 +77,45 @@ module Cassandra
           self
         end
 
+        # Noop
+        #
+        # @param host [Cassandra::Host] a host instance
+        # @return [Cassandra::LoadBalancing::Policies::RoundRobin] self
+        # @see Cassandra::Listener#host_found
         def host_found(host)
           self
         end
 
+        # Noop
+        #
+        # @param host [Cassandra::Host] a host instance
+        # @return [Cassandra::LoadBalancing::Policies::RoundRobin] self
+        # @see Cassandra::Listener#host_lost
         def host_lost(host)
           self
         end
 
+        # Returns distance to host. All hosts in rotation are considered
+        # `:local`, all other hosts - `:ignore`.
+        #
+        # @param host [Cassandra::Host] a host instance
+        # @return [Symbol] `:local` for all hosts in rotation and `:ignore` for
+        #   all other hosts.
+        # @see Cassandra::LoadBalancing::Policy#distance
         def distance(host)
           @hosts.include?(host) ? :local : :ignore
         end
 
+        # Returns a load balancing plan that rotates hosts by 1 each time a
+        # plan is requested.
+        #
+        # @param keyspace [String] current keyspace of the {Cassandra::Session}
+        # @param statement [Cassandra::Statement] actual statement to be
+        #   executed
+        # @param options [Cassandra::Execution::Options] execution options to
+        #   be used
+        # @return [Cassandra::LoadBalancing::Plan] a rotated load balancing plan
+        # @see Cassandra::LoadBalancing::Policy#plan
         def plan(keyspace, statement, options)
           hosts    = @hosts
           position = @position

data/lib/cassandra/load_balancing/policies/token_aware.rb

@@ -0,0 +1,119 @@
+# 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 LoadBalancing
+    module Policies
+      class TokenAware < Policy
+        # @private
+        class Plan
+          def initialize(hosts, policy, keyspace, statement, options)
+            @hosts     = hosts
+            @policy    = policy
+            @keyspace  = keyspace
+            @statement = statement
+            @options   = options
+            @seen      = ::Hash.new
+          end
+
+          def has_next?
+            until @hosts.empty?
+              host = @hosts.shift
+
+              if @policy.distance(host) == :local
+                @seen[host] = true
+                @next = host
+                break
+              end
+            end
+
+            return true if @next
+
+            @plan ||= @policy.plan(@keyspace, @statement, @options)
+
+            while @plan.has_next?
+              host = @plan.next
+
+              unless @seen[host]
+                @next = host
+                return true
+              end
+            end
+
+            false
+          end
+
+          def next
+            host  = @next
+            @next = nil
+            host
+          end
+        end
+
+        extend Forwardable
+
+        # @!method distance(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#distance
+        #
+        # @!method host_found(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_found
+        #
+        # @!method host_up(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_up
+        #
+        # @!method host_down(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_down
+        #
+        # @!method host_lost(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_lost
+        def_delegators :@policy, :distance, :host_found, :host_up, :host_down, :host_lost
+
+        # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual policy to filter
+        def initialize(wrapped_policy)
+          methods = [:host_up, :host_down, :host_found, :host_lost, :distance, :plan]
+
+          unless methods.all? {|method| wrapped_policy.respond_to?(method)}
+            raise ::ArgumentError, "supplied policy must be a Cassandra::LoadBalancing::Policy, #{wrapped_policy.inspect} given"
+          end
+
+          @policy = wrapped_policy
+        end
+
+        def setup(cluster)
+          @cluster = cluster
+          @policy.setup(cluster)
+          nil
+        end
+
+        def plan(keyspace, statement, options)
+          return @policy.plan(keyspace, statement, options) unless @cluster
+
+          replicas = @cluster.find_replicas(keyspace, statement)
+          return @policy.plan(keyspace, statement, options) if replicas.empty?
+
+          Plan.new(replicas.dup, @policy, keyspace, statement, options)
+        end
+      end
+    end
+  end
+end