cassandra-driver 0.1.0.alpha1 → 1.0.0.beta.1

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

@@ -0,0 +1,95 @@
+# 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
+
+        def host_up(host)
+          synchronize { @hosts = @hosts.dup.push(host) }
+
+          self
+        end
+
+        def host_down(host)
+          synchronize do
+            @hosts = @hosts.dup
+            @hosts.delete(host)
+          end
+
+          self
+        end
+
+        def host_found(host)
+          self
+        end
+
+        def host_lost(host)
+          self
+        end
+
+        def distance(host)
+          @hosts.include?(host) ? :local : :ignore
+        end
+
+        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/white_list.rb

@@ -0,0 +1,90 @@
+# 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 WhiteList < Policy
+        extend Forwardable
+
+        # @!method plan(keyspace, statement, options)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#plan
+        #
+        # @!method distance(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#distance
+        def_delegators :@policy, :plan, :distance
+
+        # @param ips [Enumerable<String, IPAddr>] a list of ips to whitelist
+        # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual policy to filter
+        # @raise [ArgumentError] if arguments are of unexpected types
+        def initialize(ips, wrapped_policy)
+          raise ::ArgumentError, "ips must be enumerable" unless ips.respond_to?(:each)
+          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
+
+          @ips    = ::Set.new
+          @policy = wrapped_policy
+
+          ips.each do |ip|
+            case ip
+            when ::IPAddr
+              @ips << ip
+            when ::String
+              @ips << ::IPAddr.new(ip)
+            else
+              raise ::ArgumentError, "ips must contain only instance of String or IPAddr, #{ip.inspect} given"
+            end
+          end
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_found
+        def host_found(host)
+          @policy.host_found(host) if @ips.include?(host.ip)
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_lost
+        def host_lost(host)
+          @policy.host_lost(host) if @ips.include?(host.ip)
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_up
+        def host_up(host)
+          @policy.host_up(host) if @ips.include?(host.ip)
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_down
+        def host_down(host)
+          @policy.host_down(host) if @ips.include?(host.ip)
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/protocol.rb

@@ -0,0 +1,93 @@
+# 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
+  # @private
+  ProtocolError = Class.new(Error)
+
+  # @private
+  module Protocol
+    DecodingError = Class.new(ProtocolError)
+    EncodingError = Class.new(ProtocolError)
+    InvalidStreamIdError = Class.new(ProtocolError)
+    InvalidValueError = Class.new(ProtocolError)
+    UnsupportedOperationError = Class.new(ProtocolError)
+    UnsupportedFrameTypeError = Class.new(ProtocolError)
+    UnsupportedResultKindError = Class.new(ProtocolError)
+    UnsupportedColumnTypeError = Class.new(ProtocolError)
+    UnsupportedEventTypeError = Class.new(ProtocolError)
+    UnsupportedFeatureError = Class.new(ProtocolError)
+    UnexpectedCompressionError = Class.new(ProtocolError)
+    UnmaterializedRowsError = Class.new(ProtocolError)
+
+    module Formats
+      CHAR_FORMAT = 'c'.freeze
+      DOUBLE_FORMAT = 'G'.freeze
+      FLOAT_FORMAT = 'g'.freeze
+      INT_FORMAT = 'N'.freeze
+      SHORT_FORMAT = 'n'.freeze
+
+      BYTES_FORMAT = 'C*'.freeze
+      TWO_INTS_FORMAT = 'NN'.freeze
+      HEADER_FORMAT = 'c4N'.freeze
+    end
+
+    module Constants
+      TRUE_BYTE = "\x01".freeze
+      FALSE_BYTE = "\x00".freeze
+      PROTOCOL_VERSION = "\x01".freeze
+      COMPRESSION_OFF = "\x00".freeze
+    end
+  end
+end
+
+require 'cassandra/protocol/cql_byte_buffer'
+require 'cassandra/protocol/type_converter'
+require 'cassandra/protocol/response'
+require 'cassandra/protocol/responses/auth_challenge_response'
+require 'cassandra/protocol/responses/auth_success_response'
+require 'cassandra/protocol/responses/error_response'
+require 'cassandra/protocol/responses/detailed_error_response'
+require 'cassandra/protocol/responses/ready_response'
+require 'cassandra/protocol/responses/authenticate_response'
+require 'cassandra/protocol/responses/supported_response'
+require 'cassandra/protocol/responses/result_response'
+require 'cassandra/protocol/responses/void_result_response'
+require 'cassandra/protocol/responses/rows_result_response'
+require 'cassandra/protocol/responses/raw_rows_result_response'
+require 'cassandra/protocol/responses/set_keyspace_result_response'
+require 'cassandra/protocol/responses/prepared_result_response'
+require 'cassandra/protocol/responses/schema_change_result_response'
+require 'cassandra/protocol/responses/event_response'
+require 'cassandra/protocol/responses/schema_change_event_response'
+require 'cassandra/protocol/responses/status_change_event_response'
+require 'cassandra/protocol/responses/topology_change_event_response'
+require 'cassandra/protocol/request'
+require 'cassandra/protocol/requests/auth_response_request'
+require 'cassandra/protocol/requests/batch_request'
+require 'cassandra/protocol/requests/startup_request'
+require 'cassandra/protocol/requests/credentials_request'
+require 'cassandra/protocol/requests/options_request'
+require 'cassandra/protocol/requests/register_request'
+require 'cassandra/protocol/requests/query_request'
+require 'cassandra/protocol/requests/void_query_request'
+require 'cassandra/protocol/requests/prepare_request'
+require 'cassandra/protocol/requests/execute_request'
+require 'cassandra/protocol/frame_encoder'
+require 'cassandra/protocol/frame_decoder'
+require 'cassandra/protocol/cql_protocol_handler'

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -0,0 +1,307 @@
+# 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 Protocol
+    class CqlByteBuffer < Ione::ByteBuffer
+      def read_unsigned_byte
+        read_byte
+      rescue RangeError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+      
+      def read_varint(len=bytesize, signed=true)
+        bytes = read(len)
+        n = 0
+        bytes.each_byte do |b|
+          n = (n << 8) | b
+        end
+        if signed && bytes.getbyte(0) & 0x80 == 0x80
+          n -= 2**(bytes.length * 8)
+        end
+        n
+      rescue RangeError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+
+      def read_decimal(len=bytesize)
+        size = read_signed_int
+        number_string = read_varint(len - 4).to_s
+        if number_string.length <= size
+          if number_string.start_with?(MINUS)
+            number_string = number_string[1, number_string.length - 1]
+            fraction_string = MINUS + ZERO << DECIMAL_POINT
+          else
+            fraction_string = ZERO + DECIMAL_POINT
+          end
+          (size - number_string.length).times { fraction_string << ZERO }
+          fraction_string << number_string
+        else
+          fraction_string = number_string[0, number_string.length - size]
+          fraction_string << DECIMAL_POINT
+          fraction_string << number_string[number_string.length - size, number_string.length]
+        end
+        BigDecimal.new(fraction_string)
+      rescue DecodingError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+
+      def read_long
+        top, bottom = read(8).unpack(Formats::TWO_INTS_FORMAT)
+        return (top << 32) | bottom if top <= 0x7fffffff
+        top ^= 0xffffffff
+        bottom ^= 0xffffffff
+        -((top << 32) | bottom) - 1
+      rescue RangeError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+
+      def read_double
+        read(8).unpack(Formats::DOUBLE_FORMAT).first
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a double: #{e.message}", e.backtrace
+      end
+
+      def read_float
+        read(4).unpack(Formats::FLOAT_FORMAT).first
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a float: #{e.message}", e.backtrace
+      end
+
+      def read_signed_int
+        n = read_int
+        return n if n <= 0x7fffffff
+        n - 0xffffffff - 1
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode an int: #{e.message}", e.backtrace
+      end
+      
+      def read_unsigned_short
+        read_short
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a short: #{e.message}", e.backtrace
+      end
+
+      def read_string
+        length = read_unsigned_short
+        string = read(length)
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a string: #{e.message}", e.backtrace
+      end
+
+      def read_long_string
+        length = read_signed_int
+        string = read(length)
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a long string: #{e.message}", e.backtrace
+      end
+
+      def read_uuid(impl=Uuid)
+        impl.new(read_varint(16, false))
+      rescue DecodingError => e
+        raise DecodingError, "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
+      end
+
+      def read_string_list
+        size = read_unsigned_short
+        Array.new(size) { read_string }
+      end
+
+      def read_bytes
+        size = read_signed_int
+        return nil if size & 0x80000000 == 0x80000000
+        read(size)
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a bytes: #{e.message}", e.backtrace
+      end
+
+      def read_short_bytes
+        size = read_unsigned_short
+        return nil if size & 0x8000 == 0x8000
+        read(size)
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a short bytes: #{e.message}", e.backtrace
+      end
+
+      def read_option
+        id = read_unsigned_short
+        value = nil
+        if block_given?
+          value = yield id, self
+        end
+        [id, value]
+      end
+
+      def read_inet
+        size = read_byte
+        ip_addr = IPAddr.new_ntoh(read(size))
+        port = read_int
+        [ip_addr, port]
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode an INET: #{e.message}", e.backtrace
+      end
+
+      def read_consistency
+        index = read_unsigned_short
+        raise DecodingError, "Unknown consistency index #{index}" if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
+        CONSISTENCIES[index]
+      end
+
+      def read_string_map
+        map = {}
+        map_size = read_unsigned_short
+        map_size.times do
+          key = read_string
+          map[key] = read_string
+        end
+        map
+      end
+
+      def read_string_multimap
+        map = {}
+        map_size = read_unsigned_short
+        map_size.times do
+          key = read_string
+          map[key] = read_string_list
+        end
+        map
+      end
+
+      def append_int(n)
+        append([n].pack(Formats::INT_FORMAT))
+      end
+
+      def append_short(n)
+        append([n].pack(Formats::SHORT_FORMAT))
+      end
+
+      def append_string(str)
+        str = str.to_s
+        append_short(str.bytesize)
+        append(str)
+      end
+
+      def append_long_string(str)
+        append_int(str.bytesize)
+        append(str)
+      end
+
+      def append_uuid(uuid)
+        v = uuid.value
+        append_int((v >> 96) & 0xffffffff)
+        append_int((v >> 64) & 0xffffffff)
+        append_int((v >> 32) & 0xffffffff)
+        append_int((v >>  0) & 0xffffffff)
+      end
+
+      def append_string_list(strs)
+        append_short(strs.size)
+        strs.each do |str|
+          append_string(str)
+        end
+        self
+      end
+
+      def append_bytes(bytes)
+        if bytes
+          append_int(bytes.bytesize)
+          append(bytes)
+        else
+          append_int(-1)
+        end
+      end
+
+      def append_short_bytes(bytes)
+        if bytes
+          append_short(bytes.bytesize)
+          append(bytes)
+        else
+          append_short(-1)
+        end
+      end
+
+      def append_consistency(consistency)
+        index = CONSISTENCIES.index(consistency)
+        raise EncodingError, %(Unknown consistency "#{consistency}") if index.nil? || CONSISTENCIES[index].nil?
+        append_short(index)
+      end
+
+      def append_string_map(map)
+        append_short(map.size)
+        map.each do |key, value|
+          append_string(key)
+          append_string(value)
+        end
+        self
+      end
+
+      def append_long(n)
+        top = n >> 32
+        bottom = n & 0xffffffff
+        append_int(top)
+        append_int(bottom)
+      end
+
+      def append_varint(n)
+        num = n
+        bytes = []
+        begin
+          bytes << (num & 0xff)
+          num >>= 8
+        end until (num == 0 || num == -1) && (bytes.last[7] == num[7])
+        append(bytes.reverse.pack(Formats::BYTES_FORMAT))
+      end
+
+      def append_decimal(n)
+        str = n.to_s(FLOAT_STRING_FORMAT)
+        size = str.index(DECIMAL_POINT)
+        number_string = str.gsub(DECIMAL_POINT, NO_CHAR)
+
+        num = number_string.to_i
+        raw = self.class.new.append_varint(num)
+        append_int(number_string.length - size)
+        append(raw)
+      end
+
+      def append_double(n)
+        append([n].pack(Formats::DOUBLE_FORMAT))
+      end
+
+      def append_float(n)
+        append([n].pack(Formats::FLOAT_FORMAT))
+      end
+
+      def eql?(other)
+        other.eql?(to_str)
+      end
+      alias_method :==, :eql?
+
+      private
+
+      MINUS = '-'.freeze
+      ZERO = '0'.freeze
+      DECIMAL_POINT = '.'.freeze
+      FLOAT_STRING_FORMAT = 'F'.freeze
+      NO_CHAR = ''.freeze
+    end
+  end
+end