riak-client-noenc 1.0.0

data/lib/riak/robject.rb

@@ -0,0 +1,222 @@
+require 'forwardable'
+require 'riak/rcontent'
+require 'riak/conflict'
+require 'riak/util/translation'
+require 'riak/util/escape'
+require 'riak/bucket'
+require 'riak/link'
+require 'riak/walk_spec'
+
+module Riak
+  # Represents the data and metadata stored in a bucket/key pair in
+  # the Riak database, the base unit of data manipulation.
+  class RObject
+    include Util::Translation
+    extend Util::Translation
+    include Util::Escape
+    extend Util::Escape
+    extend Forwardable
+
+    # @return [Bucket] the bucket in which this object is contained
+    attr_accessor :bucket
+
+    # @return [String] the key of this object within its bucket
+    attr_accessor :key
+
+    # @return [String] the Riak causal context/vector clock for the object
+    attr_accessor :vclock
+
+    alias :causal_context :vclock
+    alias :causal_context= :vclock=
+    alias :vector_clock :vclock
+    alias :vector_clock= :vclock=
+
+    # @return [Boolean] whether to attempt to prevent stale writes using
+    #   conditional PUT semantics, If-None-Match: * or If-Match: etag
+    # @see http://wiki.basho.com/display/RIAK/REST+API#RESTAPI-Storeaneworexistingobjectwithakey Riak Rest API Docs
+    attr_accessor :prevent_stale_writes
+
+    # Defines a callback to be invoked when there is conflict.
+    #
+    # @yield The conflict callback.
+    # @yieldparam [RObject] robject The conflicted RObject
+    # @yieldreturn [RObject, nil] Either the resolved RObject or nil if your
+    #                             callback cannot resolve it. The next registered
+    #                             callback will be given the chance to resolve it.
+    #
+    # @note Ripple registers its own document-level conflict handler, so if you're
+    #       using ripple, you will probably want to use that instead.
+    def self.on_conflict(&conflict_hook)
+      on_conflict_hooks << conflict_hook
+    end
+
+    # @return [Array<Proc>] the list of registered conflict callbacks.
+    def self.on_conflict_hooks
+      @on_conflict_hooks ||= []
+    end
+
+    def_delegators :content, :content_type, :content_type=,
+              :links, :links=,
+              :etag, :etag=,
+              :last_modified, :last_modified=,
+              :meta, :meta=,
+              :indexes, :indexes=,
+              :data, :data=,
+              :raw_data, :raw_data=,
+              :deserialize, :serialize
+
+    # Attempts to resolve conflict using the registered conflict callbacks.
+    #
+    # @return [RObject] the RObject
+    # @note There is no guarantee the returned RObject will have been resolved
+    def attempt_conflict_resolution
+      return self unless conflict?
+
+      self.class.on_conflict_hooks.each do |hook|
+        result = hook.call(self)
+        return result if result.is_a?(RObject)
+      end
+
+      self
+    end
+
+    # Loads a list of RObjects that were emitted from a MapReduce
+    # query.
+    # @param [Client] client A Riak::Client with which the results will be associated
+    # @param [Array<Hash>] response A list of results a MapReduce job. Each entry should contain these keys: bucket, key, vclock, values
+    # @return [Array<RObject>] An array of RObject instances
+    def self.load_from_mapreduce(client, response)
+      response.map do |item|
+        RObject.new(client[unescape(item['bucket'])], unescape(item['key'])).load_from_mapreduce(item)
+      end
+    end
+
+    # Create a new object manually
+    # @param [Bucket] bucket the bucket in which the object exists
+    # @param [String] key the key at which the object resides. If nil, a key will be assigned when the object is saved.
+    # @yield self the new RObject
+    # @see Bucket#get
+    def initialize(bucket, key = nil)
+      @bucket, @key = bucket, key
+
+      # fix a require-loop
+      require 'riak/bucket_typed/bucket'
+
+      if @bucket.is_a? BucketTyped::Bucket
+        @type = @bucket.type.name
+      end
+      @siblings = [ RContent.new(self) ]
+      yield self if block_given?
+    end
+
+    # Load object data from a map/reduce response item.
+    # This method is used by RObject::load_from_mapreduce to instantiate the
+    # necessary objects.
+    # @param [Hash] response a response from {Riak::MapReduce}
+    # @return [RObject] self
+    def load_from_mapreduce(response)
+      self.vclock = response['vclock']
+      @siblings = response['values'].map do |v|
+        RContent.new(self) do |rcontent|
+          rcontent.load_map_reduce_value(v)
+        end
+      end
+      self
+    end
+
+    # Store the object in Riak
+    # @param [Hash] options query parameters
+    # @option options [Fixnum] :r the "r" parameter (Read quorum for the
+    #   implicit read performed when validating the store operation)
+    # @option options [Fixnum] :w the "w" parameter (Write quorum)
+    # @option options [Fixnum] :dw the "dw" parameter (Durable-write quorum)
+    # @option options [Boolean] :returnbody (true) whether to return the result
+    #   of a successful write in the body of the response. Set to false for
+    #   fire-and-forget updates, set to true to immediately have access to the
+    #   object's stored representation.
+    # @return [Riak::RObject] self
+    # @raise [ArgumentError] if the content_type is not defined
+    # @raise [Conflict] if the object has siblings
+    def store(options = {})
+      fail Conflict, self if conflict?
+      fail ArgumentError, t('content_type_undefined') unless content_type.present?
+      fail ArgumentError, t('zero_length_key') if key == ''
+      @bucket.client.store_object(self, default(options))
+      self
+    end
+
+    # Reload the object from Riak.  Will use conditional GETs when possible.
+    # @param [Hash] options query parameters
+    # @option options [Fixnum] :r the "r" parameter (Read quorum)
+    # @option options [Boolean] :force will force a reload request if
+    #     the vclock is not present, useful for reloading the object after
+    #     a store (not passed in the query params)
+    # @return [Riak::RObject] self
+    def reload(options = {})
+      force = options.delete(:force)
+      return self unless @key && (@vclock || force)
+      self.etag = self.last_modified = nil if force
+      bucket.client.reload_object(self, default(options))
+    end
+
+    alias :fetch :reload
+
+    # Delete the object from Riak and freeze this instance.  Will work whether or not the object actually
+    # exists in the Riak database.
+    # @see Bucket#delete
+    def delete(options = {})
+      return if key.blank?
+      options[:vclock] = vclock if vclock
+      @bucket.delete(key, default(options))
+      freeze
+    end
+
+    # Returns sibling values. If the object is not in conflict, then
+    # only one value will be present in the array.
+    # @return [Array<RContent>] an array of conflicting sibling values
+    #   for this key, possibly containing only one
+    attr_accessor :siblings
+
+    # Returns the solitary sibling when not in conflict.
+    # @return [RContent] the sole value/sibling on this object
+    # @raise [Conflict] when multiple siblings are present
+    def content
+      raise Conflict, self if conflict?
+      @siblings.first
+    end
+
+    # @return [true,false] Whether this object has conflicting sibling objects (divergent vclocks)
+    def conflict?
+      @siblings.size != 1
+    end
+
+    # @return [String] A representation suitable for IRB and debugging output
+    def inspect
+      body = @siblings.map {|s| s.inspect }.join(", ")
+      "#<#{self.class.name} {#{bucket.name}#{"," + @key if @key}} [#{body}]>"
+    end
+
+    # Converts the object to a link suitable for linking other objects
+    # to it
+    # @param [String] tag the tag to apply to the link
+    def to_link(tag)
+      Link.new(@bucket.name, @key, tag)
+    end
+
+    # Retrieves a preflist for this RObject; useful for
+    # figuring out where in the cluster it is stored.
+    # @return [Array<PreflistItem>] an array of preflist entries
+    def preflist(options = {})
+      bucket.get_preflist key, options
+    end
+
+    private
+
+    def default(options)
+      return options unless options.is_a? Hash
+      return options unless @type
+
+      {type: @type}.merge options
+    end
+  end
+end

data/lib/riak/search.rb

@@ -0,0 +1,11 @@
+module Riak
+  module Search
+  end
+end
+
+require 'riak/search/index'
+require 'riak/search/query'
+require 'riak/search/result_collection'
+require 'riak/search/result_document'
+require 'riak/search/schema'
+require 'riak/errors/search_error'

data/lib/riak/search/index.rb

@@ -0,0 +1,87 @@
+require 'riak/search'
+require 'riak/errors/search_error'
+
+module Riak::Search
+  # A {Riak::Search::Index} is how Solr finds documents in Riak Search 2. A
+  # bucket or bucket type property must be configured to use the index in order
+  # for new and updated documents to be indexed and searchable.
+  class Index
+    # @!attribute [r] name
+    # @return [String] the name of the index
+    attr_reader :name
+
+    # @!attribute [r] client
+    # @return [Riak::Client] the client to operate on the index with
+    attr_reader :client
+
+    # Initializes an index object, that may or may not exist.
+    #
+    # @param [Riak::Client] client the client connected to the Riak cluster
+    #   you wish to operate on
+    # @param [String] name the name of the index
+    def initialize(client, name)
+      @client = client
+      @name = name
+    end
+
+    # @return [Boolean] does this index exist on Riak?
+    def exists?
+      !!index_data
+    end
+
+    # @return [Integer] N-value/replication parameter of this index
+    def n_val
+      index_data[:n_val]
+    end
+
+    # @return [String] schema name of this index
+    def schema
+      index_data[:schema]
+    end
+
+    # Attempt to create this index
+    #
+    # @raise [Riak::SearchError::IndexExistsError] if an index with the given
+    #   name already exists
+    def create!(schema = nil, n_val = nil, timeout = nil)
+      raise Riak::SearchError::IndexExistsError.new name if exists?
+
+      @client.backend do |b|
+        b.create_search_index name, schema, n_val, timeout
+      end
+
+      @index_data = nil
+
+      true
+    end
+
+    # Create a {Riak::Search::Query} using this index and client
+    #
+    # @param [String] term the query term
+    # @param [Hash] options a hash of options to set attributes on the query
+    # @return [Riak::Search::Query] a query using this index
+    def query(term, options = {  })
+      Riak::Search::Query.new(@client, self, term, options)
+    end
+
+    private
+    def index_data
+      return @index_data if defined?(@index_data) && @index_data
+
+      id = nil
+
+      begin
+        id = @client.backend do |b|
+          b.get_search_index name
+        end.index
+      rescue Riak::ProtobuffsFailedRequest => e
+        return nil if e.not_found?
+        raise e
+      end
+
+      id = id.first if id.is_a? Array
+
+      return @index_data = id
+    end
+  end
+end

data/lib/riak/search/query.rb

@@ -0,0 +1,141 @@
+require 'riak/search'
+
+module Riak::Search
+  # A {Riak::Search::Query} wraps a Solr query for Riak Search 2.
+  class Query
+
+    # @!attribute rows
+    # @return [Numeric] the number of rows to return from the query
+    attr_accessor :rows
+
+    # @!attribute start
+    # @return [Numeric] the offset into the total result set to get results for
+    attr_accessor :start
+
+    # @!attribute sort
+    # @return [String] how Solr should sort the result set
+    attr_accessor :sort
+
+    # @!attribute filter
+    # @return [String] have Solr filter the results prior to returning them
+    attr_accessor :filter
+
+    # @!attribute df
+    # @return [Array<String>] default fields for Solr to search
+    attr_accessor :df
+
+    # @!attribute op
+    # @return [String] Solr search operator
+    attr_accessor :op
+
+    # @!attribute fl
+    # @return [Array<String>] fields for Solr to return
+    attr_accessor :fl
+
+    # @!attribute [r] term
+    # @return [String] the term to query
+    attr_reader :term
+
+    # @!attribute [r] index
+    # @return [Riak::Search::Index] the index to query against
+    attr_reader :index
+
+    # @!attribute [r] client
+    # @return [Riak::Client] the client to query against
+    attr_reader :client
+
+    # Initializes a query object.
+    #
+    # @param [Riak::Client] client the client connected to the Riak cluster
+    # @param [String,Riak::Search::Index] index the index to query, either a
+    #   {Riak::Search::Index} instance or a {String}
+    # @param [String] term the query term
+    # @param [Hash] options a hash of options to quickly set attributes
+    def initialize(client, index, term, options = {  })
+      @client = client
+      validate_index index
+      @term = term
+      @options = options.symbolize_keys
+
+      set_defaults
+      consume_options
+    end
+
+    # Get results from the query. Performs the query when called the first time.
+    #
+    # @return [Riak::Search::ResultCollection] collection of results
+    def results
+      return @results if defined? @results
+
+      @results = ResultCollection.new @client, raw_results
+    end
+
+    private
+
+    def index_name
+      return @index if @index.is_a? String
+      return @index.name
+    end
+
+    def validate_index(index)
+      if index.is_a? String
+        index = Riak::Search::Index.new @client, index
+      end
+
+      unless index.is_a? Riak::Search::Index
+        raise Riak::SearchError::IndexArgumentError.new index
+      end
+
+      unless index.exists?
+        raise Riak::SearchError::IndexNonExistError.new index.name
+      end
+
+      @index = index
+    end
+
+    def set_defaults
+      @rows = nil
+      @start = nil
+
+      @sort = nil
+      @filter = nil
+
+      @df = %w{text}
+      @op = nil
+      @fl = %w{_yz_rb _yz_rk _yz_rt score}
+
+      @presort = nil
+    end
+
+    def consume_options
+      @rows = @options[:rows] if @options[:rows]
+      @start = @options[:start] if @options[:start]
+
+      @sort = @options[:sort] if @options[:sort]
+      @filter = @options[:filter] if @options[:filter]
+
+      @df = @options[:df] if @options[:df]
+      @op = @options[:op] if @options[:op]
+      @fl = @options[:fl] if @options[:fl]
+    end
+
+    def prepare_options
+      configured_options = {
+        rows: @rows,
+        start: @start,
+        sort: @sort,
+        filter: @filter,
+        df: @df.join(' '),
+        op: @op,
+        fl: @fl
+      }
+      @options.merge configured_options
+    end
+
+    def raw_results
+      @client.backend do |be|
+        be.search index_name, @term, prepare_options
+      end
+    end
+  end
+end