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

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 64e457a1343d136c65ff074454ac9e0cb42d29e4
+  data.tar.gz: 2ad5d0fc62e3e7655600de5e6096c98ec5458148
+SHA512:
+  metadata.gz: 016bd646cd22533d0b59966ff936829bfc60e785355c7badff6ac8d2d71d6be094402b4539db74460579033209d27fc521945c16b89798e4647e4a791a02d792
+  data.tar.gz: c02fdbbd1faa6e2cacdd627d375116a5ad409ab1c430a1aa1f1ce3b2d1a71bcb7273e5676364507150e6581d409af006685d84cfae7d20904727d77382844240

data/README.md

@@ -12,12 +12,12 @@ the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
 - IRC: #datastax-drivers on [irc.freenode.net](http://freenode.net>)
 - TWITTER: Follow the latest news about DataStax Drivers - [@avalanche123](http://twitter.com/avalanche123), [@mfiguiere](http://twitter.com/mfiguiere), [@al3xandru](https://twitter.com/al3xandru) 
 
-This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [Theo Hultberg](https://github.com/iconara) and we addded support for:
+This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [Theo Hultberg](https://github.com/iconara) and we added support for:
 
-* [asynchronous execution](/features/asynchronous_io/)
-* one-off, [prepared](/features/prepared_statements/) and [batch statements](/features/batch_statements/)
+* [asynchronous execution](http://datastax.github.io/ruby-driver/features/asynchronous_io/)
+* one-off, [prepared](http://datastax.github.io/ruby-driver/features/basics/prepared_statements/) and [batch statements](http://datastax.github.io/ruby-driver/features/basics/batch_statements/)
 * automatic peer discovery and cluster metadata
-* various [load-balancing](/features/load_balancing/), [retry](/features/retry_policies/) and reconnection policies, [with ability to write your own](/features/load_balancing/implementing_a_policy/)
+* various [load-balancing](http://datastax.github.io/ruby-driver/features/load_balancing/), [retry](http://datastax.github.io/ruby-driver/features/retry_policies/) and reconnection policies, [with ability to write your own](http://datastax.github.io/ruby-driver/features/load_balancing/implementing_a_policy/)
 
 ## Compability
 
@@ -37,7 +37,7 @@ require 'cassandra'
 
 cluster = Cassandra.connect # connects to localhost by default
 
-cluster.each_hosts do |host| # automatically discovers all peers
+cluster.each_host do |host| # automatically discovers all peers
   puts "Host #{host.ip}: id=#{host.id} datacenter=#{host.datacenter} rack=#{host.rack}"
 end
 
@@ -57,34 +57,42 @@ The host you specify is just a seed node, the driver will automatically discover
 
 Read more:
 
-* [`Cql.connect` options](/api/#connect-class_method)
-* [`Session#execute_async` options](/api/session/#execute_async-instance_method)
-* [Usage documentation](/features)
+* [`Cassandra.connect` options](http://datastax.github.io/ruby-driver/api/#connect-class_method)
+* [`Session#execute_async` options](http://datastax.github.io/ruby-driver/api/session/#execute_async-instance_method)
+* [Usage documentation](http://datastax.github.io/ruby-driver/features)
 
 ## Installation
 
 Install via rubygems
 
 ```bash
-gem install cassandra-driver
+gem install cassandra-driver --pre
 ```
 
 Install via Gemfile
 
 ```ruby
-gem 'cassandra-driver'
+gem 'cassandra-driver', '~> 1.0.0.beta'
 ```
 
-Note: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](/features/#compression)
+Note: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://datastax.github.io/ruby-driver/features/#compression)
 
 
 ## Upgrading from cql-rb
 
 Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API. In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/master/examples/cql-rb-wrapper.rb) to assist you with gradual upgrade.
 
+## What's new in v1.0.0.beta.2
+
+Current release introduces the following new features:
+
+* TokenAware load balancing policy
+* Domain names
+* SSL encryption
+
 ## Changelog & versioning
 
-Check out the [releases on GitHub](https://github.com/datastax/ruby-driver/releases). Version numbering follows the [semantic versioning](http://semver.org/) scheme.
+Check out the [releases on GitHub](https://github.com/datastax/ruby-driver/releases) and [changelog](https://github.com/datastax/ruby-driver/blob/master/CHANGELOG.md). Version numbering follows the [semantic versioning](http://semver.org/) scheme.
 
 Private and experimental APIs, defined as whatever is not in the [public API documentation][1], i.e. classes and methods marked as `@private`, will change without warning. If you've been recommended to try an experimental API by the maintainers, please let them know if you depend on that API. Experimental APIs will eventually become public, and knowing how they are used helps in determining their maturity.
 

data/ext/cassandra_murmur3/cassandra_murmur3.c

@@ -0,0 +1,178 @@
+// 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.
+
+#include <ruby.h>
+
+/*-----------------------------------------------------------------------------
+ * MurmurHash3 was written by Austin Appleby, and is placed in the public
+ * domain. The author hereby disclaims copyright to this source code.
+ */
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+#ifdef _MSC_VER
+typedef unsigned __int64 uint64_t;
+typedef __int64 int64_t;
+
+#define FORCE_INLINE __forceinline
+#else
+#include <stdint.h>
+#ifdef __GNUC__
+#define FORCE_INLINE __attribute__((always_inline)) inline
+#else
+#define FORCE_INLINE inline
+#endif
+#endif
+
+#define BIG_CONSTANT(x) (x##LLU)
+
+static FORCE_INLINE int64_t
+rotl(int64_t x, int8_t r)
+{
+  // cast to unsigned for logical right bitshift (to match C* MM3 implementation)
+  return (x << r) | ((int64_t) (((uint64_t) x) >> (64 - r)));
+}
+
+static FORCE_INLINE int64_t
+getblock(const int64_t* p, int i)
+{
+  return p[i];
+}
+
+static FORCE_INLINE int64_t
+fmix(int64_t k)
+{
+  // cast to unsigned for logical right bitshift (to match C* MM3 implementation)
+  k ^= ((uint64_t) k) >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= ((uint64_t) k) >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= ((uint64_t) k) >> 33;
+
+  return k;
+}
+
+static VALUE
+rb_murmur3_hash(VALUE self, VALUE rb_string)
+{
+  char*   bytes;
+  int64_t length;
+
+  Check_Type(rb_string, T_STRING);
+
+  bytes  = RSTRING_PTR(rb_string);
+  length = RSTRING_LEN(rb_string);
+
+  const int nblocks = length / 16;
+  int i;
+
+  int64_t h1 = 0;
+  int64_t h2 = 0;
+
+  int64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+  int64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+  //----------
+  // body
+
+  const int64_t* blocks = (const int64_t*)(bytes);
+
+  for(i = 0; i < nblocks; i++)
+  {
+    int64_t k1 = getblock(blocks, i * 2 + 0);
+    int64_t k2 = getblock(blocks, i * 2 + 1);
+
+    k1 *= c1;
+    k1  = rotl(k1, 31);
+    k1 *= c2;
+    h1 ^= k1;
+
+    h1  = rotl(h1, 27);
+    h1 += h2;
+    h1  = h1 * 5 + 0x52dce729;
+
+    k2 *= c2;
+    k2  = rotl(k2, 33);
+    k2 *= c1;
+    h2 ^= k2;
+
+    h2  = rotl(h2, 31);
+    h2 += h1;
+    h2  = h2 * 5 + 0x38495ab5;
+  }
+
+  //----------
+  // tail
+
+  const int8_t* tail = (const int8_t*) (bytes + nblocks * 16);
+
+  int64_t k1 = 0;
+  int64_t k2 = 0;
+
+  switch(length & 15)
+  {
+    case 15: k2 ^= ((int64_t) tail[14]) << 48;
+    case 14: k2 ^= ((int64_t) tail[13]) << 40;
+    case 13: k2 ^= ((int64_t) tail[12]) << 32;
+    case 12: k2 ^= ((int64_t) tail[11]) << 24;
+    case 11: k2 ^= ((int64_t) tail[10]) << 16;
+    case 10: k2 ^= ((int64_t) tail[ 9]) << 8;
+    case  9: k2 ^= ((int64_t) tail[ 8]) << 0;
+             k2 *= c2;
+             k2  = rotl(k2, 33);
+             k2 *= c1;
+             h2 ^= k2;
+    case  8: k1 ^= ((int64_t) tail[7]) << 56;
+    case  7: k1 ^= ((int64_t) tail[6]) << 48;
+    case  6: k1 ^= ((int64_t) tail[5]) << 40;
+    case  5: k1 ^= ((int64_t) tail[4]) << 32;
+    case  4: k1 ^= ((int64_t) tail[3]) << 24;
+    case  3: k1 ^= ((int64_t) tail[2]) << 16;
+    case  2: k1 ^= ((int64_t) tail[1]) << 8;
+    case  1: k1 ^= ((int64_t) tail[0]) << 0;
+             k1 *= c1;
+             k1  = rotl(k1, 31);
+             k1 *= c2;
+             h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= length;
+  h2 ^= length;
+
+  h1 += h2;
+  h2 += h1;
+
+  h1 = fmix(h1);
+  h2 = fmix(h2);
+
+  h1 += h2;
+  h2 += h1;
+
+  return LL2NUM(h1);
+}
+
+void
+Init_cassandra_murmur3()
+{
+  VALUE mCassandra, mMurmur3;
+
+  mCassandra = rb_define_module_under(rb_cObject, "Cassandra");
+  mMurmur3   = rb_define_module_under(mCassandra, "Murmur3");
+
+  rb_define_module_function(mMurmur3, "hash", rb_murmur3_hash, 1);
+}

data/ext/cassandra_murmur3/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('cassandra_murmur3')

data/lib/cassandra.rb

@@ -26,6 +26,10 @@ require 'set'
 require 'bigdecimal'
 require 'forwardable'
 require 'timeout'
+require 'digest'
+require 'stringio'
+require 'resolv'
+require 'openssl'
 
 module Cassandra
   # A list of all supported request consistencies
@@ -42,55 +46,77 @@ module Cassandra
   # @option options [Array<String, IPAddr>] :hosts (['127.0.0.1']) a list of
   #   initial addresses. Note that the entire list of cluster members will be
   #   discovered automatically once a connection to any hosts from the original
-  #   list is successful
+  #   list is successful.
   #
-  # @option options [Integer] :port (9042) cassandra native protocol port
+  # @option options [Integer] :port (9042) cassandra native protocol port.
+  #
+  # @option options [Numeric] :connect_timeout (10) connection timeout in
+  #   seconds.
   #
   # @option options [String] :username (none) username to use for
-  #   authentication to cassandra. Note that you must also specify `:password`
+  #   authentication to cassandra. Note that you must also specify `:password`.
   #
   # @option options [String] :password (none) password to use for
-  #   authentication to cassandra. Note that you must also specify `:username`
+  #   authentication to cassandra. Note that you must also specify `:username`.
+  #
+  # @option options [Boolean, OpenSSL::SSL::SSLContext] :ssl (false) enable
+  #   default ssl authentication if `true` (not recommended). Also accepts an
+  #   initialized {OpenSSL::SSL::SSLContext}. Note that this option should be
+  #   ignored if `:server_cert`, `:client_cert`, `:private_key` or
+  #   `:passphrase` are given.
+  #
+  # @option options [String] :server_cert (none) path to server certificate or
+  #   certificate authority file.
+  #
+  # @option options [String] :client_cert (none) path to client certificate
+  #   file. Note that this option is only required when encryption is
+  #   configured to require client authentication.
+  #
+  # @option options [String] :private_key (none) path to client private key.
+  #   Note that this option is only required when encryption is configured to
+  #   require client authentication.
+  #
+  # @option options [String] :passphrase (none) passphrase for private key.
   #
   # @option options [Symbol] :compression (none) compression to use. Must be
   #   either `:snappy` or `:lz4`. Also note, that in order for compression to
-  #   work, you must install 'snappy' or 'lz4-ruby' gems
+  #   work, you must install 'snappy' or 'lz4-ruby' gems.
   #
   # @option options [Cassandra::LoadBalancing::Policy] :load_balancing_policy
-  #   default: {Cassandra::LoadBalancing::Policies::RoundRobin}
+  #   default: {Cassandra::LoadBalancing::Policies::RoundRobin}.
   #
   # @option options [Cassandra::Reconnection::Policy] :reconnection_policy
   #   default: {Cassandra::Reconnection::Policies::Exponential}. Note that the
   #   default policy is configured with
-  #   `Reconnection::Policies::Exponential.new(0.5, 30, 2)`
+  #   `Reconnection::Policies::Exponential.new(0.5, 30, 2)`.
   #
   # @option options [Cassandra::Retry::Policy] :retry_policy default:
-  #   {Cassandra::Retry::Policies::Default}
+  #   {Cassandra::Retry::Policies::Default}.
   #
   # @option options [Logger] :logger (none) logger. a {Logger} instance from the
   #   standard library or any object responding to standard log methods
-  #   (`#debug`, `#info`, `#warn`, `#error` and `#fatal`)
+  #   (`#debug`, `#info`, `#warn`, `#error` and `#fatal`).
   #
   # @option options [Enumerable<Cassandra::Listener>] :listeners (none)
   #   initial listeners. A list of initial cluster state listeners. Note that a
-  #   load_balancing policy is automatically registered with the cluster.
+  #   `:load_balancing` policy is automatically registered with the cluster.
   #
   # @option options [Symbol] :consistency (:quorum) default consistency to use
-  #   for all requests. Must be one of {Cassandra::CONSISTENCIES}
+  #   for all requests. Must be one of {Cassandra::CONSISTENCIES}.
   #
   # @option options [Boolean] :trace (false) whether or not to trace all
-  #   requests by default
+  #   requests by default.
   #
   # @option options [Integer] :page_size (nil) default page size for all select
-  #   queries
+  #   queries.
   #
-  # @option options [Hash{String => String}] :credentials (none) a hash of credentials - to be used with [credentials authentication in cassandra 1.2](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L238-L250). Note that if you specified `:username` and `:password` options, those credentials are configured automatically
+  # @option options [Hash{String => String}] :credentials (none) a hash of credentials - to be used with [credentials authentication in cassandra 1.2](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L238-L250). Note that if you specified `:username` and `:password` options, those credentials are configured automatically.
   #
-  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v2.spec#L257-L273). Note that if you have specified `:username` and `:password`, then a {Cassandra::Auth::Providers::Password} will be used automatically
+  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v2.spec#L257-L273). Note that if you have specified `:username` and `:password`, then a {Cassandra::Auth::Providers::Password} will be used automatically.
   #
   # @option options [Cassandra::Compressor] :compressor (none) a custom
   #   compressor. Note that if you have specified `:compression`, an
-  #   appropriate compressor will be provided automatically
+  #   appropriate compressor will be provided automatically.
   #
   # @option options [Object<#all, #error, #value, #promise>] :futures_factory
   #   (none) a custom futures factory to assist with integration into existing
@@ -114,7 +140,8 @@ module Cassandra
       [ :credentials, :auth_provider, :compression, :hosts, :logger, :port,
         :load_balancing_policy, :reconnection_policy, :retry_policy, :listeners,
         :consistency, :trace, :page_size, :compressor, :username, :password,
-        :futures_factory
+        :ssl, :server_cert, :client_cert, :private_key, :passphrase,
+        :connect_timeout, :futures_factory
       ].include?(key)
     end
 
@@ -155,6 +182,69 @@ module Cassandra
       end
     end
 
+    has_client_cert = options.has_key?(:client_cert)
+    has_private_key = options.has_key?(:private_key)
+
+    if has_client_cert || has_private_key
+      if has_client_cert && !has_private_key
+        raise ::ArgumentError, "both :client_cert and :private_key options must be specified, but only :client_cert given"
+      end
+
+      if !has_client_cert && has_private_key
+        raise ::ArgumentError, "both :client_cert and :private_key options must be specified, but only :private_key given"
+      end
+
+      client_cert = ::File.expand_path(options[:client_cert])
+      private_key = ::File.expand_path(options[:private_key])
+
+      unless ::File.exists?(client_cert)
+        raise ::ArgumentError, ":client_cert #{client_cert.inspect} doesn't exist"
+      end
+
+      unless ::File.exists?(private_key)
+        raise ::ArgumentError, ":private_key #{private_key.inspect} doesn't exist"
+      end
+    end
+
+    has_server_cert = options.has_key?(:server_cert)
+
+    if has_server_cert
+      server_cert = ::File.expand_path(options[:server_cert])
+
+      unless ::File.exists?(server_cert)
+        raise ::ArgumentError, ":server_cert #{server_cert.inspect} doesn't exist"
+      end
+    end
+
+    if has_client_cert || has_server_cert
+      context = ::OpenSSL::SSL::SSLContext.new
+
+      if has_server_cert
+        context.ca_file     = server_cert
+        context.verify_mode = ::OpenSSL::SSL::VERIFY_PEER
+      end
+
+      if has_client_cert
+        context.cert = ::OpenSSL::X509::Certificate.new(File.read(client_cert))
+
+        if options.has_key?(:passphrase)
+          context.key = ::OpenSSL::PKey::RSA.new(File.read(private_key), options[:passphrase])
+        else
+          context.key = ::OpenSSL::PKey::RSA.new(File.read(private_key))
+        end
+      end
+
+      options[:ssl] = context
+    end
+
+    if options.has_key?(:ssl)
+      ssl = options[:ssl]
+
+      unless ssl.is_a?(::TrueClass) || ssl.is_a?(::FalseClass) || ssl.is_a?(::OpenSSL::SSL::SSLContext)
+        raise ":ssl must be a boolean or an OpenSSL::SSL::SSLContext, #{ssl.inspect} given"
+      end
+    end
+
     if options.has_key?(:compression)
       compression = options.delete(:compression)
 
@@ -196,9 +286,17 @@ module Cassandra
       end
     end
 
+    if options.has_key?(:connect_timeout)
+      timeout = options[:connect_timeout] = Integer(options[:connect_timeout])
+
+      if timeout < 0
+        raise ::ArgumentError, ":connect_timeout must be a positive value, #{timeout.given}"
+      end
+    end
+
     if options.has_key?(:load_balancing_policy)
       load_balancing_policy = options[:load_balancing_policy]
-      methods = [:host_up, :host_down, :host_found, :host_lost, :distance, :plan]
+      methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :distance, :plan]
 
       unless methods.all? {|method| load_balancing_policy.respond_to?(method)}
         raise ::ArgumentError, ":load_balancing_policy #{load_balancing_policy.inspect} must respond to #{methods.inspect}, but doesn't"
@@ -259,20 +357,25 @@ module Cassandra
       end
     end
 
-    hosts = options.fetch(:hosts, [])
-    hosts << ::IPAddr.new('127.0.0.1') if hosts.empty?
+    hosts = []
 
-    hosts.map! do |host|
+    Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
       case host
       when ::IPAddr
-        host
-      when ::String
-        ::IPAddr.new(host)
+        hosts << host
+      when ::String # ip address or hostname
+        Resolv.each_address(host) do |ip|
+          hosts << ::IPAddr.new(ip)
+        end
       else
         raise ::ArgumentError, ":hosts must be String or IPAddr, #{host.inspect} given"
       end
     end
 
+    if hosts.empty?
+      raise ::ArgumentError, ":hosts #{options[:hosts].inspect} could not be resolved to any ip address"
+    end
+
     Driver.new(options).connect(hosts).value
   end
 end
@@ -308,6 +411,9 @@ require 'cassandra/retry'
 
 require 'cassandra/util'
 
+# murmur3 hash extension
+require 'cassandra_murmur3'
+
 module Cassandra
   # @private
   Io = Ione::Io
@@ -317,4 +423,6 @@ module Cassandra
   VOID_OPTIONS   = Execution::Options.new({:consistency => :one})
   # @private
   NO_HOSTS       = Errors::NoHostsAvailable.new
+  # @private
+  EMPTY_LIST = [].freeze
 end