seomoz-riak-client 1.0.0.pre

data/lib/riak/client/net_http_backend.rb

@@ -0,0 +1,79 @@
+
+require 'riak/client/http_backend'
+require 'riak/failed_request'
+
+module Riak
+  class Client
+    # Uses the Ruby standard library Net::HTTP to connect to Riak.
+    # Conforms to the Riak::Client::HTTPBackend interface.
+    class NetHTTPBackend < HTTPBackend
+      def self.configured?
+        begin
+          require 'net/http'
+          require 'openssl'
+          true
+        rescue LoadError, NameError
+          false
+        end
+      end
+
+      # Sets the read_timeout applied to Net::HTTP connections
+      # Increase this if you have very long request times.
+      def self.read_timeout=(timeout)
+        @read_timeout = timeout
+      end
+
+      def self.read_timeout
+        @read_timeout ||= 4096
+      end
+
+      private
+      def perform(method, uri, headers, expect, data=nil) #:nodoc:
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = self.class.read_timeout
+        configure_ssl(http) if @client.ssl_enabled?
+
+        request = Net::HTTP.const_get(method.to_s.capitalize).new(uri.request_uri, headers)
+        case data
+        when String
+          request.body = data
+        when data.respond_to?(:read)
+          case
+          when data.respond_to?(:stat) # IO#stat
+            request.content_length = data.stat.size
+          when data.respond_to?(:size) # Some IO-like objects
+            request.content_length = data.size
+          else
+            request['Transfer-Encoding'] = 'chunked'
+          end
+          request.body_stream = data
+        end
+
+        {}.tap do |result|
+          http.request(request) do |response|
+            if valid_response?(expect, response.code)
+              result.merge!({:headers => response.to_hash, :code => response.code.to_i})
+              response.read_body {|chunk| yield chunk } if block_given?
+              if return_body?(method, response.code, block_given?)
+                result[:body] = response.body
+              end
+            else
+              raise Riak::HTTPFailedRequest.new(method, expect, response.code.to_i, response.to_hash, response.body)
+            end
+          end
+        end
+      end
+
+      def configure_ssl(http)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL.const_get("VERIFY_#{@client.ssl_options[:verify_mode].upcase}")
+        if @client.ssl_options[:pem]
+          http.cert = OpenSSL::X509::Certificate.new(@client.ssl_options[:pem])
+          http.key  = OpenSSL::PKey::RSA.new(@client.ssl_options[:pem], @client.ssl_options[:pem_password])
+        end
+        http.ca_file = @client.ssl_options[:ca_file] if @client.ssl_options[:ca_file]
+        http.ca_path = @client.ssl_options[:ca_path] if @client.ssl_options[:ca_path]
+      end
+    end
+  end
+end

data/lib/riak/client/protobuffs_backend.rb

@@ -0,0 +1,97 @@
+require 'riak'
+require 'socket'
+require 'base64'
+require 'digest/sha1'
+require 'riak/util/translation'
+
+module Riak
+  class Client
+    class ProtobuffsBackend
+      include Util::Translation
+
+      # Message Codes Enum
+      MESSAGE_CODES = %W[
+          ErrorResp
+          PingReq
+          PingResp
+          GetClientIdReq
+          GetClientIdResp
+          SetClientIdReq
+          SetClientIdResp
+          GetServerInfoReq
+          GetServerInfoResp
+          GetReq
+          GetResp
+          PutReq
+          PutResp
+          DelReq
+          DelResp
+          ListBucketsReq
+          ListBucketsResp
+          ListKeysReq
+          ListKeysResp
+          GetBucketReq
+          GetBucketResp
+          SetBucketReq
+          SetBucketResp
+          MapRedReq
+          MapRedResp
+       ].map {|s| s.intern }.freeze
+
+      def self.simple(method, code)
+        define_method method do
+          socket.write([1, MESSAGE_CODES.index(code)].pack('NC'))
+          decode_response
+        end
+      end
+
+      attr_accessor :client
+      def initialize(client)
+        @client = client
+      end
+
+      simple :ping,          :PingReq
+      simple :get_client_id, :GetClientIdReq
+      simple :server_info,   :GetServerInfoReq
+      simple :list_buckets,  :ListBucketsReq
+
+      private
+      # Implemented by subclasses
+      def decode_response
+        raise NotImplementedError
+      end
+
+      def socket
+        Thread.current[:riakpbc_socket] ||= new_socket
+      end
+
+      def new_socket
+        socket = TCPSocket.new(@client.host, @client.pb_port)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+        socket
+      end
+
+      def reset_socket
+        socket.close
+        Thread.current[:riakpbc_socket] = nil
+      end
+
+      UINTMAX = 0xffffffff
+      QUORUMS = {
+        "one" => UINTMAX - 1,
+        "quorum" => UINTMAX - 2,
+        "all" => UINTMAX - 3,
+        "default" => UINTMAX - 4
+      }.freeze
+
+      def normalize_quorum_value(q)
+        QUORUMS[q.to_s] || q.to_i
+      end
+
+      # This doesn't give us exactly the keygen that Riak uses, but close.
+      def generate_key
+        Base64.encode64(Digest::SHA1.digest(Socket.gethostname + Time.now.iso8601(3))).tr("+/","-_").sub(/=+\n$/,'')
+      end
+    end
+  end
+end

data/lib/riak/client/pump.rb

@@ -0,0 +1,30 @@
+
+begin
+  require 'fiber'
+rescue LoadError
+  require 'riak/util/fiber1.8'
+end
+
+module Riak
+  class Client
+    # @private
+    class Pump      
+      def initialize(block)
+        @fiber = Fiber.new do
+          loop do
+            block.call Fiber.yield
+          end
+        end
+        @fiber.resume
+      end
+
+      def pump(input)
+        @fiber.resume input
+      end
+
+      def to_proc
+        method(:pump).to_proc
+      end
+    end
+  end
+end

data/lib/riak/client/search.rb

@@ -0,0 +1,94 @@
+
+require 'builder'
+
+module Riak
+  class Client
+    # (Riak Search) Performs a search via the Solr interface.
+    # @overload search(index, query, options={})
+    #   @param [String] index the index to query on
+    #   @param [String] query a Lucene query string
+    # @overload search(query, options={})
+    #   Queries the default index
+    #   @param [String] query a Lucene query string
+    # @param [Hash] options extra options for the Solr query
+    # @option options [String] :df the default field to search in
+    # @option options [String] :'q.op' the default operator between terms ("or", "and")
+    # @option options [String] :wt ("json") the response type - "json" and "xml" are valid
+    # @option options [String] :sort ('none') the field and direction to sort, e.g. "name asc"
+    # @option options [Fixnum] :start (0) the offset into the query to start from, e.g. for pagination
+    # @option options [Fixnum] :rows (10) the number of results to return
+    # @return [Hash] the query result, containing the 'responseHeaders' and 'response' keys
+    def search(*args)
+      options = args.extract_options!
+      index, query = args[-2], args[-1]  # Allows nil index, while keeping it as first argument
+      path = [solr, index, "select", {"q" => query, "wt" => "json"}.merge(options.stringify_keys), {}].compact
+      response = http.get(200, *path)
+      if response[:headers]['content-type'].include?("application/json")
+        JSON.parse(response[:body])
+      else
+        response[:body]
+      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
+      path = [solr, index, "update", xml.target!, {'Content-Type' => 'text/xml'}].compact
+      http.post(200, *path)
+      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
+      path = [solr, index, "update", xml.target!, {'Content-Type' => 'text/xml'}].compact
+      http.post(200, *path)
+      true
+    end
+    alias :delete_doc :remove
+    alias :deindex :remove
+  end
+end

data/lib/riak/core_ext.rb

@@ -0,0 +1,6 @@
+require 'riak/core_ext/blank'
+require 'riak/core_ext/extract_options'
+require 'riak/core_ext/slice'
+require 'riak/core_ext/stringify_keys'
+require 'riak/core_ext/symbolize_keys'
+require 'riak/core_ext/to_param'

data/lib/riak/core_ext/blank.rb

@@ -0,0 +1,53 @@
+require 'set'
+
+unless Object.new.respond_to? :blank?
+  class Object
+    def blank?
+      false
+    end
+  end
+
+  class NilClass
+    def blank?
+      true
+    end
+  end
+
+  class FalseClass
+    def blank?
+      true
+    end
+  end
+
+  class TrueClass
+    def blank?
+      false
+    end
+  end
+
+  class Set
+    alias :blank? :empty?
+  end
+
+  class String
+    def blank?
+      self !~ /[^\s]/
+    end
+  end
+
+  class Array
+    alias :blank? :empty?
+  end
+
+  class Hash
+    alias :blank? :empty?
+  end
+end
+
+unless Object.new.respond_to? :present?
+  class Object
+    def present?
+      !blank?
+    end
+  end
+end

data/lib/riak/core_ext/extract_options.rb

@@ -0,0 +1,7 @@
+unless Array.new.respond_to? :extract_options!
+  class Array
+    def extract_options!
+      last.is_a?(::Hash) ? pop : {}
+    end
+  end
+end

data/lib/riak/core_ext/json.rb

@@ -0,0 +1,15 @@
+unless Object.new.respond_to?(:to_json)
+  # @private
+  class Object
+    def to_json(*args)
+      Riak::JSON.encode(self)
+    end
+  end
+
+  # @private
+  class Symbol
+    def to_json(*args)
+      to_s.to_json(*args)
+    end
+  end
+end

data/lib/riak/core_ext/slice.rb

@@ -0,0 +1,18 @@
+unless {}.respond_to? :slice
+  class Hash
+    def slice(*keys)
+      allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      hash = {}
+      allowed.each { |k| hash[k] = self[k] if has_key?(k) }
+      hash
+    end
+
+    def slice!(*keys)
+      keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+      omit = slice(*self.keys - keys)
+      hash = slice(*keys)
+      replace(hash)
+      omit
+    end
+  end
+end

data/lib/riak/core_ext/stringify_keys.rb

@@ -0,0 +1,10 @@
+unless {}.respond_to? :stringify_keys
+  class Hash
+    def stringify_keys
+      inject({}) do |hash, pair| 
+        hash[pair[0].to_s] = pair[1]
+        hash
+      end
+    end
+  end
+end

data/lib/riak/core_ext/symbolize_keys.rb

@@ -0,0 +1,10 @@
+unless {}.respond_to? :symbolize_keys
+  class Hash
+    def symbolize_keys
+      inject({}) do |hash, pair| 
+        hash[pair[0].to_sym] = pair[1]
+        hash
+      end
+    end
+  end
+end

data/lib/riak/core_ext/to_param.rb

@@ -0,0 +1,31 @@
+unless Object.new.respond_to? :to_query and Object.new.respond_to? :to_param
+  class Object
+    def to_param
+      to_s
+    end
+
+    def to_query(key)
+      require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+      "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
+    end
+  end
+
+  class Array
+    def to_param
+      map(&:to_param).join('/')
+    end
+
+    def to_query(key)
+      prefix = "#{key}[]"
+      collect { |value| value.to_query(prefix) }.join '&'
+    end
+  end
+
+  class Hash
+    def to_param(namespace = nil)
+      collect do |key, value|
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end.sort * '&'
+    end
+  end
+end