blodsband 0.0.2

data/lib/blodsband/riak/lock.rb

@@ -0,0 +1,68 @@
+
+module Blodsband
+
+  class Riak
+
+    class Lock
+
+      attr_reader :key
+
+      #
+      # Create a new lock in a bucket.
+      #
+      # @param [Blodsband::Riak::Bucket] bucket the bucket in which the lock shall live.
+      # @param [String] key the key to the lock
+      #
+      def initialize(bucket, key)
+        @bucket = bucket
+        @key = key
+      end
+
+      #
+      # Lock this lock, with an optional timeout
+      #
+      # @param [Number] timeout the maximum time to wait for the lock to be available, in seconds.
+      #
+      # @return [true, false] whether we succeeded in locking before the timeout
+      #
+      def lock(timeout = 1 << 256)
+        deadline = Time.now.to_f + timeout
+        while !@bucket.put_if_missing(key, "locked")
+          EM::Synchrony.sleep(0.1)
+          if Time.now.to_f > deadline
+            return false
+          end
+        end
+        return true
+      end
+      
+      #
+      # Unlock this lock
+      #
+      def unlock
+        @bucket.delete(key, :riak_params => {:w => :all})
+        while !@bucket.get(key, :unique => true).nil?
+          EM::Synchrony.sleep(0.1)
+          @bucket.delete(key, :riak_params => {:w => :all})
+        end
+      end
+
+      #
+      # Execute a block while exclusively locking this lock.
+      #
+      # @param [Block] block the block to execute.
+      #
+      def synchronize(&block)
+        lock
+        begin
+          yield
+        ensure
+          unlock
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/blodsband/riak/map.rb

@@ -0,0 +1,143 @@
+
+module Blodsband
+  
+  class Riak
+
+    #
+    # A concurrent map.
+    #
+    class Map < List
+
+      #
+      # @param [Object] key a key to the map.
+      #
+      # @return [Object] the value in this map for the given key.
+      #
+      def [](key)
+        element_key = bucket.get(key_for(key))
+        if element_key.nil?
+          nil
+        else
+          map_key, value = Element.find(self, element_key).value
+          value
+        end
+      end
+
+      #
+      # @param [Array<Object>] keys some keys to check if they exist in this map.
+      #
+      # @return [Hash<Object, Object>] the argument keys that exist in this map and their values.
+      #
+      def retain(keys)
+        bucket.has_many?(keys.collect do |map_key| 
+                           key_for(map_key)
+                         end).collect do |bucket_key|
+          bucket.aget(bucket_key)
+        end.collect do |f|
+          f.get
+        end.collect do |element_key|
+          bucket.aget(element_key)
+        end.collect do |f|
+          f.get
+        end.inject({}) do |sum, element_value|
+          sum.merge(element_value.first => element_value.last)
+        end
+      end
+
+      #
+      # @param [Blodsband::Riak::Map] map a {Blodsband::Riak::Map} to intersect this map with.
+      #
+      # @return [Hash<Object, Object>] the intersection of this map with the argument.
+      #
+      def intersect(map)
+        if size > map.size
+          retain(map.to_a.collect do |k,v|
+                   k
+                 end)
+        else
+          map.retain(to_a.collect do |k,v|
+                       k
+                     end)
+        end
+      end
+
+      #
+      # @param [Object] k a key to this map.
+      #
+      # @return [true, false] whether this map contains the argument.
+      #
+      def include?(k)
+        !bucket.get(key_for(k)).nil?
+      end
+      
+      #
+      # @param [Object] k a key to this map to delete.
+      #
+      # @return [Object] the value for the key, or nil.
+      #
+      def delete(key)
+        element_key = bucket.get(key_for(key))
+        if element_key.nil?
+          nil
+        else
+          element = Element.find(self, element_key)
+          element.delete
+          element.value.last
+        end
+      end
+
+      #
+      # @param [Object] key a key to insert.
+      # @param [Object] value a value to insert.
+      # 
+      # @return [Object] the inserted value.
+      #
+      def []=(key, value)
+        element_key = bucket.get(key_for(key))
+        if element_key.nil?
+          append([key, value])
+        else
+          Element.find(self, element_key).value = [key, value]
+        end
+        value
+      end
+      
+      protected
+
+      def ok_to_add?(new_element)
+        map_key, value = new_element.value
+        bucket.get(key_for(map_key)).nil?
+      end
+
+      def backlog_delete(new_element)
+        map_key, value = new_element.value
+        backlog << [:delete_element_pointer,
+                    map_key]
+      end
+
+      def backlog_add(new_element)
+        map_key, value = new_element.value
+        backlog << [:add_element_pointer,
+                    new_element.key,
+                    map_key]
+      end
+
+      def delete_element_pointer(map_key)
+        bucket.delete(key_for(map_key))
+      end
+
+      def add_element_pointer(new_element_key, map_key)
+        bucket.put(key_for(map_key), new_element_key, :riak_params => {:w => :all})
+      end
+
+      private
+
+      def key_for(map_key)
+        "#{key}_#{Digest::SHA1.hexdigest(Yajl::Encoder.encode(map_key)).to_i(16).to_s(36)}"
+      end
+
+    end
+
+  end
+
+end

data/lib/blodsband/riak/mr.rb

@@ -0,0 +1,103 @@
+
+module Blodsband
+
+  class Riak
+
+    class Mr
+
+      #
+      # Create a new map reduce reference.
+      #
+      # @param [::URI] url a {::URI} pointing to the HTTP port of a Riak node.
+      #
+      def initialize(url)
+        @url = url
+        @inputs = nil
+        @phases = []
+      end
+
+      #
+      # Add inputs to the map reduce.
+      #
+      # @param [Hash<Symbol, Object>] hash the inputs to add. See {http://wiki.basho.com/MapReduce.html#MapReduce-via-the-HTTP-API}.
+      #
+      # @return [Blodsband::Riak::Mr] this {Blodsband::Riak::Mr}.
+      #
+      def inputs(hash)
+        @inputs = hash
+        self
+      end
+
+      #
+      # Add a map phase to the map reduce.
+      #
+      # @param [Hash<Symbol, Object>] hash the map phase to add. See {http://wiki.basho.com/MapReduce.html#MapReduce-via-the-HTTP-API}.
+      #
+      # @return [Blodsband::Riak::Mr] this {Blodsband::Riak::Mr}.
+      #
+      def map(hash)
+        @phases << {"map" => hash}
+        self
+      end
+
+      #
+      # Add a reduce phase to the map reduce.
+      #
+      # @param [Hash<Symbol, Object>] hash the reduce phase to add. See {http://wiki.basho.com/MapReduce.html#MapReduce-via-the-HTTP-API}.
+      #
+      # @return [Blodsband::Riak::Mr] this {Blodsband::Riak::Mr}.
+      #
+      def reduce(hash)
+        @phases << {"reduce" => hash}
+        self
+      end
+
+      #
+      # The body to use in the HTTP request used to execute this map reduce. Mostly for debugging purposes.
+      #
+      # @return [Hash<String, Object>] a {::Hash} to json-encode and send as body when executing the map reduce.
+      #
+      def body
+        {
+          "inputs" => @inputs,
+          "query" => @phases
+        }
+      end
+
+      #
+      # Execute this map reduce.
+      #
+      # @return [Blodsband::Riak::Response] the result of running the map reduce in Riak.
+      #
+      def run
+        arun.get
+      end
+
+      #
+      # {include:Mr#run}
+      #
+      # @return [Blodsband::Future<Blodsband::Riak::Response>] the eventual result of running the map reduce in Riak.
+      #
+      def arun
+        m = Multi.new
+        m.add(:mr, 
+              EM::HttpRequest.new(URI.join(@url.to_s, "mapred")).
+              apost(:head => {
+                      "Content-Type" => "application/json"
+                    },
+                    :body => Yajl::Encoder.encode(body)))
+        return(Future.new do
+                 m.really_perform
+                 if err = m.responses[:errback][:mr]
+                   Error.new(err)
+                 else
+                   Yajl::Parser.parse(m.responses[:callback][:mr].response)
+                 end
+               end)
+      end
+
+    end
+
+  end
+
+end

data/lib/blodsband/riak/response.rb

@@ -0,0 +1,208 @@
+
+module Blodsband
+
+  class Riak
+
+    #
+    # The semi magical class encapsulating responses from Riak. Probably never constructed by API users.
+    #
+    # Will mostly add the following fields to any object including it:
+    #  :status an Integer defining the status of the response. 300 means siblings, for example.
+    #  :links a Hash<String, Array<String>> with riaktags pointing to bucket/key pairs for the links.
+    #  :vclock the vector clock for the fetched value.
+    #  :last_modified when the document was last modified in Riak.
+    #  :key the key the document was found under (when applicable)
+    #  :bucket the name of the bucket the document was found in (when applicable)
+    #  :meta a Hash<String, String> with Riak meta keys pointing to Riak meta values for the document.
+    #
+    module Response
+
+      def self.construct(status, headers, body, options = {})
+        rval = Yajl::Parser.parse(body)
+        class << rval
+          include Response
+        end
+        rval.apply(status, headers, options[:bucket], options[:key])
+        rval
+      end
+
+      def self.parse_multipart(part, options = {})
+        if part["Content-Type"] =~ /multipart\/mixed/ || (part.respond_to?(:multipart?) && part.multipart?)
+          part.parts.collect do |inner_part|
+            parse_multipart(inner_part)
+          end
+        else
+          construct(200, part, part.body.to_s, options)
+        end
+      end
+
+      def self.parse_multipart_response(http, options = {})
+        mailbody = ""
+        http.response_header.each do |k,v|
+          mailbody += "#{k.gsub(/_/, "-")}: #{v}\n"
+        end
+        mailbody += http.response
+        mail = Mail.new(mailbody)
+        mail.parts.collect do |part|
+          parse_multipart(part, options)
+        end
+      end
+
+      def self.parse_response(http, options = {})
+        return nil if http.nil?
+        return nil if http.response_header.status == 404
+        if (http.response_header.status == 200 || 
+            http.response_header.status == 204 || 
+            (http.response_header.status == 300 && http.response_header["Content-Type"] =~ /multipart\/mixed/))
+          if http.response_header["Content-Type"] =~ /multipart\/mixed/
+            rval = parse_multipart_response(http, options)
+            class << rval
+              include Response
+            end
+            rval.apply(http.response_header.status, http.response_header, options[:bucket], options[:key])
+            rval
+          else
+            construct(http.response_header.status,
+                      http.response_header,
+                      http.response,
+                      options)
+          end
+        else
+          raise Blodsband::Error.new(http)
+        end
+      end
+
+      def self.inject_links(previous_links, document, links, responses)
+        previous_links << links.shift
+        response = responses.shift
+        if document.is_a?(Hash)
+          document[previous_links.join("->")] = response
+        elsif document.respond_to?(:<<)
+          document << response
+        else
+          document = [document, response]
+        end
+        if links.size > 0
+          document = inject_links(previous_links, document, links, responses)
+        end
+        document
+      end
+      
+      def self.parse_callbacks(multi, options = {})
+        resp = parse_response(multi.responses[:callback][:resp], options)
+        link_chains = options.delete(:links) || []
+        link_chains.each do |chain|
+          inject_links([], resp, chain, parse_response(multi.responses[:callback][chain]))
+        end
+        resp
+      end
+
+      def self.parse(item, options = {})
+        if item.is_a?(EM::Synchrony::Multi)
+          if item.responses[:errback].empty?
+            parse_callbacks(item, options)
+          else
+            raise Multi::Error.new(item)
+          end
+        else
+          raise "Unparseable item #{item.inspect}"
+        end
+      end
+
+      def self.included(base)
+        unless base.include?(InstanceMethods)
+          base.class_eval do
+            attr_reader :status
+            attr_reader :links
+            attr_reader :vclock
+            attr_reader :last_modified
+            attr_reader :key
+            attr_reader :bucket
+            attr_reader :meta
+            include InstanceMethods
+          end
+          base.extend(ClassMethods)
+        end
+      end
+
+      module InstanceMethods
+        #
+        # Copies the response-specific parts of this {Blodsband::Riak::Response} to <code>other</code> after
+        # having made <code>other</code> include {Blodsband::Riak::Response}.
+        #
+        # Does not copy links or meta since they are value specific.
+        #
+        # @param [Object] other what we want to copy our response data to.
+        # @param [Hash] options
+        #  :except:: [Array<:status, :vclock, :last_modified, :key, :bucket>] an array of data not to copy.
+        #
+        # @return [Object] the parameter with {Blodsband::Riak::Response} included and its response data set to that of us.
+        #
+        def copy_to(other, options = {})
+          except = options.delete(:except) || []
+          raise "Unknown option to #copy_to: #{options.inspect}" unless options.empty?
+          class << other
+            include Response
+          end
+          response = self
+          other.instance_eval do
+            @status = response.status unless except.include?(:status)
+            @vclock = response.vclock unless except.include?(:vclock)
+            @last_modified = response.last_modified unless except.include?(:last_modified)
+            @key = response.key unless except.include?(:key)
+            @bucket = response.bucket unless except.include?(:bucket)
+          end
+          other
+        end
+        def apply(status, headers, bucket, key)
+          @bucket = bucket
+          @key = key
+          @status = status
+          @vclock = headers["X-Riak-Vclock"]
+          @last_modified = DateTime.parse(headers["Last-Modified"].to_s) rescue nil
+          @meta = {}
+          if headers.is_a?(Mail::Part)
+            headers.header_fields.each do |field|
+              if match = field.name.match(/^X-Riak-Meta-(.*)$/)
+                @meta[match[1].downcase] = field.value.to_s
+              end
+            end
+          else 
+            headers.each do |key, value|
+              if match = key.to_s.match(/^X_RIAK_META_(.*)$/)
+                @meta[match[1].gsub(/_/, "-").downcase] = value.to_s
+              end
+            end
+          end
+          link_header = headers["Link"]
+          if link_header.nil?
+            @links = []
+          else
+            @links = link_header.to_s.split(/,/).inject({}) do |sum, link|
+              parts = link.split(/;/)
+              if parts.size > 0 && keymatch = parts.shift.match(/<\/buckets\/(.*)\/keys\/(.*)>/)
+                key = [keymatch[1], keymatch[2]]
+                type = ""
+                parts.each do |part|
+                  if match = part.match(/riaktag="(.*)"/)
+                    type = match[1]
+                  end
+                end
+                sum[type.strip] ||= []
+                sum[type.strip] << key
+              end
+              sum
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+      end
+
+    end
+
+  end
+
+end
+