cassandra-driver 1.0.0.beta.2-java

data/lib/cassandra/host.rb

@@ -0,0 +1,79 @@
+# 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 Host
+    # @return [IPAddr] host ip
+    attr_reader :ip
+    # @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 has connected.
+    # @return [String, nil] host datacenter
+    attr_reader :datacenter
+    # @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 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, tokens = EMPTY_LIST, status = :up)
+      @ip              = ip
+      @id              = id
+      @rack            = rack
+      @datacenter      = datacenter
+      @release_version = release_version
+      @tokens          = tokens
+      @status          = status
+    end
+
+    # @return [Boolean] whether this host's status is `:up`
+    def up?
+      @status == :up
+    end
+
+    # @return [Boolean] whether this host's status is `:down`
+    def down?
+      @status == :down
+    end
+
+    # @private
+    def hash
+      @hash ||= @ip.hash
+    end
+
+    # @param other [Cassandra::Host] a host to compare
+    # @return [Boolean] whether this host has the same ip as the other
+    def eql?(other)
+      other.eql?(@ip)
+    end
+    alias :== :eql?
+
+    # @return [String] a CLI-friendly host representation
+    def inspect
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @ip=#{@ip}>"
+    end
+  end
+end

data/lib/cassandra/keyspace.rb

@@ -0,0 +1,133 @@
+# 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
+  # Represents a cassandra keyspace
+  # @see Cassandra::Cluster#each_keyspace
+  # @see Cassandra::Cluster#keyspace
+  class Keyspace
+    # @private
+    class Replication
+      attr_reader :klass, :options
+
+      def initialize(klass, options)
+        @klass   = klass
+        @options = options
+      end
+
+      def to_cql
+        replication = {'class' => @klass}
+        replication.merge!(@options)
+
+        Util.encode_hash(replication)
+      end
+
+      def eql?(other)
+        other.is_a?(Replication) &&
+          @klass == other.klass &&
+          @options == other.options
+      end
+      alias :== :eql?
+    end
+
+    # @return [String] this keyspace name
+    attr_reader :name
+    # @private
+    attr_reader :replication
+
+    # @private
+    def initialize(name, durable_writes, replication, tables)
+      @name           = name
+      @durable_writes = durable_writes
+      @replication    = replication
+      @tables         = tables
+    end
+
+    # @return [Boolean] whether durables writes are enabled for this keyspace
+    def durable_writes?
+      @durable_writes
+    end
+
+    # @return [Boolean] whether this keyspace has a table with the given name
+    # @param name [String] table name
+    def has_table?(name)
+      @tables.has_key?(name)
+    end
+
+    # @return [Cassandra::Table, nil] a table or nil
+    # @param name [String] table name
+    def table(name)
+      @tables[name]
+    end
+
+    # Yield or enumerate each table defined in this keyspace
+    # @overload each_table
+    #   @yieldparam table [Cassandra::Table] current table
+    #   @return [Cassandra::Keyspace] self
+    # @overload each_table
+    #   @return [Array<Cassandra::Table>] a list of tables
+    def each_table(&block)
+      if block_given?
+        @tables.each_value(&block)
+        self
+      else
+        @tables.values
+      end
+    end
+    alias :tables :each_table
+
+    # @return [String] a cql representation of this table
+    def to_cql
+      "CREATE KEYSPACE #{Util.escape_name(@name)} WITH REPLICATION = #{@replication.to_cql} AND DURABLE_WRITES = #{@durable_writes};"
+    end
+
+    # @return [Boolean] whether this keyspace is equal to the other
+    def eql?(other)
+      other.is_a?(Keyspace) &&
+        @name == other.name &&
+        @durable_writes == other.durable_writes &&
+        @replication == other.replication &&
+        @tables == other.raw_tables
+    end
+    alias :== :eql?
+
+    # @private
+    def update_table(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
+    attr_reader :durable_writes
+    protected :durable_writes
+
+    protected
+
+    # @private
+    def raw_tables
+      @tables
+    end
+  end
+end

data/lib/cassandra/listener.rb

@@ -0,0 +1,87 @@
+# 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
+  # Cassandra state listener.
+  #
+  # @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
+    # This method is called whenever a host is considered to be up, whether
+    #   by Cassandra's gossip exchange or when the driver has successfully
+    #   established a connection to it.
+    #
+    # @param host [Cassandra::Host] a host instance
+    # @return [void]
+    def host_up(host)
+    end
+
+    # This method is called whenever a host is considered to be down, whether
+    #   by Cassandra's gossip exchange or when the driver failed to establish
+    #   any connections to it.
+    #
+    # @param host [Cassandra::Host] a host instance
+    # @return [void]
+    def host_down(host)
+    end
+
+    # This method is called whenever a host is discovered by the driver,
+    #   whether because it is a completely new node or if its
+    #   {Cassandra::Host#datacenter} or {Cassandra::Host#rack} have changed.
+    #
+    # @param host [Cassandra::Host] a host instance
+    # @return [void]
+    def host_found(host)
+    end
+
+    # This method is called whenever a host leaves the cluster, whether
+    #   because it is completely gone or if its {Cassandra::Host#datacenter} or
+    #   {Cassandra::Host#rack} have changed.
+    #
+    # @param host [Cassandra::Host] a host instance
+    # @return [void]
+    def host_lost(host)
+    end
+
+    # This method is called whenever a new keyspace is created.
+    #
+    # @param keyspace [Cassandra::Keyspace] a keyspace instance
+    # @return [void]
+    def keyspace_created(keyspace)
+    end
+
+    # This method is called whenever an existing keyspace is changed. This
+    # happens when a new table is created or an existing table is dropped or
+    # altered.
+    #
+    # @param keyspace [Cassandra::Keyspace] a keyspace instance
+    # @return [void]
+    def keyspace_changed(keyspace)
+    end
+
+    # This method is called whenever an existing keyspace is dropped.
+    #
+    # @param keyspace [Cassandra::Keyspace] a keyspace instance
+    # @return [void]
+    def keyspace_dropped(keyspace)
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# 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 DCAwareRoundRobin < Policy
+        # @private
+        class Plan
+          def initialize(local, remote, index)
+            @local  = local
+            @remote = remote
+            @index  = index
+
+            @local_remaining  = @local_total  = local.size
+            @remote_remaining = @remote_total = remote.size
+          end
+
+          def has_next?
+            @local_remaining > 0 || @remote_remaining > 0
+          end
+
+          def next
+            if @local_remaining > 0
+              @local_remaining -= 1
+              i = (@index % @local_total)
+              @index += 1
+
+              return @local[i]
+            end
+
+            if @remote_remaining > 0
+              @remote_remaining -= 1
+              i = (@index % @remote_total)
+              @index += 1
+
+              return @remote[i]
+            end
+          end
+        end
+
+        include MonitorMixin
+
+        def initialize(datacenter, max_remote_hosts_to_use = nil, use_remote_hosts_for_local_consistency = false)
+          datacenter              = String(datacenter)
+          max_remote_hosts_to_use = max_remote_hosts_to_use && Integer(max_remote_hosts_to_use)
+
+          raise ::ArgumentError, "datacenter cannot be nil" if datacenter.nil?
+          raise ::ArgumentError, "max_remote_hosts_to_use must be nil or >= 0" if max_remote_hosts_to_use && max_remote_hosts_to_use < 0
+
+          @datacenter = datacenter
+          @max_remote = max_remote_hosts_to_use
+          @local      = ::Array.new
+          @remote     = ::Array.new
+          @position   = 0
+
+          @use_remote = !!use_remote_hosts_for_local_consistency
+
+          mon_initialize
+        end
+
+        def host_up(host)
+          if host.datacenter.nil? || host.datacenter == @datacenter
+            synchronize { @local = @local.dup.push(host) }
+          else
+            if @max_remote.nil? || @remote.size < @max_remote
+              synchronize { @remote = @remote.dup.push(host) }
+            end
+          end
+
+          self
+        end
+
+        def host_down(host)
+          if host.datacenter.nil? || host.datacenter == @datacenter
+            synchronize do
+              @local = @local.dup
+              @local.delete(host)
+            end
+          else
+            synchronize do
+              @remote = @remote.dup
+              @remote.delete(host)
+            end
+          end
+
+          self
+        end
+
+        def host_found(host)
+          self
+        end
+
+        def host_lost(host)
+          self
+        end
+
+        def distance(host)
+          if host.datacenter.nil? || host.datacenter == @datacenter
+            @local.include?(host) ? :local : :ignore
+          else
+            @remote.include?(host) ? :remote : :ignore
+          end
+        end
+
+        def plan(keyspace, statement, options)
+          local = @local
+
+          if LOCAL_CONSISTENCIES.include?(options.consistency) && !@use_remote
+            remote = EMPTY_ARRAY
+          else
+            remote = @remote
+          end
+
+          position = @position
+          total    = local.size + remote.size
+
+          return EMPTY_PLAN if total == 0
+
+          @position = (@position + 1) % total
+
+          Plan.new(local, remote, position)
+        end
+
+        private
+
+        # @private
+        LOCAL_CONSISTENCIES = [:local_quorum, :local_one].freeze
+        # @private
+        EMPTY_ARRAY         = [].freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# 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 RoundRobin < Policy
+        # @private
+        class Plan
+          def initialize(hosts, index)
+            @hosts = hosts
+            @index = index
+
+            @total = @remaining = hosts.size
+          end
+
+          def has_next?
+            @remaining > 0
+          end
+
+          def next
+            return if @remaining == 0
+
+            @remaining -= 1
+            index, @index = @index, (@index + 1) % @total
+
+            @hosts[index]
+          end
+        end
+
+        include MonitorMixin
+
+        def initialize
+          @hosts    = ::Array.new
+          @position = 0
+
+          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
+            @hosts.delete(host)
+          end
+
+          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
+          total    = hosts.size
+          return EMPTY_PLAN if total == 0
+
+          @position = (position + 1) % total
+
+          Plan.new(hosts, position)
+        end
+      end
+    end
+  end
+end

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