blodsband 0.0.2

data/lib/blodsband/riak/counter.rb

@@ -0,0 +1,77 @@
+
+module Blodsband
+
+  class Riak
+
+    class Counter
+
+      #
+      # Create a concurrent counter.
+      #
+      # @param [Blodsband::Riak::Bucket] bucket the bucket this counter lives in.
+      # @param [String] key the key for this counter.
+      #
+      def initialize(bucket, key)
+        @bucket = bucket
+        @key = key
+      end
+
+      #
+      # Increment this counter.
+      #
+      # @param [Integer] step the amount to increment the counter.
+      #
+      # @return [Integer] the new value for this counter. Note that there is no guarantee whatsoever as to at what point this value is true. Only that it was true at some point.
+      #
+      # @raise [RuntimerError] if step is < 0
+      #
+      def inc(step = 1)
+        raise RuntimeError.new("#{self}.inc(..) only allows positive values") if step < 0
+        current = get_resolved
+        current["last"] = current["last"] + current["step"]
+        current["step"] = step
+        val(get_resolved(@bucket.put(@key, current, :riak_params => {:readbody => true})))
+      end
+
+      #
+      # Get the value of this counter.
+      #
+      # @param [Blodsband::Riak::Result] current a {Blodsband::Riak::Response} defining the last known value (possibly with a gazillion siblings).
+      #
+      # @return [Integer] the current value of the counter. Note that there is no guarantee whatsoever as to when this value was true. Only that it was true at some point.
+      #
+      def val(current = nil)
+        current = get_resolved if current.nil?
+        return current["last"] + current["step"]
+      end
+      
+      private
+      
+      def get_resolved(current = nil)
+        current = @bucket.get(@key, :ary => true) if current.nil?
+        if current.empty?
+          current = {
+            "step" => 0,
+            "last" => 0
+          }
+          return get_resolved(@bucket.put(@key, current, :riak_params => {:readbody => true}))
+        else
+          last = 1 << 256
+          step = 0
+          current.each do |v|
+            step += v["step"]
+            last = v["last"] if v["last"] < last
+          end
+          sum = {
+            "step" => step,
+            "last" => last
+          }
+          return current.copy_to(sum)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/blodsband/riak/list.rb

@@ -0,0 +1,880 @@
+
+module Blodsband
+  
+  class Riak
+    
+    #
+    # A concurrent linked list.
+    #
+    class List
+
+      #
+      # An error signaling that saving a piece of data failed because it has
+      # been concurrently updated elsewhere.
+      #
+      class ConcurrentUpdateError < RuntimeError
+        #
+        # [Object] The actor that was concurrently updated.
+        #
+        attr_reader :actor
+        def initialize(actor, message)
+          super(message)
+          @actor = actor
+        end
+      end
+
+      #
+      # An error signaling that performing an operation failed because one or more
+      # of the actors in the operation have been deleted.
+      #
+      class ActorDeletedError < RuntimeError
+        #
+        # [Object] The actor that was deleted.
+        #
+        attr_reader :actor
+        def initialize(actor, message)
+          super(message)
+          @actor = actor
+        end
+      end
+
+      #
+      # The list element.
+      #
+      class Element
+
+        #
+        # The key in Riak for this element.
+        #
+        attr_reader :key
+        #
+        # The {Blodsband::Riak::List} this element belongs to.
+        #
+        attr_reader :list
+        
+        #
+        # Find an element.
+        #
+        # @param [Blodsband::Riak::List] list the list the element belongs to.
+        # @param [String] key the key for this element.
+        #
+        # @return [Blodsband::Riak::Element] the element at the given key.
+        #
+        def self.find(list, key)
+          rval = Element.new
+          rval.instance_eval do
+            @list = list
+            @key = key
+          end
+          rval
+        end
+        
+        #
+        # @private
+        #
+        # Create an element.
+        #
+        # @param [Blodsband::Riak::List] list the list the element shall belong to.
+        # @param [Object] value the value to put in the element.
+        #
+        # @return [Blodsband::Riak::Element] a new (unsaved) element with the given value.
+        #
+        def self.create(list, value)
+          rval = Element.new
+          rval.instance_eval do
+            @list = list
+            @key = rand(1 << 256).to_s(36)
+            @value = value
+            class << @value
+              include Response
+            end
+            @value.instance_eval do
+              @meta = (@meta || {}).merge("list-key" => list.key)
+            end
+          end
+          rval.save
+          rval
+        end
+
+        #
+        # @return [true, false] whether the element exists.
+        #
+        def exists?
+          reload
+          !key.nil? && !value.nil?
+        end
+
+        #
+        # @return [String] a {::String} representation of the element.
+        #
+        def to_s
+          if exists?
+            "#{self.previous} => #{self.class}:#{key}@#{list.key} #{value.inspect} => #{self.next}"
+          else
+            "#{self.class}:#{key}@#{list.key}"
+          end
+        end
+
+        #
+        # @param [Object] o the new value to set in this element.
+        #
+        # @note Does not lock the parent list, since changing the element value is independent 
+        #  of structural list changes. Instead both this and structural list changes just retry
+        #  on {Blodsband::Riak::List::ConcurrentUpdateError}.
+        #
+        # @return [Object] the new value.
+        #
+        def value=(o)
+          begin
+            old_value = value
+            @value = value.copy_to(o)
+            value.instance_eval do
+              @meta = old_value.meta
+            end
+            save
+            value
+          rescue ConcurrentUpdateError => e
+            if !exists?
+              raise ActorDeletedError.new(self, to_s)
+            else
+              retry
+            end
+          end
+        end
+
+        #
+        # @return [Object] the value of this element.
+        #
+        def value
+          @value ||= list.bucket.get(key, :unique => true)
+        end
+
+        #
+        # Prepend a value before this element in the list.
+        #
+        # @param [Object] value the value to prepend.
+        #
+        # @return [Object] the value inserted.
+        #
+        def prepend(value)
+          if exists?
+            while !list.prepend_element_before(self, Element.create(list, value))
+              list.reload
+              reload
+              raise ActorDeletedError.new(self, to_s) unless exists?
+              raise ActorDeletedError.new(list, list.to_s) unless list.exists?
+            end
+          else
+            raise ActorDeletedError.new(self, to_s)
+          end
+        end
+
+        #
+        # Delete this element.
+        #
+        def delete
+          if exists?
+            while !list.delete_element(self)
+              list.reload
+              reload
+              break unless exists?
+              raise ActorDeletedError.new(list, list.to_s) unless list.exists?
+            end
+          end
+        end
+
+        #
+        # Append a value after this element in the list.
+        #
+        # @param [Object] value the value to append.
+        #
+        # @return [Object] the value appended.
+        #
+        def append(value)
+          if exists?
+            while !list.append_element_after(self, Element.create(list, value))
+              list.reload
+              reload
+              raise ActorDeletedError.new(self, to_s) unless exists?
+              raise ActorDeletedError.new(list, list.to_s) unless list.exists?
+            end
+          else
+            raise ActorDeletedError.new(self, to_s)
+          end
+        end
+        
+        #
+        # @private
+        #
+        # Save this element.
+        #
+        # @raise [Blodsband::Riak::List::ConcurrentUpdateError] if the element has already been updated elsewhere.
+        #
+        def save
+          curr = @value
+          @value = list.bucket.cas(key, value, value.vclock)
+          if @value.nil?
+            raise ConcurrentUpdateError.new(self, to_s) 
+          else
+            #STDERR.puts("#{$$} succeeded saving #{curr} (#{curr.meta})")
+          end
+        end
+
+        #
+        # @private
+        #
+        # Make sure this element is reloaded from Riak.
+        #
+        def reload
+          @value = nil
+        end
+
+        #
+        # @private
+        #
+        # @return [String] the key to the next element in the list.
+        #
+        def next
+          value.meta["list-next"]
+        end
+
+        #
+        # @private
+        #
+        # @return [Blodsband::Riak::List::Element] the next element or nil.
+        #
+        def next_element
+          Element.find(list, self.next)
+        end
+
+        #
+        # @private
+        #
+        # @return [String] the key to the previous element in the list.
+        #
+        def previous
+          value.meta["list-previous"]
+        end
+
+        #
+        # @private
+        #
+        # @return [Blodsband::Riak::List::Element] the previous element or nil.
+        #
+        def previous_element
+          Element.find(list, self.previous)
+        end
+
+        #
+        # @private
+        #
+        def set_pointers(list_version, previous_key, next_key)
+          begin
+            list_doc = list.bucket.get(list.key)
+            if list_doc.nil? || list_doc["version"] == list_version
+              if previous_key.nil?
+                value.meta.delete("list-previous")
+              elsif previous_key != ":unchanged"
+                value.meta["list-previous"] = previous_key 
+              end
+              if next_key.nil?
+                value.meta.delete("list-next")
+              elsif next_key != ":unchanged"
+                value.meta["list-next"] = next_key 
+              end
+              save
+            end
+          rescue ConcurrentUpdateError => e
+            retry if exists?
+          end
+        end
+
+      end
+
+      #
+      # The key of this list in Riak.
+      #
+      attr_reader :key
+      #
+      # The {Blodsband::Riak::Bucket} this list lives in.
+      #
+      attr_reader :bucket
+
+      #
+      # Access a list in a bucket.
+      #
+      # @param [Blodsband::Riak::Bucket] the bucket the list lives in.
+      # @param [String] key the key of the list.
+      #
+      def initialize(bucket, key)
+        @bucket = bucket
+        @key = key
+      end
+
+      #
+      # @return [String] a string representation of the list.
+      #
+      def to_s
+        "#{self.class}:#{key}"
+      end
+
+      #
+      # @return [true, false] whether this list is empty.
+      #
+      def empty?
+        size == 0
+      end
+
+      #
+      # @return [true, false] whether this list exists in Riak.
+      #
+      def exists?
+        !key.nil? && !bucket.get(key).nil?
+      end
+
+      #
+      # @return [Integer] the size of this list.
+      #
+      def size
+        document["size"] ||= 0
+      end
+
+      #
+      # @return [Array] this list as a ruby {::Array}.
+      #
+      def to_a
+        rval = []
+        each do |e|
+          rval << e
+        end
+        rval
+      end
+      
+      #
+      # @return [Object] the last element of this list after having removed it.
+      #
+      def pop
+        if empty?
+          nil
+        else
+          e = Element.find(self, document["tail"])
+          rval = e.value
+          e.delete
+          rval
+        end
+      end
+
+      #
+      # @return [Object] the first element of this list after having removed it.
+      #
+      def shift
+        if empty?
+          nil
+        else
+          e = Element.find(self, document["head"])
+          rval = e.value
+          e.delete
+          rval
+        end
+      end
+
+      #
+      # @return [Object] the first element of this list.
+      #
+      def first
+        if empty?
+          nil
+        else
+          Element.find(self, document["head"]).value
+        end
+      end
+
+      #
+      # @return [Object] the last element of this list.
+      #
+      def last
+        if empty?
+          nil
+        else
+          Element.find(self, document["tail"]).value
+        end
+      end
+
+      #
+      # @private
+      #
+      # Save this list.
+      #
+      # @raise [Blodsband::Riak::ConcurrentUpdateError] if this list has already been updated elswhere.
+      #
+      def save
+        curr = document
+        @document = bucket.cas(key, document, document.vclock)
+        if @document.nil?
+          raise ConcurrentUpdateError.new(self, to_s) 
+        else
+          #STDERR.puts("#{$$} succeeded saving #{@document.inspect}")
+        end
+      end
+
+      def stack_each(current, &block)
+        stack = []
+        while current
+          if current.exists?
+            block.call(current.value, current)
+            if current.next
+              stack << current
+              if stack.include?(current.next_element)
+                raise "Loop detected! Wtf? #{stack.inspect}"
+              else
+                current = current.next_element
+              end
+            else
+              current = nil
+            end
+          else
+            if stack.empty?
+              return
+            else
+              while !stack.empty? && !stack.last.next
+                stack.pop
+              end
+              if stack.empty?
+                current = nil
+              else
+                current = stack.last.next_element
+              end
+            end
+          end
+        end
+      end
+
+      #
+      # Execute code on each element in the list.
+      #
+      # @param [Block |value, element|] block the code to execute.
+      #
+      def each(&block)
+        begin
+          element = nil
+          while size > 0 && !(element = Element.find(self, document["head"])).exists?
+            reload
+          end
+          stack_each(element, &block) if size > 0
+        rescue ActorDeletedError => e
+          if e.actor == self
+            raise e
+          else
+            retry
+          end
+        end
+      end
+
+      #
+      # Append to the list.
+      #
+      # @param [Object] value the value to append.
+      #
+      # @return [Object] the appended value.
+      # 
+      def append(value)
+        append_and_get_element(value).value
+      end
+
+      alias :<< :append
+
+      #
+      # @private
+      #
+      # Append to the list.
+      #
+      # @param (see #append)
+      #
+      # @return [Blodsband::Riak::List::Element] the appended element.
+      #
+      def append_and_get_element(value)
+        new_node = Element.create(self, value)
+        append_element(new_node)
+        new_node
+      end
+
+      #
+      # Prepend to the list.
+      #
+      # @param [Object] value the value to prepend.
+      #
+      # @return [Object] the prepended value.
+      #
+      def prepend(value)
+        new_node = Element.create(self, value)
+        prepend_element(new_node)
+        value
+      end
+
+      #
+      # @private
+      #
+      def prepend_element_before(element, new_node)
+        add_element(element, new_node, :execute_prepend_element_before, "prepend #{new_node.value} before #{element.value}")
+      end
+
+      #
+      # @private
+      #
+      def append_element_after(element, new_node)
+        add_element(element, new_node, :execute_append_element_after, "append #{new_node.value} after #{element.value}")
+      end
+
+      #
+      # @private
+      #
+      # Delete an element.
+      #
+      # @param [Blodsband::Riak::List::Element] element the element to delete.
+      #
+      def delete_element(element)
+        begin
+          backlog << [:execute_delete_element, 
+                      element.key,
+                      "delete #{element.value}"]
+
+          save
+
+          begin
+            rollforward
+          rescue ConcurrentUpdateError => e
+          ensure
+            return true
+          end
+        rescue ConcurrentUpdateError => e
+          if !exists?
+            raise ActorDeletedError.new(self, to_s)
+          elsif element.exists?
+            false
+          end
+        end
+      end
+      
+      #
+      # @private
+      #
+      # Make sure this list gets reloaded from Riak.
+      #
+      def reload
+        @document = nil
+      end
+
+      #
+      # @private
+      #
+      # Validate that this list is consistent.
+      #
+      def validate
+        d = bucket.get(key)
+        s = 0
+        p = nil
+        pe = nil
+        c = d["head"]
+        seen = []
+        while c
+          seen << c
+          e = bucket.get(c)
+          raise "#{e} (#{e.meta.inspect}) doesn't point back to #{pe} (#{pe.meta.inspect})" if p && e.meta["list-previous"] != p
+          p = c
+          pe = e
+          s += 1
+          c = e.meta["list-next"]
+          raise "#{e} (#{e.meta.inspect}) is the the beginning of a loop: #{seen.inspect}" if seen.include?(c)
+          seen << c
+        end
+        raise "#{d.inspect}['tail'] doesn't point to the de facto tail #{pe}" unless d["tail"] == p
+        raise "#{d.inspect}['size'] doesn't show the de facto size #{s}" unless s == d["size"]
+      end
+
+      protected
+
+      def ok_to_add?(element)
+        true
+      end
+
+      def backlog_add(element)
+      end
+
+      def backlog_delete(element)
+      end
+
+      def backlog
+        document["backlog"] ||= []
+        document["backlog"]
+      end
+
+      private 
+
+      def add_element(element, new_node, method, desc)
+        begin
+          backlog << [method,
+                      element.key, 
+                      new_node.key,
+                      desc]
+
+          save
+
+          begin
+            rollforward
+          rescue ConcurrentUpdateError => e
+          ensure
+            return true
+          end
+        rescue ConcurrentUpdateError => e
+          if !exists?
+            raise ActorDeletedError.new(self, to_s)
+          elsif !element.exists?
+            raise ActorDeletedError.new(element, element.to_s)
+          else
+            return false
+          end
+        end
+      end
+
+      def set_element_pointers(v, element_key, previous_key, next_key, desc)
+        Element.find(self, element_key).set_pointers(v, previous_key, next_key)
+      end
+
+      def actually_delete_element(element_key, desc)
+        bucket.delete(element_key)
+      end
+
+      def execute_delete_element(element_key, desc)
+        element = Element.find(self, element_key)
+        if element.exists?
+          previous_element = element.previous_element
+          next_element = element.next_element
+          #STDERR.puts("#{$$} chain:\n  #{previous_element}\n  #{element}\n  #{next_element}")
+          
+          document["version"] = version + 1
+          
+          backlog << [:set_element_pointers,
+                      version,
+                      next_element.key,
+                      element.previous,
+                      ":unchanged",
+                      desc] if next_element.exists?
+          
+          backlog << [:set_element_pointers,
+                      version,
+                      previous_element.key,
+                      ":unchanged",
+                      next_element.key,
+                      desc] if previous_element.exists?
+          
+          backlog << [:actually_delete_element,
+                      element.key,
+                      desc]
+
+          backlog_delete(element)
+
+          document["head"] = element.next if element.previous.nil?
+          document["tail"] = element.previous if element.next.nil?
+          document["size"] -= 1          
+        end
+      end
+
+      def execute_prepend_element_before(element_key, new_key, desc)
+        element = Element.find(self, element_key)
+        if element.exists?
+          new_element = Element.find(self, new_key)
+          if ok_to_add?(new_element)
+            previous_element = element.previous_element
+            #STDERR.puts("#{$$} chain:\n  #{previous_element}\n  #{new_element}\n  #{element}")
+            
+            document["version"] = version + 1
+            
+            backlog << [:set_element_pointers,
+                        version,
+                        new_element.key,
+                        previous_element.key,
+                        element.key,
+                        desc]
+            backlog << [:set_element_pointers,
+                        version,
+                        element.key,
+                        new_element.key,
+                        ":unchanged",
+                        desc]
+            backlog << [:set_element_pointers,
+                        version,
+                        previous_element.key,
+                        ":unchanged",
+                        new_element.key,
+                        desc] if previous_element.exists?
+            
+            backlog_add(new_element)
+            
+            document["head"] = new_key if element.previous.nil?
+            document["size"] = size + 1
+          else
+            bucket.delete(new_element.key)
+          end
+        end
+      end
+
+      def execute_append_element_after(element_key, new_key, desc)
+        element = Element.find(self, element_key)
+        if element.exists?
+          new_element = Element.find(self, new_key)
+          if ok_to_add?(new_element)
+            next_element = element.next_element
+            #STDERR.puts("#{$$} chain:\n  #{element}\n  #{new_element}\n  #{next_element}")
+            document["version"] = version + 1
+            
+            backlog << [:set_element_pointers,
+                        version,
+                        new_element.key,
+                        element.key,
+                        next_element.key,
+                        desc]
+            backlog << [:set_element_pointers,
+                        version,
+                        element.key,
+                        ":unchanged",
+                        new_element.key,
+                        desc]
+            backlog << [:set_element_pointers,
+                        version,
+                        next_element.key,
+                        new_element.key,
+                        ":unchanged",
+                        desc] if next_element.exists?
+            
+            backlog_add(new_element)
+
+            document["tail"] = new_key if element.next.nil?
+            document["size"] = size + 1
+          else
+            bucket.delete(new_element.key)
+          end
+        end
+      end
+
+      def prepend_element(new_node)
+        done = false
+        while !done
+          if empty?
+            done = set_first_element(new_node)
+          else
+            first_element = Element.find(self, document["head"])
+            if first_element.exists?
+              begin
+                done = prepend_element_before(first_element, new_node)
+              rescue ActorDeletedError => e
+                if e.actor != first_element
+                  raise e
+                else
+                  reload
+                end
+              end
+            else
+              reload
+            end
+          end
+        end
+      end
+      
+      def append_element(new_node)
+        done = false
+        while !done
+          if empty?
+            done = set_first_element(new_node)
+          else
+            last_element = Element.find(self, document["tail"])
+            if last_element.exists?
+              begin
+                done = append_element_after(last_element, new_node)
+              rescue ActorDeletedError => e
+                if e.actor != last_element
+                  raise e
+                else
+                  reload
+                end
+              end
+            else
+              reload
+            end
+          end
+        end
+      end
+
+      def set_first_element(new_node)
+        begin
+          document["version"] = version + 1
+          new_node.set_pointers(version, nil, nil)
+          new_node.save
+          document["head"] = new_node.key
+          document["tail"] = new_node.key
+          document["size"] = 1
+          backlog_add(new_node)
+          save
+          begin
+            rollforward
+          rescue ConcurrentUpdateError => e
+          ensure
+            return true
+          end
+        rescue ConcurrentUpdateError => e
+          if !exists?
+            raise ActorDeletedError.new(self, to_s)
+          else
+            return false
+          end
+        end
+      end
+
+      def rollforward
+        while !backlog.empty?
+          begin
+            todo = backlog.clone
+            #STDERR.puts("#{$$} going to roll #{todo.inspect} forward")
+            copy = todo.clone
+            backlog.clear
+            while !todo.empty?
+              self.send(*(todo.shift))
+            end
+            save
+            #STDERR.puts("#{$$} rolled #{copy.inspect} forward")
+          rescue ConcurrentUpdateError => e
+            reload
+            retry unless (_document["backlog"] || []).empty?
+          end
+        end
+      end
+
+      def version
+        document["version"] || 0
+      end
+
+      def _document
+        if @document.nil?
+          @document = bucket.get(key, :unique => true)
+          if @document.nil?
+            @document = {}
+            class << @document
+              include Response
+            end
+          end
+        end
+        @document
+      end
+
+      def document
+        if @document.nil?
+          _document
+          rollforward
+        end
+        @document
+      end
+
+    end
+
+  end
+
+end