dse-driver 1.0.1

data/lib/dse/load_balancing/policies/host_targeting.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  module LoadBalancing
+    module Policies
+      # A load balancing policy that targets a particular host, and delegates to a lower-level policy if the
+      # host is not available.
+      # @private
+      class HostTargeting < Cassandra::LoadBalancing::Policy
+        # @private
+        class Plan
+          def initialize(targeted_host, policy, keyspace, statement, options)
+            @targeted_host = targeted_host
+            @policy = policy
+            @keyspace = keyspace
+            @statement = statement
+            @options = options
+            @first = true
+          end
+
+          def has_next?
+            @next = @targeted_host if @first && !@targeted_host.nil? && @targeted_host.up?
+            @first = false
+            return true if @next
+
+            @plan ||= @policy.plan(@keyspace, @statement, @options)
+
+            while @plan.has_next?
+              host = @plan.next
+
+              unless host == @targeted_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 :@base_policy, :distance, :host_found, :host_up, :host_down, :host_lost
+
+        # @param base_policy [Cassandra::LoadBalancing::Policy] policy to delegate to if host is not available.
+        def initialize(base_policy)
+          @base_policy = base_policy
+        end
+
+        def setup(cluster)
+          @cluster = cluster
+          @base_policy.setup(cluster)
+          nil
+        end
+
+        def teardown(cluster)
+          @cluster = nil
+          @base_policy.teardown(cluster)
+          nil
+        end
+
+        def plan(keyspace, statement, options)
+          # Fall back to creating a plan from the base policy if the statement is not host-targeting.
+          return @base_policy.plan(keyspace, statement, options) unless statement.is_a?(Dse::Statements::HostTargeting)
+          Plan.new(@cluster.host(statement.target_ip), @base_policy, keyspace, statement, options)
+        end
+      end
+    end
+  end
+end

data/lib/dse/session.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  # A session is used to execute queries. In addition to executing standard CQL queries via the
+  # {http://dsdocs30/api/cassandra/session#execute-instance_method #execute} and
+  # {http://dsdocs30/api/cassandra/session#execute_async-instance_method #execute_async}
+  # methods, it executes graph queries via the {#execute_graph_async} and {#execute_graph} methods.
+  #
+  # @see http://dsdocs30/api/cassandra/session Cassandra::Session
+  class Session
+    # @private
+    def initialize(cassandra_session, graph_options, futures_factory)
+      @cassandra_session = cassandra_session
+      @graph_options = graph_options
+      @futures = futures_factory
+    end
+
+    # Execute a graph statement asynchronously.
+    # @param graph_statement [String, Dse::Graph::Statement] a graph statement
+    # @param options [Hash] a customizable set of options. All of the options supported by
+    #   {Cassandra::Session#execute_async} are valid here. However, there are some extras, noted below.
+    # @option options [Hash] :arguments Parameters for the graph statement.
+    #    NOTE: Unlike {#execute} and {#execute_async}, this must be a hash of <parameter-name,value>.
+    # @option options [Dse::Graph::Options] :graph_options options for the DSE graph statement handler. Takes
+    #    priority over other `:graph_*` options specified below.
+    # @option options [String] :graph_name name of graph to use in graph statements
+    # @option options [String] :graph_source graph traversal source
+    # @option options [String] :graph_language language used in graph queries
+    # @option options [Cassandra::CONSISTENCIES] :graph_read_consistency read consistency level for graph statements.
+    #    Overrides the standard statement consistency level
+    # @option options [Cassandra::CONSISTENCIES] :graph_write_consistency write consistency level for graph statements.
+    #    Overrides the standard statement consistency level
+    # @return [Cassandra::Future<Cassandra::Result>]
+    # @see http://dsdocs30/api/cassandra/session#execute_async-instance_method
+    #   Cassandra::Session::execute_async for all of the core options.
+    def execute_graph_async(graph_statement, options = {})
+      # Make our own copy of the options. The caller might want to re-use the options they provided, and we're
+      # about to do some destructive mutations.
+
+      options = options.dup
+      Cassandra::Util.assert_instance_of_one_of([String, Dse::Graph::Statement], graph_statement)
+
+      if graph_statement.is_a?(String)
+        graph_statement = Dse::Graph::Statement.new(graph_statement, options[:arguments], options, options[:idempotent])
+      end
+
+      graph_options = @graph_options.merge(graph_statement.options)
+      options[:payload] = graph_options.as_payload
+      options[:timeout] = graph_options.timeout
+
+      if graph_options.analytics?
+        @cassandra_session.execute_async('CALL DseClientTool.getAnalyticsGraphServer()').then do |rows|
+          row = rows.first
+          if row.nil? || row['result'].nil?
+            @cassandra_session.execute_async(graph_statement, options).then do |raw_result|
+              Dse::Graph::ResultSet.new(raw_result)
+            end
+          else
+            ip = row['result']['ip']
+            targeted_statement = Dse::Statements::HostTargeting.new(graph_statement, ip)
+            @cassandra_session.execute_async(targeted_statement, options).then do |raw_result|
+              Dse::Graph::ResultSet.new(raw_result)
+            end
+          end
+        end
+      else
+        @cassandra_session.execute_async(graph_statement, options).then do |raw_result|
+          Dse::Graph::ResultSet.new(raw_result)
+        end
+      end
+    rescue => e
+      @futures.error(e)
+    end
+
+    # Execute a graph statement synchronously.
+    # @see #execute_graph_async
+    # @return [Cassandra::Result] a Cassandra result containing individual JSON results.
+    def execute_graph(statement, options = {})
+      execute_graph_async(statement, options).get
+    end
+
+    #### The following methods handle arbitrary delegation to the underlying session object. ####
+    protected
+
+    # @private
+    def method_missing(method_name, *args, &block)
+      # If we get here, we don't have a method of our own. Forward the request to @cassandra_session.
+      # If it returns itself, we will coerce the result to return our *self* instead.
+
+      result = @cassandra_session.send(method_name, *args, &block)
+      (result == @cassandra_session) ? self : result
+    end
+
+    # @private
+    def respond_to?(method, include_private = false)
+      super || @cassandra_session.respond_to?(method, include_private)
+    end
+  end
+end

data/lib/dse/statements.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  # @private
+  module Statements
+  end
+end
+require 'dse/statements/host_targeting'

data/lib/dse/statements/host_targeting.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  module Statements
+    # Wraps any query statement and attaches a target host, making it usable in a targeted load-balancing policy
+    # without modifying the user's statement.
+    # @private
+    class HostTargeting
+      include Cassandra::Util
+      include Cassandra::Statement
+
+      # @return  the base statement to execute.
+      attr_reader :base_statement
+      # @return [String] the ip address of the host on which the statement should run if possible.
+      attr_reader :target_ip
+
+      def initialize(base_statement, target_ip)
+        @base_statement = base_statement
+        @target_ip = target_ip
+      end
+
+      # @private
+      def accept(client, options)
+        client.query(self, options)
+      end
+
+      def idempotent?
+        @base_statement.idempotent?
+      end
+
+      protected
+
+      def method_missing(method_name, *args, &block)
+        # Delegate all method calls to the real statement that we're wrapping.
+        @base_statement.send(method_name, *args, &block)
+      end
+
+      def respond_to?(method, include_private = false)
+        super || @base_statement.respond_to?(method, include_private)
+      end
+    end
+  end
+end

data/lib/dse/util.rb

@@ -0,0 +1,12 @@
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  # @private
+  module Util
+  end
+end

data/lib/dse/util/endian_buffer.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  module Util
+    # Wrapper class around a Cassandra::Protocol::CqlByteBuffer that delegates reads of some
+    # numeric values to the appropriate underlying method, depending on endian-ness.
+    # @private
+    class EndianBuffer
+      def initialize(buffer, little_endian)
+        @buffer = buffer
+        # Depending on the endian-ness of the data, we want to invoke different read methods on the buffer.
+        if little_endian
+          @read_unsigned = buffer.method(:read_unsigned_int_le)
+          @read_double = buffer.method(:read_double_le)
+        else
+          @read_unsigned = buffer.method(:read_int)
+          @read_double = buffer.method(:read_double)
+        end
+      end
+
+      def read_unsigned
+        @read_unsigned.call
+      end
+
+      def read_double
+        @read_double.call
+      end
+    end
+  end
+end

data/lib/dse/version.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  VERSION = '1.0.1'.freeze
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: dse-driver
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Sandeep Tamhankar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A pure Ruby driver for DataStax Enterprise
+email:
+- sandeep.tamhankar@datastax.com
+executables: []
+extensions:
+- ext/gss_api_context/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- .yardopts
+- README.md
+- ext/gss_api_context/extconf.rb
+- ext/gss_api_context/gss_api_context.c
+- ext/gss_api_context/kerberosgss.c
+- ext/gss_api_context/kerberosgss.h
+- lib/dse.rb
+- lib/dse/auth/providers/gss_api.rb
+- lib/dse/auth/providers/password.rb
+- lib/dse/cluster.rb
+- lib/dse/geometry/line_string.rb
+- lib/dse/geometry/point.rb
+- lib/dse/geometry/polygon.rb
+- lib/dse/graph.rb
+- lib/dse/graph/duration.rb
+- lib/dse/graph/edge.rb
+- lib/dse/graph/options.rb
+- lib/dse/graph/path.rb
+- lib/dse/graph/result.rb
+- lib/dse/graph/result_set.rb
+- lib/dse/graph/statement.rb
+- lib/dse/graph/vertex.rb
+- lib/dse/graph/vertex_property.rb
+- lib/dse/load_balancing/policies/host_targeting.rb
+- lib/dse/session.rb
+- lib/dse/statements.rb
+- lib/dse/statements/host_targeting.rb
+- lib/dse/util.rb
+- lib/dse/util/endian_buffer.rb
+- lib/dse/version.rb
+homepage: http://docs.datastax.com/en/developer/ruby-driver-dse/1.0
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --title
+- Ruby Driver for DSE
+- --main
+- README.md
+- --line-numbers
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.0
+signing_key: 
+specification_version: 4
+summary: Ruby Driver for DataStax Enterprise
+test_files: []
+has_rdoc: