cassandra-driver 1.0.0.beta.2-java

data/lib/cassandra/cluster/metadata.rb

@@ -0,0 +1,124 @@
+# 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
+    # @private
+    class Metadata
+      include MonitorMixin
+
+      attr_reader :name
+
+      def initialize(cluster_registry, cluster_schema, schema_partitioners, replication_strategies, default_replication_strategy)
+        @registry         = cluster_registry
+        @schema           = cluster_schema
+        @partitioners     = schema_partitioners
+        @strategies       = replication_strategies
+        @default_strategy = default_replication_strategy
+      end
+
+      def find_replicas(keyspace, statement)
+        unless statement.respond_to?(:partition_key) && statement.respond_to?(:keyspace)
+          return EMPTY_LIST
+        end
+
+        keyspace      = String(statement.keyspace || keyspace)
+        partition_key = statement.partition_key
+        return EMPTY_LIST unless keyspace && partition_key
+
+        partitioner = @partitioner
+        return EMPTY_LIST unless partitioner
+
+        keyspace_hosts = @token_replicas[keyspace]
+        return EMPTY_LIST if keyspace_hosts.nil? || keyspace_hosts.empty?
+
+        token = partitioner.create_token(partition_key)
+        index = insertion_point(@token_ring, token)
+        index = 0 if index >= @token_ring.size
+        hosts = keyspace_hosts[@token_ring[index]]
+        return EMPTY_LIST unless hosts
+
+        hosts
+      end
+
+      def update(data)
+        @name        = data['name']
+        @partitioner = @partitioners[data['partitioner']]
+
+        self
+      end
+
+      def rebuild_token_map
+        partitioner = @partitioner
+        return self unless partitioner
+
+        tokens        = ::SortedSet.new
+        token_to_host = ::Hash.new
+
+        @registry.each_host do |host|
+          host.tokens.each do |token|
+            token = partitioner.parse_token(token) rescue next
+            tokens.add(token)
+            token_to_host[token] = host
+          end
+        end
+
+        token_ring     = tokens.to_a
+        token_replicas = ::Hash.new
+
+        @schema.each_keyspace do |keyspace|
+          replication = keyspace.replication
+          strategy    = @strategies[replication.klass] || @default_strategy
+
+          token_replicas[keyspace.name] = strategy.replication_map(
+            token_to_host,
+            token_ring,
+            replication.options
+          )
+        end
+
+        @token_replicas = token_replicas
+        @token_ring     = token_ring
+
+        self
+      end
+
+      private
+
+      def insertion_point(list, item)
+        min = 0
+        max = list.size - 1
+
+        while min <= max do
+          idx = (min + max) / 2
+          val = list[idx]
+
+          if val < item
+            min = idx + 1
+          elsif val > item
+            max = idx - 1
+          else
+            return idx # item found
+          end
+        end
+
+        min # item not found.
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/options.rb

@@ -0,0 +1,42 @@
+# 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
+    # @private
+    class Options
+      attr_reader :credentials, :auth_provider, :compressor, :port,
+                  :connect_timeout, :ssl, :connections_per_local_node,
+                  :connections_per_remote_node
+      attr_accessor :protocol_version
+
+      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node)
+        @protocol_version   = protocol_version
+        @credentials        = credentials
+        @auth_provider      = auth_provider
+        @compressor         = compressor
+        @port               = port
+        @connect_timeout    = connect_timeout
+        @ssl                = ssl
+
+        @connections_per_local_node  = connections_per_local_node
+        @connections_per_remote_node = connections_per_remote_node
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/registry.rb

@@ -0,0 +1,198 @@
+# 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
+    # @private
+    class Registry
+      include MonitorMixin
+
+      LISTENER_METHODS = [:host_found, :host_lost, :host_up, :host_down].freeze
+
+      def initialize(logger)
+        @logger    = logger
+        @hosts     = ::Hash.new
+        @listeners = ::Set.new
+
+        mon_initialize
+      end
+
+      def add_listener(listener)
+        synchronize { @listeners = @listeners.dup.add(listener) }
+
+        self
+      end
+
+      def remove_listener(listener)
+        synchronize { @listeners = @listeners.dup.delete(listener) }
+
+        self
+      end
+
+      def each_host(&block)
+        if block_given?
+          @hosts.each_value(&block)
+          self
+        else
+          @hosts.values
+        end
+      end
+      alias :hosts :each_host
+
+      def host(address)
+        @hosts[address.to_s]
+      end
+
+      def has_host?(address)
+        @hosts.has_key?(address.to_s)
+      end
+
+      def host_found(address, data = {})
+        ip   = address.to_s
+        host = @hosts[ip]
+
+        if host
+          if host.id              == data['host_id']         &&
+             host.release_version == data['release_version'] &&
+             host.rack            == data['rack']            &&
+             host.datacenter      == data['data_center']
+
+            return self
+          else
+            notify_lost(host)
+
+            host = create_host(address, data)
+
+            notify_found(host)
+          end
+        else
+          host = create_host(address, data)
+
+          notify_found(host)
+        end
+
+        synchronize do
+          hosts     = @hosts.dup
+          hosts[ip] = host
+          @hosts    = hosts
+        end
+
+        self
+      end
+
+      def host_down(address)
+        ip   = address.to_s
+        host = @hosts[ip]
+
+        return self unless host && !host.down?
+
+        host = toggle_down(host)
+
+        synchronize do
+          hosts     = @hosts.dup
+          hosts[ip] = host
+          @hosts    = hosts
+        end
+
+        self
+      end
+
+      def host_up(address)
+        ip   = address.to_s
+        host = @hosts[ip]
+
+        return self unless host && !host.up?
+
+        host = toggle_up(host)
+
+        synchronize do
+          hosts     = @hosts.dup
+          hosts[ip] = host
+          @hosts    = hosts
+        end
+
+        self
+      end
+
+      def host_lost(address)
+        ip   = address.to_s
+        host = nil
+
+        return self unless @hosts.has_key?(ip)
+
+        synchronize do
+          hosts  = @hosts.dup
+          host   = hosts.delete(ip)
+          @hosts = hosts
+        end
+
+        notify_lost(host)
+
+        host
+      end
+
+      private
+
+      def create_host(ip, data)
+        Host.new(ip, data['host_id'], data['rack'], data['data_center'], data['release_version'], data['tokens'].freeze, :up)
+      end
+
+      def toggle_up(host)
+        host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :up)
+        @logger.debug("Host #{host.ip} is up")
+        @listeners.each do |listener|
+          listener.host_up(host) rescue nil
+        end
+        host
+      end
+
+      def toggle_down(host)
+        host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :down)
+        @logger.debug("Host #{host.ip} is down")
+        @listeners.each do |listener|
+          listener.host_down(host) rescue nil
+        end
+        host
+      end
+
+      def notify_lost(host)
+        if host.up?
+          @logger.debug("Host #{host.ip} is down and lost")
+          host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :down)
+          @listeners.each do |listener|
+            listener.host_down(host) rescue nil
+            listener.host_lost(host) rescue nil
+          end
+        else
+          @logger.debug("Host #{host.ip} is lost")
+          @listeners.each do |listener|
+            listener.host_lost(host) rescue nil
+          end
+        end
+      end
+
+      def notify_found(host)
+        @logger.debug("Host #{host.ip} is found and up")
+        @listeners.each do |listener|
+          listener.host_found(host) rescue nil
+          listener.host_up(host) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/partitioners/murmur3.rb

@@ -0,0 +1,47 @@
+# 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 Partitioners
+        # @private
+        class Murmur3
+          def create_token(partition_key)
+            token = Cassandra::Murmur3.hash(partition_key)
+            token = LONG_MAX if token == LONG_MIN
+
+            token
+          end
+
+          def parse_token(token_string)
+            token_string.to_i
+          end
+
+          private
+
+          # @private
+          LONG_MIN = -2 ** 63
+          # @private
+          LONG_MAX = 2 ** 63 - 1
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/partitioners/ordered.rb

@@ -0,0 +1,37 @@
+# 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 Partitioners
+        # @private
+        class Ordered
+          def create_token(partition_key)
+            partition_key
+          end
+
+          def parse_token(token_string)
+            token_string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/schema/partitioners/random.rb

@@ -0,0 +1,37 @@
+# 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 Partitioners
+        # @private
+        class Random
+          def create_token(partition_key)
+            Digest::MD5.hexdigest(partition_key).to_i(16)
+          end
+
+          def parse_token(token_string)
+            token_string.to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# 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.
+#++
+
+require 'cassandra/cluster/schema/partitioners/ordered'
+require 'cassandra/cluster/schema/partitioners/random'
+require 'cassandra/cluster/schema/partitioners/murmur3'

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

@@ -0,0 +1,92 @@
+# 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 NetworkTopology
+          def replication_map(token_hosts, token_ring, replication_options)
+            size  = token_ring.size
+            racks = ::Hash.new
+            token_hosts.each_value do |host|
+              racks[host.datacenter] ||= ::Set.new
+              racks[host.datacenter].add(host.rack)
+            end
+
+            replication_map = ::Hash.new
+
+            token_ring.each_with_index do |token, i|
+              all_replicas = ::Hash.new
+              visited = ::Hash.new
+              skipped_datacenter_hosts = ::Hash.new
+              replicas = ::Set.new
+
+              size.times do |j|
+                break if all_replicas.size == racks.size && !all_replicas.any? {|(datacenter, r)| r.size < Integer(replication_options[datacenter])}
+
+                host       = token_hosts[token_ring[(i + j) % size]]
+                datacenter = host.datacenter
+                next if datacenter.nil?
+
+                factor = replication_options[datacenter]
+                next unless factor
+
+                factor = Integer(factor) rescue next
+
+                replicas_in_datacenter = all_replicas[datacenter] ||= ::Set.new
+                next if replicas_in_datacenter.size >= factor
+
+                rack = host.rack
+                visited_racks = visited[datacenter] ||= ::Set.new
+
+                if rack.nil? || visited_racks.size == racks[datacenter].size
+                  replicas << host
+                  replicas_in_datacenter << host
+                else
+                  if visited_racks.include?(rack)
+                    skipped_hosts = skipped_datacenter_hosts[datacenter] ||= ::Set.new
+                    skipped_hosts << host
+                  else
+                    replicas << host
+                    replicas_in_datacenter << host
+                    visited_racks << rack
+
+                    if visited_racks.size == racks[datacenter].size && (skipped_hosts = skipped_datacenter_hosts[datacenter]) && replicas_in_datacenter.size < factor
+                      skipped_hosts.each do |skipped_host|
+                        replicas << skipped_host
+                        replicas_in_datacenter << skipped_host
+                        break if replicas_in_datacenter.size >= factor
+                      end
+                    end
+                  end
+                end
+              end
+
+              replication_map[token] = replicas.to_a.freeze
+            end
+
+            replication_map
+          end
+        end
+      end
+    end
+  end
+end

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