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

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

@@ -0,0 +1,138 @@
+# 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
+      class TypeParser
+        # @private
+        Node   = Struct.new(:parent, :name, :children)
+        # @private
+        Result = Struct.new(:results, :collections)
+
+        @@types = {
+          "org.apache.cassandra.db.marshal.AsciiType"         => :ascii,
+          "org.apache.cassandra.db.marshal.LongType"          => :bigint,
+          "org.apache.cassandra.db.marshal.BytesType"         => :blob,
+          "org.apache.cassandra.db.marshal.BooleanType"       => :boolean,
+          "org.apache.cassandra.db.marshal.CounterColumnType" => :counter,
+          "org.apache.cassandra.db.marshal.DecimalType"       => :decimal,
+          "org.apache.cassandra.db.marshal.DoubleType"        => :double,
+          "org.apache.cassandra.db.marshal.FloatType"         => :float,
+          "org.apache.cassandra.db.marshal.InetAddressType"   => :inet,
+          "org.apache.cassandra.db.marshal.Int32Type"         => :int,
+          "org.apache.cassandra.db.marshal.UTF8Type"          => :text,
+          "org.apache.cassandra.db.marshal.TimestampType"     => :timestamp,
+          "org.apache.cassandra.db.marshal.DateType"          => :timestamp,
+          "org.apache.cassandra.db.marshal.UUIDType"          => :uuid,
+          "org.apache.cassandra.db.marshal.IntegerType"       => :varint,
+          "org.apache.cassandra.db.marshal.TimeUUIDType"      => :timeuuid,
+          "org.apache.cassandra.db.marshal.MapType"           => :map,
+          "org.apache.cassandra.db.marshal.SetType"           => :set,
+          "org.apache.cassandra.db.marshal.ListType"          => :list
+        }
+
+        def parse(string)
+          create_result(parse_node(string))
+        end
+
+        private
+
+        def create_result(node)
+          collections = nil
+          results     = []
+
+          if node.name == "org.apache.cassandra.db.marshal.CompositeType"
+            collections = {}
+
+            if node.children.last.name == "org.apache.cassandra.db.marshal.ColumnToCollectionType"
+              node.children.pop.children.each do |child|
+                key, name  = child.name.split(":")
+                key        = [key].pack('H*').force_encoding(::Encoding::UTF_8)
+
+                if name == "org.apache.cassandra.db.marshal.ReversedType"
+                  collections[key] = lookup_type(child.children.first)
+                else
+                  child.name = name
+                  collections[key] = lookup_type(child)
+                end
+              end
+            end
+
+            node.children.each do |child|
+              results << create_type(child)
+            end
+          else
+            results << create_type(node)
+          end
+
+          Result.new(results, collections)
+        end
+
+        def create_type(node)
+          order = :asc
+
+          if node.name == "org.apache.cassandra.db.marshal.ReversedType"
+            order = :desc
+            node  = node.children.first
+          end
+
+          [lookup_type(node), order]
+        end
+
+        def lookup_type(node)
+          type = @@types[node.name]
+
+          case type
+          when :set, :list
+            [type, lookup_type(node.children.first)]
+          when :map
+            [type, *node.children.map {|child| lookup_type(child)}]
+          else
+            type
+          end
+        end
+
+        def parse_node(string)
+          root = node = Node.new(nil, '', [])
+
+          string.each_char do |char|
+            case char
+            when '(' # starting type params
+              child = Node.new(node, '', [])
+              node.children << child
+              node = child
+            when ','
+              child = Node.new(node.parent, '', [])
+              node.parent.children << child
+              node = child
+            when ')'
+              node = node.parent
+            when ' '
+              next
+            else
+              node.name << char
+            end
+          end
+
+          root
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/column.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
+  # Represents a cassandra column
+  # @see Cassandra::Table#each_column
+  # @see Cassandra::Table#column
+  class Column
+    # @private
+    class Index
+      # @return [String] index name
+      attr_reader :name
+      # @return [String] custom index class name
+      attr_reader :custom_class_name
+
+      # @private
+      def initialize(name, custom_class_name = nil)
+        @name              = name
+        @custom_class_name = custom_class_name
+      end
+    end
+
+    # @return [String] column name
+    attr_reader :name
+    # @private
+    # @return [Symbol, Array(Symbol, Symbol)] column type
+    attr_reader :type
+    # @return [Symbol] column order (`:asc` or `:desc`)
+    attr_reader :order
+    # @private
+    # @return [Cassandra::Column::Index, nil] column index
+    attr_reader :index
+    # @private
+    # @return [Boolean] whether the column is static
+    attr_reader :static
+
+    # @private
+    def initialize(name, type, order, index = nil, is_static = false)
+      @name     = name
+      @type     = type
+      @order    = order
+      @index    = index
+      @static   = is_static
+    end
+
+    # @return [Boolean] whether the column is static
+    def static?
+      @static
+    end
+
+    # @return [String] a cql representation of this column
+    def to_cql
+      type = case @type
+      when Array
+        type, *args = @type
+        "#{type.to_s}<#{args.map(&:to_s).join(', ')}>"
+      else
+        @type.to_s
+      end
+
+      cql = "#{@name} #{type}"
+      cql << ' static' if @static
+      cql
+    end
+
+    # @return [Boolean] whether this column is equal to the other
+    def eql?(other)
+      other.is_a?(Column) &&
+        @name == other.name &&
+        @type == other.type &&
+        @order == other.order &&
+        @index == other.index &&
+        @static == other.static?
+    end
+    alias :== :eql?
+  end
+end

data/lib/cassandra/compression.rb

@@ -0,0 +1,66 @@
+# 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 Compression
+    # @note 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
+      # @!method algorithm
+      #
+      # Returns the name of the algorithm this compressor supports,
+      # e.g. "snappy" or "lz4".
+      #
+      # @return [String] algorithm
+
+      # @!method compress?(frame)
+      #
+      # Before compressing a frame the compressor will be asked if it wants
+      # to compress it or not. One reason it could say no is if the frame is
+      # small enough that compression would be unlikely to decrease its size.
+      #
+      # If your operations consist mostly of small prepared statement
+      # executions it might not be useful to compress the frames being sent
+      # _to_ Cassandra, but enabling compression can still be useful on the
+      # frames coming _from_ Cassandra. Making this method always return
+      # false disables request compression, but will still make the client
+      # tell Cassandra that it supports compressed frames.
+      #
+      # The bytes given to {#compress?} are the same as to {#compress}
+      #
+      # @param frame [String] the bytes of the frame to be compressed
+      # @return [true, false] whether to perform compression or not
+
+      # @!method compress(frame)
+      #
+      # Compresses the raw bytes of a frame.
+      #
+      # @param frame [String] the bytes of the frame to be compressed
+      # @return [String] the compressed frame
+
+      # @!method decompress(compressed_frame)
+      #
+      # Decompresses the raw bytes of a compressed frame.
+      #
+      # @param compressed_frame [String] the bytes of the compressed frame to
+      #   be uncompressed
+      # @return [String] uncompressed bytes
+    end
+  end
+end

data/lib/cassandra/compression/compressors/lz4.rb

@@ -0,0 +1,72 @@
+# 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.
+#++
+
+begin
+  require 'lz4-ruby'
+rescue LoadError => e
+  raise LoadError, %[LZ4 support requires the "lz4-ruby" gem: #{e.message}], e.backtrace
+end
+
+module Cassandra
+  module Compression
+    module Compressors
+      # A compressor that uses the LZ4 compression library.
+      #
+      # @note This compressor requires the
+      #   [lz4-ruby](http://rubygems.org/gems/lz4-ruby) gem (v0.3.2 or later
+      #   required).
+      # @note No need to instantiate this class manually, use `compression:
+      #   :lz4` option when calling {Cassandra.connect} and one will be created
+      #   automatically for you.
+      class Lz4 < Compressor
+        # @return [String] `'lz4'`
+        attr_reader :algorithm
+
+        # @param [Integer] min_size (64) Don't compress frames smaller than
+        #   this size (see {#compress?}).
+        def initialize(min_size=64)
+          @algorithm = 'lz4'.freeze
+          @min_size = min_size
+        end
+
+        # @return [true, false] will return false for frames smaller than the
+        #   `min_size` given to the constructor.
+        # @see Cassandra::Compression::Compressor#compress?
+        def compress?(str)
+          str.bytesize > @min_size
+        end
+
+        # @see Cassandra::Compression::Compressor#compress
+        def compress(str)
+          [str.bytesize, ::LZ4::Raw.compress(str.to_s).first].pack(BUFFER_FORMAT)
+        end
+
+        # @see Cassandra::Compression::Compressor#decompress
+        def decompress(str)
+          decompressed_size, compressed_data = str.to_s.unpack(BUFFER_FORMAT)
+          ::LZ4::Raw.decompress(compressed_data, decompressed_size).first
+        end
+
+        private
+
+        # @private
+        BUFFER_FORMAT = 'Na*'.freeze
+      end
+    end
+  end
+end

data/lib/cassandra/compression/compressors/snappy.rb

@@ -0,0 +1,66 @@
+# 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.
+#++
+
+begin
+  require 'snappy'
+rescue LoadError => e
+  raise LoadError, %[Snappy support requires the "snappy" gem: #{e.message}], e.backtrace
+end
+
+module Cassandra
+  module Compression
+    module Compressors
+      # A compressor that uses the Snappy compression library.
+      #
+      # @note This compressor requires the
+      #   [snappy](http://rubygems.org/gems/snappy) gem (v0.0.10 or later for
+      #   JRuby support).
+      # @note No need to instantiate this class manually, use `compression:
+      #   :snappy` option when calling {Cassandra.connect} and one will be
+      #   created automatically for you.
+      class Snappy < Compressor
+        # @return [String] `'snappy'`
+        attr_reader :algorithm
+
+        # @param [Integer] min_size (64) Don't compress frames smaller than
+        #   this size (see {#compress?}).
+        def initialize(min_size=64)
+          @algorithm = 'snappy'.freeze
+          @min_size = min_size
+        end
+
+        # @return [true, false] will return false for frames smaller than the
+        #   `min_size` given to the constructor.
+        # @see Cassandra::Compression::Compressor#compress?
+        def compress?(str)
+          str.bytesize > @min_size
+        end
+
+        # @see Cassandra::Compression::Compressor#compress
+        def compress(str)
+          ::Snappy.deflate(str)
+        end
+
+        # @see Cassandra::Compression::Compressor#decompress
+        def decompress(str)
+          ::Snappy.inflate(str)
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/driver.rb

@@ -0,0 +1,86 @@
+# 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
+  class Driver
+    def self.let(name, &block)
+      define_method(name)        { @instances[name] ||= @defaults.fetch(name) { instance_eval(&block) } }
+      define_method(:"#{name}=") { |object| @instances[name] = object }
+    end
+
+    let(:io_reactor)       { Io::IoReactor.new }
+    let(:cluster_registry) { Cluster::Registry.new(logger) }
+    let(:cluster_schema)   { Cluster::Schema.new(schema_type_parser) }
+    let(:futures_factory)  { Future }
+
+    let(:schema_type_parser) { Cluster::Schema::TypeParser.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(: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(:execution_options) do
+      Execution::Options.new({
+        :consistency => consistency,
+        :trace       => trace,
+        :page_size   => page_size
+      })
+    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(:port)                  { 9042 }
+    let(:protocol_version)      { 2 }
+    let(:connection_timeout)    { 10 }
+    let(:logger)                { Client::NullLogger.new  }
+    let(:compressor)            { nil }
+    let(:credentials)           { nil }
+    let(:auth_provider)         { nil }
+    let(:load_balancing_policy) { LoadBalancing::Policies::RoundRobin.new }
+    let(:reconnection_policy)   { Reconnection::Policies::Exponential.new(0.5, 30, 2) }
+    let(:retry_policy)          { Retry::Policies::Default.new }
+    let(:consistency)           { :quorum }
+    let(:trace)                 { false }
+    let(:page_size)             { nil }
+
+    let(:connections_per_local_node)  { 2 }
+    let(:connections_per_remote_node) { 1 }
+
+    let(:listeners) { [] }
+
+    def initialize(defaults = {})
+      @defaults  = defaults
+      @instances = {}
+    end
+
+    def connect(addresses)
+      cluster_registry.add_listener(load_balancing_policy)
+      cluster_registry.add_listener(control_connection)
+      listeners.each do |listener|
+        cluster.register(listener)
+      end
+
+      addresses.each {|address| cluster_registry.host_found(address)}
+
+      control_connection.connect_async.map(cluster)
+    end
+  end
+end