riak-client 1.4.5 → 2.0.0.rc1

data/lib/riak/client/node.rb

@@ -6,8 +6,7 @@ module Riak
       include Util::Translation
       include Util::Escape
 
-      VALID_OPTIONS = [:host, :http_port, :pb_port, :http_paths, :prefix,
-        :mapred, :luwak, :solr, :port, :basic_auth, :ssl_options, :ssl]
+      VALID_OPTIONS = [:host, :pb_port]
 
       # For a score which halves in 10 seconds, choose
       # ln(1/2)/10
@@ -15,32 +14,17 @@ module Riak
 
       # What IP address or hostname does this node listen on?
       attr_accessor :host
-      # Which port does the HTTP interface listen on?
-      attr_accessor :http_port
+
       # Which port does the protocol buffers interface listen on?
       attr_accessor :pb_port
-      # A hash of HTTP paths used on this node.
-      attr_accessor :http_paths
-      # A "user:password" string.
-      attr_reader :basic_auth
-      attr_accessor :ssl_options
+
       # A Decaying rate of errors.
       attr_reader :error_rate
 
       def initialize(client, opts = {})
         @client = client
-        @ssl = opts[:ssl]
-        @ssl_options = opts[:ssl_options]
         @host = opts[:host] || "127.0.0.1"
-        @http_port = opts[:http_port] || opts[:port] || 8098
         @pb_port = opts[:pb_port] || 8087
-        @http_paths = {
-          :prefix => opts[:prefix] || "/riak/",
-          :mapred => opts[:mapred] || "/mapred",
-          :luwak =>  opts[:luwak]  || "/luwak",
-          :solr =>   opts[:solr]   || "/solr" # Unused?
-        }.merge(opts[:http_paths] || {})
-        self.basic_auth = opts[:basic_auth]
 
         @error_rate = Decaying.new
       end
@@ -48,73 +32,18 @@ module Riak
       def ==(o)
         o.kind_of? Node and
           @host == o.host and
-          @http_port == o.http_port and
           @pb_port == o.pb_port
       end
 
-      # Sets the HTTP Basic Authentication credentials.
-      # @param [String] value an auth string in the form "user:password"
-      def basic_auth=(value)
-        case value
-        when nil
-          @basic_auth = nil
-        when String
-          raise ArgumentError, t("invalid_basic_auth") unless value.to_s.split(':').length === 2
-          @basic_auth = value
-        end
-      end
-
-      # Can this node be used for HTTP requests?
-      def http?
-        # TODO: Need to sort out capabilities
-        true
-      end
-
       # Can this node be used for protocol buffers requests?
       def protobuffs?
         # TODO: Need to sort out capabilities
         true
       end
 
-      # Enables or disables SSL on this node to be utilized by the HTTP
-      # Backends
-      def ssl=(value)
-        case value
-        when TrueClass
-          @ssl_options ||= {}
-        when Hash
-          (@ssl_options ||= {}).merge!(value)
-        end
-        value ? ssl_enable : ssl_disable
-      end
-
-      # Checks if SSL is enabled for HTTP
-      def ssl_enabled?
-        @client.protocol == 'https' && @ssl_options.present?
-      end
-
       def inspect
-        "#<Node #{@host}:#{@http_port}:#{@pb_port}>"
-      end
-
-      protected
-
-
-      def ssl_enable
-        @client.protocol = 'https' unless @client.protocol == 'https'
-        @ssl_options[:pem] = File.read(@ssl_options[:pem_file]) if @ssl_options[:pem_file]
-        @ssl_options[:verify_mode] ||= "peer" if @ssl_options.stringify_keys.any? {|k,v| %w[pem ca_file ca_path].include?(k)}
-        @ssl_options[:verify_mode] ||= "none"
-        raise ArgumentError.new(t('invalid_ssl_verify_mode', :invalid => @ssl_options[:verify_mode])) unless %w[none peer].include?(@ssl_options[:verify_mode])
-
-        @ssl_options
+        "#<Node #{@host}:#{@pb_port}>"
       end
-
-      def ssl_disable
-        @client.protocol = 'http' unless @client.protocol == 'http'
-        @ssl_options  = nil
-      end
-
     end
   end
 end

data/lib/riak/client/protobuffs_backend.rb

@@ -29,10 +29,6 @@ module Riak
         @node = node
       end
 
-      simple :ping,          :PingReq
-      simple :get_client_id, :GetClientIdReq
-      simple :server_info,   :GetServerInfoReq
-
       # Performs a secondary-index query via emulation through MapReduce.
       # @param [String, Bucket] bucket the bucket to query
       # @param [String] index the index to query
@@ -72,6 +68,10 @@ module Riak
       def teardown
         reset_socket
       end
+      
+      def socket
+        @socket ||= new_socket
+      end
 
       private
       def get_server_version
@@ -82,17 +82,9 @@ module Riak
       def decode_response
         raise NotImplementedError
       end
-
-      def socket
-        @socket ||= new_socket
-      end
-
+      
       def new_socket
-        socket = TCPSocket.new(@node.host, @node.pb_port)
-        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
-        #TODO: Should we set the client ID here?
-        # set_client_id @client.client_id
-        socket
+        raise NotImplementedError
       end
 
       def reset_socket

data/lib/riak/client/search.rb

@@ -1,5 +1,3 @@
-require 'builder'
-
 module Riak
   class Client
     # (Riak Search) Performs a search via the Solr interface.
@@ -25,67 +23,5 @@ module Riak
       end
     end
     alias :select :search
-
-    # (Riak Search) Adds documents to a search index via the Solr interface.
-    # @overload index(index, *docs)
-    #   Adds documents to the specified search index
-    #   @param [String] index the index in which to add/update the given documents
-    #   @param [Array<Hash>] docs unnested document hashes, with one key per field
-    # @overload index(*docs)
-    #   Adds documents to the default search index
-    #   @param [Array<Hash>] docs unnested document hashes, with one key per field
-    # @raise [ArgumentError] if any documents don't include 'id' key
-    def index(*args)
-      index = args.shift if String === args.first # Documents must be hashes of fields
-      raise ArgumentError.new(t("search_docs_require_id")) unless args.all? {|d| d.key?("id") || d.key?(:id) }
-      xml = Builder::XmlMarkup.new
-      xml.add do
-        args.each do |doc|
-          xml.doc do
-            doc.each do |k,v|
-              xml.field('name' => k.to_s) { xml.text!(v.to_s) }
-            end
-          end
-        end
-      end
-      http do |h|
-        h.update_search_index(index, xml.target!)
-      end
-      true
-    end
-    alias :add_doc :index
-
-    # (Riak Search) Removes documents from a search index via the Solr interface.
-    # @overload remove(index, specs)
-    #   Removes documents from the specified index
-    #   @param [String] index the index from which to remove documents
-    #   @param [Array<Hash>] specs the specificaiton of documents to remove (must contain 'id' or 'query' keys)
-    # @overload remove(specs)
-    #   Removes documents from the default index
-    #   @param [Array<Hash>] specs the specification of documents to remove (must contain 'id' or 'query' keys)
-    # @raise [ArgumentError] if any document specs don't include 'id' or 'query' keys
-    def remove(*args)
-      index = args.shift if String === args.first
-      raise ArgumentError.new(t("search_remove_requires_id_or_query")) unless args.all? { |s|
-        s.include? :id or
-        s.include? 'id' or
-        s.include? :query or
-        s.include? 'query'
-      }
-      xml = Builder::XmlMarkup.new
-      xml.delete do
-        args.each do |spec|
-          spec.each do |k,v|
-            xml.tag!(k.to_sym, v)
-          end
-        end
-      end
-      http do |h|
-        h.update_search_index(index, xml.target!)
-      end
-      true
-    end
-    alias :delete_doc :remove
-    alias :deindex :remove
   end
 end

data/lib/riak/client/yokozuna.rb

@@ -0,0 +1,52 @@
+module Riak
+  class Client
+    def create_search_index(name, schema=nil, n_val=nil)
+      raise ArgumentError, t("zero_length_index") if name.nil? || name.empty?
+      backend do |b|
+        b.create_search_index(name, schema, n_val)
+      end
+      true
+    end
+
+    def get_search_index(name)
+      raise ArgumentError, t("zero_length_index") if name.nil? || name.empty?
+      resp = []
+      backend do |b|
+        resp = b.get_search_index(name)
+      end
+      resp.index && Array === resp.index ? resp.index.first : resp
+    end
+
+    def list_search_indexes()
+      resp = []
+      backend do |b|
+        resp = b.get_search_index(nil)
+      end
+      resp.index ? resp.index : resp
+    end
+
+    def delete_search_index(name)
+      raise ArgumentError, t("zero_length_index") if name.nil? || name.empty?
+      backend do |b|
+        b.delete_search_index(name)
+      end
+      true
+    end
+
+    def create_search_schema(name, content)
+      raise ArgumentError, t("zero_length_schema") if name.nil? || name.empty?
+      raise ArgumentError, t("zero_length_content") if content.nil? || content.empty?
+      backend do |b|
+        b.create_search_schema(name, content)
+      end
+      true
+    end
+
+    def get_search_schema(name)
+      raise ArgumentError, t("zero_length_schema") if name.nil? || name.empty?
+      backend do |b|
+        return b.get_search_schema(name)
+      end
+    end
+  end
+end

data/lib/riak/counter.rb

@@ -1,4 +1,4 @@
-require 'riak/failed_request'
+require 'riak/errors/failed_request'
 
 module Riak
 

data/lib/riak/crdt.rb

@@ -0,0 +1,21 @@
+require 'riak/errors/crdt_error'
+
+%w{ operation base inner_register inner_flag counter inner_counter batch_counter map inner_map batch_map set inner_set typed_collection }.each do |f|
+  require "riak/crdt/#{f}"
+end
+
+module Riak
+  # Container module for Convergent Replicated Data Type
+  # features.
+  module Crdt
+
+    # These are the default bucket types for the three top-level data types.
+    # Broadly, CRDTs require allow_mult to be enabled, and the `datatype`
+    # property to be set to the appropriate atom (`counter`, `map`, or `set`).
+    DEFAULT_BUCKET_TYPES = {
+      counter: 'counters',
+      map: 'maps',
+      set: 'sets',
+    }
+  end
+end

data/lib/riak/crdt/base.rb

@@ -0,0 +1,97 @@
+module Riak
+  module Crdt
+
+    # Basic and shared code used by the top-level CRDTs. In particular, dirty-
+    # tracking, loading, and operating is implemented by this class, and
+    # the {Riak::Crdt::Set}, {Riak::Crdt::Counter}, and {Riak::Crdt::Map}
+    # classes implement everything else.
+    #
+    # @api private
+    class Base
+      include Util::Translation
+      attr_reader :bucket
+      attr_reader :bucket_type
+
+      # Returns the key of this CRDT. Extremely useful when using a 
+      # Riak-assigned key.
+      attr_reader :key
+
+      def initialize(bucket, key, bucket_type, options={})
+        raise ArgumentError, t("bucket_type", bucket: bucket.inspect) unless bucket.is_a? Bucket
+
+        unless key.is_a? String or key.nil?
+          raise ArgumentError, t("string_type", string: key.inspect)
+        end
+
+        @bucket = bucket
+        @key = key
+        @bucket_type = bucket_type
+        @options = options
+
+        @dirty = true
+      end
+
+      def dirty?
+        @dirty
+      end
+      
+      # Force a reload of this structure from Riak.
+      def reload
+        loader do |l|
+          vivify l.load @bucket, @key, @bucket_type
+          @context = l.context
+        end
+        @dirty = false
+
+        self
+      end
+
+      # Does this CRDT have the context necessary to remove elements?
+      #
+      # @return [Boolean] if the set has a defined context
+      def context?
+        !!@context
+      end
+      
+      private
+      def client
+        @bucket.client
+      end
+
+      def backend(&blk)
+        client.backend &blk
+      end
+
+      def loader
+        backend do |be|
+          yield be.crdt_loader
+        end
+      end
+      
+      def operator
+        backend do |be|
+          yield be.crdt_operator
+        end
+      end
+
+      def operate(*args)
+        options = Hash.new
+        options = args.pop if args.last.is_a? Hash
+        options[:context] ||= @context
+        result = operator do |op|
+          response = op.operate(bucket.name,
+                                key,
+                                bucket_type,
+                                *args,
+                                options
+                                )
+
+          break if :empty == response
+          @key = response.key if response.key
+        end
+
+        @dirty = true
+      end
+    end
+  end
+end

data/lib/riak/crdt/batch_counter.rb

@@ -0,0 +1,19 @@
+module Riak
+  module Crdt
+    class BatchCounter
+      attr_reader :accumulator
+      
+      def initialize
+        @accumulator = 0
+      end
+      
+      def increment(amount=1)
+        @accumulator += amount
+      end
+      
+      def decrement(amount=1)
+        increment -amount
+      end
+    end
+  end
+end

data/lib/riak/crdt/batch_map.rb

@@ -0,0 +1,41 @@
+module Riak
+  module Crdt
+    # A map that queues up its operations for the parent {Map} to send to
+    # Riak all at once.
+    class BatchMap
+      attr_reader :counters, :flags, :maps, :registers, :sets
+      
+      # @api private
+      def initialize(parent)
+        @parent = parent
+        @queue = []
+
+        initialize_collections
+      end
+
+      # @api private
+      def operate(operation)
+        @queue << operation
+      end
+
+      # @api private
+      def operations
+        @queue.map do |q|
+          Operation::Update.new.tap do |op|
+            op.type = :map
+            op.value = q
+          end
+        end
+      end
+      
+      private
+      def initialize_collections
+        @counters = @parent.counters.reparent self
+        @flags = @parent.flags.reparent self
+        @maps = @parent.maps.reparent self
+        @registers = @parent.registers.reparent self
+        @sets = @parent.sets.reparent self
+      end
+    end
+  end
+end