riak-client 0.9.8 → 1.0.0.beta

data/lib/riak/node/log.rb

@@ -0,0 +1,34 @@
+module Riak
+  class Node
+    LAGER_LEVELS = [
+                    :debug,
+                    :info,
+                    :notice,
+                    :warning,
+                    :error,
+                    :critical,
+                    :alert,
+                    :emergency
+                   ]
+
+    def read_console_log(*levels)
+      console_log = log + 'console.log'
+      if console_log.exist?
+        levels = levels.map { |level| expand_log_level(level) }.compact.flatten
+        pattern = /(#{levels.map { |level| "\\[#{level}\\]" }.join("|")})/
+        console_log.readlines.grep(pattern)
+      end
+    end
+
+    def expand_log_level(level)
+      case level
+      when Range
+        first = LAGER_LEVELS.index(level.begin) || 0
+        last = LAGER_LEVELS.index(level.end) || -1
+        LAGER_LEVELS[first..last]
+      when Symbol
+        level
+      end
+    end
+  end
+end

data/lib/riak/node/version.rb

@@ -0,0 +1,37 @@
+require 'pathname'
+
+module Riak
+  class Node
+    def version
+      @version ||= configure_version
+    end
+
+    def configure_version
+      if base_dir
+        versions = (base_dir + 'releases' + 'start_erl.data').read
+        versions.split(" ")[1]
+      end
+    end
+
+    def base_dir
+      @base_dir ||= configure_base_dir
+    end
+
+    def configure_base_dir
+      pattern = /^RUNNER_BASE_DIR=(.*)/
+      lines = control_script.readlines.grep(pattern)
+      if lines.empty?
+        nil
+      else
+        line = lines.first
+        case line
+        when /^RUNNER_BASE_DIR=$\{RUNNER_SCRIPT_DIR%\/*\}/
+          source.parent
+        else
+          path = pattern.match(line)[1]
+          Pathname.new(path).expand_path if File.directory?(path)
+        end
+      end
+    end
+  end
+end

data/lib/riak/robject.rb

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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.
 require 'set'
 require 'time'
 require 'yaml'
@@ -19,12 +6,14 @@ require 'riak/util/escape'
 require 'riak/bucket'
 require 'riak/link'
 require 'riak/walk_spec'
+require 'riak/serializers'
 
 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
 
@@ -52,10 +41,34 @@ module Riak
     # @return [Hash] a hash of any X-Riak-Meta-* headers that were in the HTTP response, keyed on the trailing portion
     attr_accessor :meta
 
+    # @return [Hash<Set>] a hash of secondary indexes, where the
+    #   key is the index name and the value is a Set of index
+    #   entries for that index
+    attr_accessor :indexes
+
     # @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
 
+    def self.on_conflict(&conflict_hook)
+      on_conflict_hooks << conflict_hook
+    end
+
+    def self.on_conflict_hooks
+      @on_conflict_hooks ||= []
+    end
+
+    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
@@ -75,6 +88,7 @@ module Riak
     def initialize(bucket, key=nil)
       @bucket, @key = bucket, key
       @links, @meta = Set.new, {}
+      @indexes = Hash.new {|h,k| h[k] = Set.new }
       yield self if block_given?
     end
 
@@ -103,7 +117,8 @@ module Riak
     # @return [Object] the unmarshaled form of {#raw_data} stored in riak at this object's key
     def data
       if @raw_data && !@data
-        @data = deserialize(@raw_data)
+        raw = @raw_data.respond_to?(:read) ? @raw_data.read : @raw_data
+        @data = deserialize(raw)
         @raw_data = nil
       end
       @data
@@ -112,6 +127,10 @@ module Riak
     # @param [Object] unmarshaled form of the data to be stored in riak. Object will be serialized using {#serialize} if a known content_type is used. Setting this overrides values stored with {#raw_data=}
     # @return [Object] the object stored
     def data=(new_data)
+      if new_data.respond_to?(:read)
+        raise ArgumentError.new(t("invalid_io_object"))
+      end
+
       @raw_data = nil
       @data = new_data
     end
@@ -142,8 +161,7 @@ module Riak
     # @raise [ArgumentError] if the content_type is not defined
     def store(options={})
       raise ArgumentError, t("content_type_undefined") unless @content_type.present?
-      params = {:returnbody => true}.merge(options)
-      @bucket.client.backend.store_object(self, params[:returnbody], params[:w], params[:dw])
+      @bucket.client.store_object(self, options)
       self
     end
 
@@ -158,15 +176,17 @@ module Riak
       force = options.delete(:force)
       return self unless @key && (@vclock || force)
       self.etag = self.last_modified = nil if force
-      bucket.client.backend.reload_object(self, options[:r])
+      bucket.client.reload_object(self, 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, options)
       freeze
     end
@@ -196,17 +216,7 @@ module Riak
     # be done.
     # @param [Object] payload the data to serialize
     def serialize(payload)
-      return payload if payload.respond_to?(:read)
-      case @content_type
-      when /json/
-        payload.to_json(Riak.json_options)
-      when /yaml/
-        YAML.dump(payload)
-      when "application/x-ruby-marshal"
-        Marshal.dump(payload)
-      else
-        payload.to_s
-      end
+      Serializers.serialize(@content_type, payload)
     end
 
     # Deserializes the internal object data from a Riak response. Differs based on the content-type.
@@ -217,21 +227,12 @@ module Riak
     # * Marshal (application/x-ruby-marshal)
     # @param [String] body the serialized response body
     def deserialize(body)
-      case @content_type
-      when /json/
-        JSON.parse(body, Riak.json_options)
-      when /yaml/
-        YAML.load(body)
-      when "application/x-ruby-marshal"
-        Marshal.load(body)
-      else
-        body
-      end
+      Serializers.deserialize(@content_type, body)
     end
 
     # @return [String] A representation suitable for IRB and debugging output
     def inspect
-      body = if @data || content_type =~ /json|yaml|marshal/
+      body = if @data || Serializers[content_type]
                data.inspect
              else
                @raw_data && "(#{@raw_data.size} bytes)"
@@ -257,7 +258,7 @@ module Riak
     # If the key is blank, the bucket URL will be returned (where the object will be
     # submitted to when stored).
     def url
-      segments = [ @bucket.client.prefix, escape(@bucket.name)]
+      segments = [ @bucket.client.http_paths[:prefix], escape(@bucket.name)]
       segments << escape(@key) if @key
       @bucket.client.http.path(*segments).to_s
     end
@@ -265,12 +266,15 @@ module Riak
     alias :vector_clock :vclock
     alias :vector_clock= :vclock=
 
-      protected
+    protected
     def load_map_reduce_value(hash)
       metadata = hash['metadata']
       extract_if_present(metadata, 'X-Riak-VTag', :etag)
       extract_if_present(metadata, 'content-type', :content_type)
       extract_if_present(metadata, 'X-Riak-Last-Modified', :last_modified) { |v| Time.httpdate( v ) }
+      extract_if_present(metadata, 'index', :indexes) do |entries|
+        Hash[ entries.map {|k,v| [k, Set.new(Array(v))] } ]
+      end
       extract_if_present(metadata, 'Links', :links) do |links|
         Set.new( links.map { |l| Link.new(*l) } )
       end

data/lib/riak/search.rb

@@ -1,162 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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.
+require 'riak'
 
-require 'riak/json'
-require 'riak/client'
-require 'riak/bucket'
-require 'riak/map_reduce'
-require 'builder' # Needed to generate Solr XML
-
-module Riak
-  class Client
-    # @return [String] The URL path prefix to the Solr HTTP endpoint
-    attr_accessor :solr
-
-    # @private
-    alias :initialize_core :initialize
-    # @option options [String] :solr ('/solr') The URL path prefix to the Solr HTTP endpoint
-    def initialize(options={})
-      self.solr = options.delete(:solr) || "/solr"
-      initialize_core(options)
-    end
-
-    # 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
-
-    # 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
-
-    # 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
-
-  class Bucket
-    # The precommit specification for kv/search integration
-    SEARCH_PRECOMMIT_HOOK = {"mod" => "riak_search_kv_hook", "fun" => "precommit"}
-
-    # Installs a precommit hook that automatically indexes objects
-    # into riak_search.
-    def enable_index!
-      unless is_indexed?
-        self.props = {"precommit" => (props['precommit'] + [SEARCH_PRECOMMIT_HOOK])}
-      end
-    end
-
-    # Removes the precommit hook that automatically indexes objects
-    # into riak_search.
-    def disable_index!
-      if is_indexed?
-        self.props = {"precommit" => (props['precommit'] - [SEARCH_PRECOMMIT_HOOK])}
-      end
-    end
-
-    # Detects whether the bucket is automatically indexed into
-    # riak_search.
-    # @return [true,false] whether the bucket includes the search indexing hook
-    def is_indexed?
-      props['precommit'].include?(SEARCH_PRECOMMIT_HOOK)
-    end
-  end
-
-  class MapReduce
-    # Use a search query to start a map/reduce job.
-    # @param [String, Bucket] bucket the bucket/index to search
-    # @param [String] query the query to run
-    # @return [MapReduce] self
-    def search(bucket, query)
-      bucket = bucket.name if bucket.respond_to?(:name)
-      @inputs = {:module => "riak_search", :function => "mapred_search", :arg => [bucket, query]}
-      self
-    end
-  end
-end
+warn Riak.t('deprecated.search', :backtrace => "    "+caller.join("\n    "))

data/lib/riak/serializers.rb

@@ -0,0 +1,74 @@
+module Riak
+  module Serializers
+    include Util::Translation
+    extend self
+
+    def [](content_type)
+      serializers[content_type]
+    end
+
+    def []=(content_type, serializer)
+      serializers[content_type] = serializer
+    end
+
+    def serialize(content_type, content)
+      serializer_for(content_type).dump(content)
+    end
+
+    def deserialize(content_type, content)
+      serializer_for(content_type).load(content)
+    end
+
+    private
+
+    def serializer_for(content_type)
+      serializers.fetch(content_type) do
+        raise NotImplementedError.new(t('serializer_not_implemented', :content_type => content_type.inspect))
+      end
+    end
+
+    def serializers
+      @serializers ||= {}
+    end
+
+    module TextPlain
+      extend self
+
+      def dump(object)
+        object.to_s
+      end
+
+      def load(string)
+        string
+      end
+    end
+
+    module ApplicationJSON
+      extend self
+
+      def dump(object)
+        object.to_json(Riak.json_options)
+      end
+
+      def load(string)
+        Riak::JSON.parse(string)
+      end
+    end
+
+    Serializers['text/plain'] = TextPlain
+    Serializers['application/json'] = ApplicationJSON
+    Serializers['application/x-ruby-marshal'] = ::Marshal
+
+    YAML_MIME_TYPES = %w[
+      text/yaml
+      text/x-yaml
+      application/yaml
+      application/x-yaml
+    ]
+
+    YAML_MIME_TYPES.each do |mime_type|
+      Serializers[mime_type] = ::YAML
+    end
+  end
+end
+