riakpb 0.1.3 → 0.1.4

data/README.rdoc

@@ -88,6 +88,38 @@ This is a work in progress and I am current improving the rspec and the document
   => #<#Riak::RiakContent value={"Date"=>Mon, 12 Apr 2010, "Open"=>"567.35", "High"=>"574.00", "Low"=>"566.22", "Close"=>"572.73", "Volume"=>"2352400", "Adj Close"=>"572.73"}, content_type="application/json", vtag="264RmLHrCK89zvhtq4n6Fj", links=[], last_mod=1276389859, last_mod_usecs=810556, usermeta={}>
   >> 
 
+=== Junkshot: (Siblings)
+
+  >> client = Riak::Client.new
+  => #<Riak::Client:0x00000100d2b998 @host="127.0.0.1", @port=8087, @w=nil, @dw=nil, @buckets=[], @bucket_cache={}>
+  >> bucket = client["goog2"]
+  => #<Riak::Bucket name=goog2, props={n_val=>3, allow_mult=false}>
+  >> bucket.allow_mult = true
+  => true
+  >> client.junkshot "goog2", "2010-04-12", {:links => {"tomorrow" => ["goog2", "2010-04-13"]}}
+  => content {
+    value: ""
+    vtag: "3jfZii80dgtSPYbZ6CL1PU"
+    links {
+      bucket: "goog2"
+      key: "2010-04-13"
+      tag: "tomorrow"
+    }
+    last_mod: 1276715503
+    last_mod_usecs: 980712
+  }
+  content {
+    value: "{\"Date\":\"2010-04-12\",\"Open\":\"567.35\",\"High\":\"574.00\",\"Low\":\"566.22\",\"Close\":\"572.73\",\"Volume\":\"2352400\",\"Adj Close\":\"572.73\"}"
+    content_type: "application/json"
+    vtag: "2UplDRmlJaxS1rhn0GNgqN"
+    last_mod: 1276651742
+    last_mod_usecs: 417836
+  }
+  vclock: "k\xCEa``\xE0\xCA`\xCA\x05R,\xCC_s\xBEd0%2\xE5\xB12<^\xDAq\x94\x0F&|`\xF6n\xA00#P\xF8\xDE\x92\x1E\x980[s\x12S\x1F\xCBU\xA8\xC4\xA4\xC9\xBDp\xF5\xEC<\x8B\x0F`\n\x03\xD5\xB3\xE9x\x9C\x85Jh\xCE@\xA8g\xCE\xB00\xC3\x14\x06\xAAg\xBF\xB9\xE5\x14TBq\x0EB=\xD3u\xE7r,\xC2\x8C\xAB\xDC\xEFA\x85\xDF\xCFE6\x865.'\bY\"\v\x00"
+
+  >> 
+
+
 === MapReduce:
 
 I'm working on ways to simplify M/R requests.  It works the same as in ripple.  Largely because it's ripped off from it, with very few changes (so far).

data/lib/riak/bucket.rb

@@ -29,11 +29,11 @@ module Riak
       raise ArgumentError, t("client_type", :client => client.inspect)  unless client.is_a?(Client)
       raise ArgumentError, t("string_type", :string => name.inspect)    unless name.is_a?(String)
 
-      @client     = client
-      @name       = name
-      @n_val      = options[:n_val]       || nil
-      @allow_mult = options[:allow_mult]  || nil
-      @key_cache  = Hash.new{|k,v| k[v] = Riak::Key.new(self, v)}
+      @client           = client
+      @name             = name
+      self.n_val      ||= options[:n_val]
+      self.allow_mult ||= options[:allow_mult]
+      @key_cache        = Hash.new{|k,v| k[v] = Riak::Key.new(self, v)}
     end
 
     # Load information for the bucket from a response given by the {Riak::Client::HTTPBackend}.
@@ -42,12 +42,13 @@ module Riak
     # @return [Bucket] self
     # @see Client#bucket
     def load(response)
-      raise ArgumentError, t("response_type") unless response.is_a?(Riak::RpbGetBucketResp)
+      if response.is_a?(Riak::RpbGetBucketResp)
+        @n_val      = response.props.n_val
+        @allow_mult = response.props.allow_mult
 
-      self.n_val      = response.props.n_val
-      self.allow_mult = response.props.allow_mult
-
-      return(self)
+        return(self)
+      end
+      raise ArgumentError, t("response_type")
     end
 
     # Accesses or retrieves a list of keys in this bucket.  Needs to have expiration / cacheing, though not now.
@@ -86,7 +87,7 @@ module Riak
     # @return [Riak::Key] the object
     def key!(key, r=nil)
       raise ArgumentError, t("string_invalid", :string  => key) unless key.is_a?(String)
-      raise ArgumentError, t("fixnum_invalid", :num     => r)   unless r.is_a?(Fixnum)
+      raise ArgumentError, t("fixnum_invalid", :num     => r)   unless r.is_a?(Fixnum) or r.nil?
 
       response = @client.get_request @name, key, r
 
@@ -113,6 +114,22 @@ module Riak
       @client.put_request(options)
     end
 
+    def junkshot(key, params)
+      raise RuntimeError.new t('siblings_disallowed') unless @allow_mult == true
+
+      params[:links]    = parse_links(params[:links])     if params.has_key?(:links)
+      params[:usermeta] = parse_links(params[:usermeta])  if params.has_key?(:usermeta)
+
+      options           = params.slice :return_body, :w, :dw
+      content           = params.slice :value, :content_type, :charset, :content_encoding, :links, :usermeta
+
+      key               = key.name if key.is_a?(Riak::Key)
+      options[:key]     = key
+      options[:content] = Riak::RpbContent.new(content)
+
+      self.store(options)
+    end
+
     # Deletes a key from the bucket
     # @param [String] key the key to delete
     # @param [Hash] options quorum options
@@ -144,9 +161,15 @@ module Riak
     # Set the allow_mult property.  *NOTE* This will result in a PUT request to Riak.
     # @param [true, false] value whether the bucket should allow siblings
     def allow_mult=(value)
-      return(@allow_mult = value) if value.is_a?(TrueClass) or value.is_a?(FalseClass)
-
-      raise ArgumentError, t("boolean_type")
+      case value
+      when true, false
+        @client.set_bucket(self.name, {:n_val => @n_val, :allow_mult => value})
+        return(@allow_mult = value)
+      when nil, ''
+        return(@allow_mult = nil)
+      else
+        raise ArgumentError, t("boolean_type")
+      end
     end
 
     # @return [Fixnum] the N value, or number of replicas for this bucket
@@ -158,9 +181,15 @@ module Riak
     # Saving this value after the bucket has objects stored in it may have unpredictable results.
     # @param [Fixnum] value the number of replicas the bucket should keep of each object
     def n_val=(value)
-      raise ArgumentError, t("fixnum_type", :value => value) unless value.is_a?(Fixnum)
-
-      @n_val = value
+      case value
+      when Fixnum
+        @client.set_bucket(self.name, {:n_val => value, :allow_mult => @allow_mult})
+        return(@n_val = value)
+      when nil, ''
+        return(@n_val = nil)
+      else
+        raise ArgumentError, t("fixnum_type", :value => value)
+      end
     end
 
     # @return [String] a representation suitable for IRB and debugging output
@@ -173,5 +202,30 @@ module Riak
       "#<Riak::Bucket name=#{@name}, props={n_val=>#{@n_val}, allow_mult=#{@allow_mult}}, keys=#{keys.inspect}>"
     end
 
+    private
+    def parse_links(link_params)
+      rpb_links = []
+
+      link_params.each do |tag, links|
+        pb_link         = Riak::RpbLink.new
+        pb_link.tag     = tag
+        pb_link.bucket  = links[0]
+        pb_link.key     = links[1]
+        rpb_links      << pb_link
+      end
+      return(rpb_links)
+    end # parse_links
+
+    def parse_meta(meta_params)
+      rpb_meta = []
+
+      meta_params.each do |k,v|
+        pb_meta       = Riak::RpbPair.new
+        pb_meta.key   = k
+        pb_meta.value = v
+        rpb_meta     << pb_meta
+      end
+      return(rpb_meta)
+    end
   end
 end

data/lib/riak/client/rpc.rb

@@ -19,10 +19,12 @@ module Riak
       attr_reader :req_message, :response, :resp_message_codes, :resp_message, :status
 
       # Establishes a Client ID with the Riak node, for the life of the RPC connection.
-      # @param [Client] the Riak::Client object in which this Rpc instance lives
-      def initialize(client)
+      # @param [Client] client the Riak::Client object in which this Rpc instance lives
+      # @param [Fixnum] limit the max size of an individual TCPSocket receive call.  Need to fix, later.
+      def initialize(client, limit=RECV_LIMIT)
         @status             = false
         @client             = client
+        @limit              = limit
         @client_id          = request(Util::MessageCode::GET_CLIENT_ID_REQUEST).client_id
         @set_client_id      = Riak::RpbSetClientIdReq.new(:client_id => @client_id)
 
@@ -65,7 +67,7 @@ module Riak
                                                 @set_client_id.serialize_to_string)
 
         socket.send(@set_c_id_req, 0)
-        set_c_id_resp       = socket.recv(RECV_LIMIT)
+        set_c_id_resp       = socket.recv(@limit)
 
         resp_code, resp_msg = decode_message(set_c_id_resp)
 
@@ -84,10 +86,14 @@ module Riak
 
         with_socket do |socket|
           begin
-            @req_message  = assemble_request mc, (pb_msg.serialize_to_string rescue '')
+            begin
+              @req_message  = assemble_request mc, pb_msg.serialize_to_string
+            rescue NoMethodError
+              @req_message  = assemble_request mc
+            end
 
             socket.send(@req_message, 0)
-            self.response = socket.recv(RECV_LIMIT)
+            self.response = socket.recv(@limit)
 
           end while(false == (@response.done rescue true))
         end # with_socket

data/lib/riak/client.rb

@@ -99,17 +99,48 @@ module Riak
     # I need bucket!  Bring me bucket! (Retrieves a bucket from Riak.  Eating disorder not included.)
     # @param [String] bucket the bucket to retrieve
     # @return [Bucket] the requested bucket
-    def bring_me_bucket(bucket)
+    def bucket(bucket)
+      return(@bucket_cache[bucket]) if @bucket_cache.has_key?(bucket)
+      bring_me_bucket!(bucket)
+    end
+    alias :[]               :bucket
+    alias :bring_me_bucket  :bucket
+
+    # I need bucket!  Bring me bucket! (Retrieves a bucket from Riak, even if it's already been retrieved.)
+    # @param [String] bucket the bucket to retrieve
+    # @return [Bucket] the requested bucket
+    def bucket!(bucket)
       request       = Riak::RpbGetBucketReq.new(:bucket => bucket)
       response      = rpc.request(
                         Util::MessageCode::GET_BUCKET_REQUEST,
                         request
                       )
-
       @bucket_cache[bucket].load(response)
     end
-    alias :[]     :bring_me_bucket
-    alias :bucket :bring_me_bucket
+    alias :bring_me_bucket! :bucket!
+
+    # Set the properties for a given bucket, and then reload it.
+    # @param [String] bucket the bucket name in which props will be set
+    # @param [RpbBucketProps, Hash] props the properties to be set within the given bucket
+    # @return [TrueClass, FalseClass] whether or not the operation was successful
+    def set_bucket(bucket, props)
+      props = Riak::RpbBucketProps.new(props) if props.is_a?(Hash)
+
+      raise TypeError.new t('invalid_props') unless props.is_a?(Riak::RpbBucketProps)
+
+      begin
+        request       = Riak::RpbSetBucketReq.new(:bucket => bucket, :props => props)
+        response      = rpc.request(
+                          Util::MessageCode::SET_BUCKET_REQUEST,
+                          request
+                        )
+        self.bucket!(bucket)
+
+        return(true)
+      rescue FailedRequest
+        return(false)
+      end
+    end
 
     # Retrieves a key, using RpbGetReq, from within a given bucket, from Riak.
     # @param [String] bucket the bucket from which to retrieve the key
@@ -144,7 +175,6 @@ module Riak
       options[:return_body] ||= true
 
       request   = Riak::RpbPutReq.new(options)
-
       response  = rpc.request(
                     Util::MessageCode::PUT_REQUEST,
                     request
@@ -204,7 +234,6 @@ module Riak
     # @raise [ReturnRespError] if the message response does not correlate with the message requested
     # @return [Hash] Mapping of the buckets (String) to their keys (Array of Strings)
     def keys_in(bucket)
-
       list_keys_request = RpbListKeysReq.new(:bucket => bucket)
 
       response = rpc.request Util::MessageCode::LIST_KEYS_REQUEST, list_keys_request
@@ -217,6 +246,37 @@ module Riak
 #        "#<Client >"
 #      end
 
+    # Junkshot lets you throw a lot of data at riak, which will then need to be reconciled later
+    # @overload junkshot(bucket, key, params)
+    #   @param [String] bucket the name of the bucket
+    #   @param [String] key the name of the key
+    #   @param [Hash] params the parameters that are to be updated (Needs fixin')
+    # @overload junkshot(key, params)
+    #   @param [Key] key the Key instance to be junkshotted
+    #   @param [Hash] params the parameters that are to be updated (Needs fixin')
+    # @return [String, Key] dependent upon whether :return_body is set to true or false
+    def junkshot(*params)
+      params = params.dup.flatten
+      case params.size
+      when 3
+        bucket  = params[0]
+        key     = params[1]
+        params  = params[2]
+      when 2
+        begin
+          key     = params[0]
+          bucket  = key.bucket
+          key     = key.name
+        rescue NoMethodError
+          raise TypeError.new t('invalid_key')
+        end
+        params  = params[1]
+      end
+      self.bucket!(bucket).junkshot(key, params)
+    end
+    alias :stuff  :junkshot
+    alias :jk     :junkshot
+
     private
     def b64encode(n)
       Base64.encode64([n].pack("N")).chomp

data/lib/riak/client_pb.rb

@@ -343,7 +343,7 @@ module Riak
   end
   class RpbContent < ::Protobuf::Message
     defined_in __FILE__
-    required :bytes, :value, 1
+    optional :bytes, :value, 1
     optional :bytes, :content_type, 2
     optional :bytes, :charset, 3
     optional :bytes, :content_encoding, 4

data/lib/riak/key.rb

@@ -46,7 +46,7 @@ module Riak
 
       if response.has_field?(:content)
         self.content    = response.content
-      elsif @contents.empty?
+      elsif @contents.blank?
         @contents[:new]
       end
 
@@ -79,7 +79,7 @@ module Riak
     # Indicates whether or not the Key is empty
     # @return [Boolean] true or false, whether or not the vclock/content is empty
     def empty?
-      return(true) if @vclock.empty? && (@contents.nil? || @contents.empty?)
+      return(true) if @vclock.blank? && @contents.nil?
       return(false)
     end
 

data/lib/riak/locale/en.yml

@@ -4,7 +4,8 @@ en:
     string_type: "invalid_argument {{string}} is not a String"
     loading_bucket: "while loading bucket '{{name}}'"
     invalid_bucket: "the specified bucket is invalid"
-    invalid_key: "the specified key does not exist"
+    invalid_key: "the specified key is invalid or does not exist"
+    siblings_disallowed: "the specified bucket does not allow siblings.  Set allow_mult in props to do this."
     value_empty: "a value must be set in order to serialize into a protocol buffer"
     failed_request: "Expected message code {{expected}} from Riak but received {{actual}}. {{output}}"
     decode_error: "Riak reported a message length of {{expected}} but length was {{actual}}. {{output}}"

data/lib/riak/riak_content.rb

@@ -138,6 +138,7 @@ module Riak
         end
       end # tags.each do |tag, link|
     end
+    alias :link :link_key
 
     # Set the links to other Key in riak.
     # @param [RpbGetResp, RpbPutResp] contains the tag/bucket/key of a given link
@@ -193,8 +194,8 @@ module Riak
       rpb_content.charset           = @charset          unless @charset.nil? # || @charset.empty?
       rpb_content.content_encoding  = @content_encoding unless @content_encoding.nil? # || @content_encoding.empty?
       rpb_content.vtag              = @vtag             unless @vtag.nil?
-      rpb_content.links             = rpb_links         unless rpb_links.empty?
-      rpb_content.usermeta          = usermeta          unless usermeta.empty?
+      rpb_content.links             = rpb_links         unless rpb_links.nil?
+      rpb_content.usermeta          = usermeta          unless usermeta.nil?
 
       return(rpb_content)
     end

data/lib/riak.rb

@@ -9,7 +9,7 @@ require 'base64'
 require 'riak/client_pb'
 
 module Riak
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 
   # Domain objects
   autoload :I18n,             'riak/i18n'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Scott Gonyea
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-14 00:00:00 -07:00
+date: 2010-06-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency