riak-ruby-ledger 0.0.4

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/**/*_test.rb"
+  t.pattern = "test/**/*_test.rb"
+end

data/lib/crdt/tgcounter.rb

@@ -0,0 +1,171 @@
+require 'set'
+
+module Riak::CRDT
+  class TGCounter
+    attr_accessor :counts, :actor, :history_length
+
+    # Create a new Transaction GCounter
+    # @param [Hash] options
+    #   {
+    #     :actor [String]
+    #     :history_length [Integer]
+    #   }
+    def initialize(options)
+      self.actor = options[:actor]
+      self.history_length = options[:history_length]
+      self.counts = Hash.new()
+      self.counts[self.actor] = Hash.new()
+      self.counts[self.actor]["total"] = 0
+      self.counts[self.actor]["txns"] = TransactionArray.new()
+    end
+
+    def to_hash
+      c = Hash.new()
+      self.counts.each do |a, values|
+        c[a] = Hash.new()
+        c[a]["total"] = values["total"]
+        c[a]["txns"] = values["txns"].arr
+      end
+
+      {
+          type: 'TGCounter',
+          c: c
+      }
+    end
+
+    def to_json
+      self.to_hash.to_json
+    end
+
+    def self.from_hash(h, options)
+      gc = new(options)
+
+      h['c'].each do |a, values|
+        gc.counts[a] = Hash.new() unless gc.counts[a]
+        gc.counts[a]["total"] = values["total"]
+        gc.counts[a]["txns"] = TransactionArray.new(values["txns"])
+      end
+
+      return gc
+    end
+
+    def self.from_json(json, options)
+      h = JSON.parse json
+      raise ArgumentError.new 'unexpected type field in JSON' unless h['type'] == 'TGCounter'
+
+      from_hash(h, options)
+    end
+
+    # Increment this actor's transaction array, overwriting if the value exists
+    # @param [String] transaction
+    # @param [Integer] value
+    def increment(transaction, value)
+      self.counts[actor]["txns"][transaction] = value
+    end
+
+    # Get unique list of all transactions and values across all known actors
+    # @param [String] ignore_actor
+    # @return [Hash]
+    def unique_transactions(ignore_actor=nil)
+      txns = Hash.new()
+
+      self.counts.each do |a, values|
+        unless a == ignore_actor
+          values["txns"].arr.each do |arr|
+              txns[arr[0]] = arr[1]
+          end
+        end
+      end
+
+      txns
+    end
+
+    def has_transaction?(transaction)
+      self.unique_transactions().keys.member?(transaction)
+    end
+
+    # Sum of totals and currently tracked transactions
+    # @return [Integer]
+    def value()
+      total = self.unique_transactions().values.inject(0, &:+)
+
+      self.counts.values.each do |a|
+        total += a["total"]
+      end
+
+      total
+    end
+
+    # Merge actor data from a sibling into self, additionally compress oldest
+    # transactions that exceed the :history_length param into actor's total
+    # @param [TGCounter] other
+    def merge(other)
+      # Combine all actors first
+      other.counts.each do |other_actor, other_values|
+        if self.counts[other_actor]
+          # Max of totals
+          mine = self.counts[other_actor]["total"]
+          self.counts[other_actor]["total"] = [mine, other_values["total"]].max
+
+          # Max of unique transactions
+          other_values["txns"].arr.each do |arr|
+            other_txn, other_value = arr
+            mine = (self.counts[other_actor]["txns"][other_txn]) ?
+                self.counts[other_actor]["txns"][other_txn] : 0
+            self.counts[other_actor]["txns"][other_txn] = [mine, other_value].max
+          end
+        else
+          self.counts[other_actor] = other_values
+        end
+      end
+
+      # Remove duplicate transactions if other actors have claimed them
+      self.unique_transactions(actor).keys.each do |txn|
+        self.counts[actor]["txns"].delete(txn)
+      end
+
+      # Merge this actor's data based on history_length
+      total = 0
+      if self.counts[actor]["txns"].length > self.history_length
+        to_delete = self.counts[actor]["txns"].length - self.history_length
+        self.counts[actor]["txns"].arr.slice!(0..to_delete - 1).each do |arr|
+          total += arr[1]
+        end
+      end
+
+      self.counts[actor]["total"] += total
+    end
+  end
+end
+
+# Ease of use class: Wraps an ordered array with some hash-like functions
+class TransactionArray
+  attr_accessor :arr
+
+  def initialize(arr=Array.new())
+    self.arr = arr
+  end
+
+  def length()
+    self.arr.length
+  end
+
+  def ==(other)
+    self.arr == other.arr
+  end
+
+  def []=(key, value)
+    self.delete(key) if self.[](key)
+    self.arr << [key, value]
+  end
+
+  def [](key)
+    res = self.arr.select { |a| a[0] == key }
+    res.first[1] if res && res.length > 0 &&res.first.length == 2
+  end
+
+  def delete(key)
+    index = self.arr.index { |a| a[0] == key }
+    self.arr.delete_at(index) if index
+  end
+end

data/lib/crdt/tpncounter.rb

@@ -0,0 +1,64 @@
+require 'crdt/tgcounter'
+
+module Riak::CRDT
+  class TPNCounter
+    attr_accessor :p, :n
+
+    # Create a new Transaction PNCounter
+    # @param [Hash] options
+    #   {
+    #     :actor [String]
+    #     :history_length [Integer]
+    #   }
+    def initialize(options)
+      self.p = TGCounter.new(options)
+      self.n = TGCounter.new(options)
+    end
+
+    def to_json
+      {
+          type: 'TPNCounter',
+          p: self.p.to_hash,
+          n: self.n.to_hash
+      }.to_json
+    end
+
+    def self.from_json(json, options)
+      h = JSON.parse json
+      raise ArgumentError.new 'unexpected type field in JSON' unless h['type'] == 'TPNCounter'
+
+      pnc = new(options)
+      pnc.p = TGCounter.from_hash(h['p'], options)
+      pnc.n = TGCounter.from_hash(h['n'], options)
+
+      return pnc
+    end
+
+    # Increment this actor's positive transaction array, overwriting if the value exists
+    # @param [String] transaction
+    # @param [Integer] value
+    def increment(transaction, value)
+      self.p.increment(transaction, value)
+    end
+
+    # Increment this actor's negative transaction array, overwriting if the value exists
+    # @param [String] transaction
+    # @param [Integer] value
+    def decrement(transaction, value)
+      self.n.increment(transaction, value)
+    end
+
+    def value
+      self.p.value - self.n.value
+    end
+
+    def has_transaction?(transaction)
+      self.p.has_transaction?(transaction) || self.n.has_transaction?(transaction)
+    end
+
+    def merge(other)
+      self.p.merge(other.p)
+      self.n.merge(other.n)
+    end
+  end
+end

data/lib/ledger.rb

@@ -0,0 +1,173 @@
+require 'ledger/version'
+require 'crdt/tpncounter'
+require 'json'
+
+module Riak
+  class Ledger
+    attr_accessor :bucket, :key, :counter, :retry_count, :counter_options
+
+    # Create a new Ledger object
+    # @param [Riak::Bucket] bucket
+    # @param [String] key
+    # @param [Hash] options
+    #   {
+    #     :actor [String]: default Thread.current["name"] || "ACTOR1"
+    #     :history_length [Integer]: default 10
+    #     :retry_count [Integer]: default 10
+    #   }
+    def initialize(bucket, key, options={})
+      self.bucket = bucket
+      self.key = key
+      self.retry_count = options[:retry_count] || 10
+
+      self.counter_options = {}
+      self.counter_options[:actor] = options[:actor] || Thread.current["name"] || "ACTOR1"
+      self.counter_options[:history_length] = options[:history_length] || 10
+      self.counter = Riak::CRDT::TPNCounter.new(self.counter_options)
+
+      unless bucket.allow_mult
+        self.bucket.allow_mult = true
+      end
+    end
+
+    # Find an existing Ledger object, merge and save it
+    # @param [Riak::Bucket] bucket
+    # @param [String] key
+    # @param [Hash] options
+    #   {
+    #     :actor [String]: default Thread.current["name"] || "ACTOR1"
+    #     :history_length [Integer]: default 10
+    #     :retry_count [Integer]: default 10
+    #   }
+    # @return [Riak::Ledger]
+    def self.find!(bucket, key, options={})
+      candidate = new(bucket, key, options)
+      vclock = candidate.refresh()
+      candidate.save(vclock)
+
+      return candidate
+    end
+
+    # Increment the counter, merge and save it
+    # @param [String] transaction
+    # @param [Positive Integer] value
+    # @see update!(transaction, value)
+    # @return [Boolean]
+    def credit!(transaction, value)
+      update!(transaction, value)
+    end
+
+    # Decrement the counter, merge and save it
+    # @param [String] transaction
+    # @param [Positive Integer] value
+    # @see update!(transaction, value)
+    # @return [Boolean]
+    def debit!(transaction, value)
+      update!(transaction, value * -1)
+    end
+
+    # Update the counter, merge and save it. Retry if unsuccessful
+    # @param [String] transaction
+    # @param [Integer] value
+    # @param [Integer] current_retry
+    # @return [Boolean]
+    def update!(transaction, value, current_retry=nil)
+      # Failure case, not able to successfully complete the operation, retry a.s.a.p.
+      if current_retry && current_retry <= 0
+        return false
+      end
+
+      # Get the current merged state of this counter
+      vclock = refresh()
+
+
+      if has_transaction?(transaction)
+        # If the transaction already exists in the counter, no problem
+        return true
+      else
+        # If the transaction doesn't exist, attempt to add it and save
+        if value < 0
+          self.counter.decrement(transaction, value * -1)
+        else
+          self.counter.increment(transaction, value)
+        end
+
+        unless save(vclock)
+          # If the save wasn't successful, retry
+          current_retry = self.retry_count unless current_retry
+          update!(transaction, value, current_retry - 1)
+        else
+          # If the save succeeded, no problem
+          return true
+        end
+      end
+    end
+
+    # Create a new Ledger object
+    # @param [String] transaction
+    # @return [Boolean]
+    def has_transaction?(transaction)
+      self.counter.has_transaction?(transaction)
+    end
+
+    # Calculate the current value of the counter
+    # @return [Integer]
+    def value()
+      self.counter.value
+    end
+
+    # Delete the counter
+    # @return [Boolean]
+    def delete()
+      begin
+        self.bucket.delete(self.key)
+        return true
+      rescue => e
+        return false
+      end
+    end
+
+    # Get the current state of the counter and merge it
+    # @return [String]
+    def refresh()
+      obj = self.bucket.get_or_new(self.key)
+      return if obj.nil?
+
+      self.counter = Riak::CRDT::TPNCounter.new(self.counter_options)
+
+      if obj.siblings.length > 1
+        obj.siblings.each do | sibling |
+          unless sibling.raw_data.nil? or sibling.raw_data.empty?
+            self.counter.merge(Riak::CRDT::TPNCounter.from_json(sibling.raw_data, self.counter_options))
+          end
+        end
+      elsif !obj.raw_data.nil?
+        self.counter.merge(Riak::CRDT::TPNCounter.from_json(obj.raw_data, self.counter_options))
+      end
+
+      return obj.vclock
+    end
+
+    # Save the counter with an optional vclock
+    # @param [String] vclock
+    # @return [Boolean]
+    def save(vclock=nil)
+      object = self.bucket.new(self.key)
+      object.vclock = vclock if vclock
+      object.content_type = 'application/json'
+      object.raw_data = to_json
+
+      begin
+        options = {:returnbody => false}
+        object.store(options)
+        return true
+      rescue => e
+        return false
+      end
+    end
+
+    def to_json()
+      self.counter.to_json
+    end
+  end
+end

data/lib/ledger/version.rb

@@ -0,0 +1,5 @@
+module Riak
+  class Ledger
+    VERSION = "0.0.4"
+  end
+end

data/riak-ruby-ledger.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ledger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "riak-ruby-ledger"
+  spec.version       = Riak::Ledger::VERSION
+  spec.authors       = ["drewkerrigan"]
+  spec.email         = ["dkerrigan@basho.com"]
+  spec.description   = %q{A PNCounter CRDT based ledger with support for transaction ids and tunable write idempotence}
+  spec.summary       = %q{This gem attempts to provide a tunable Counter option by combining non-idempotent GCounters and a partially idempotent GSet for calculating a running counter or ledger. By allowing clients to set how many transactions to keep in the counter object as well as set a retry policy on the Riak actions performed on the counter, a good balance can be achieved.}
+  spec.homepage      = "https://github.com/drewkerrigan/riak-ruby-ledger"
+  spec.license       = "Apache2"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "json"
+  spec.add_dependency "riak-client"
+end