crdt 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd48ff44957feb80db35dde367d7738a00017ba4
-  data.tar.gz: 14f4d3d491163faaad568b5dd827e058671a3640
+  metadata.gz: 144854095bee0b768400839d8c599d2edb3274ab
+  data.tar.gz: 93a47b03011a29a6ea63475437b202c1068ed309
 SHA512:
-  metadata.gz: f93a162bb0765597bb6519a41691bcca73bcd5c7ee6f6d67b91f02434a514d5088b11980716fa0a9297eabadb71c9a5d7be370d06255f1a4195562699715d5b0
-  data.tar.gz: 512bd46616582d6d910302677d3f9956e261965db82391f5cccaf1413aae37aa813545b2daf081137519c11b7909038b4984beb8c68fb4e9d6c73d98997a0f67
+  metadata.gz: e02b8ad58ad150e670782320963c626afe7202b7d74a054051af47dd497a3f38e8bbb2a3ba527a426753c8ced005c3974cd40e3a9aab27c96455e5579249950a
+  data.tar.gz: b68ef708f83d7c06a6d21cac54f482784d63c015d6b31eb733bd1ec3fa653c397a4ef9c9de382fee0354fa222240fc4dfa5286ff96d9c460d60972f4ca8c0b01

data/lib/crdt.rb

@@ -11,5 +11,5 @@ end
   or_set
   lww_register
 }.each do |lib|
-  require File.expand_path("crdt/#{lib}", __DIR__)
+  require File.expand_path("crdt/#{lib}", __dir__)
 end

data/lib/crdt/or_graph.rb

@@ -0,0 +1,167 @@
+module CRDT
+  # Observe Remove Graph (variant of 2P2P Graph)
+  #
+  # This is a general purpose graph data type. It works by keeping a 2P set for vertices and an OR set for edges
+  #
+  # Vertices are created uniquely on a node, and are represented with a token. It is left to the user to tie this token to their internal data.
+  # When merging changes, removes take precedence over adds, which can cause some surprising behavior when removing vertices
+  class ORGraph
+    # Create a new graph
+    def initialize(node_identity = Thread.current.object_id, token_counter = 0)
+      @node_identity = node_identity
+      @token_counter = token_counter
+      @vertices = {}
+      @edges = {}
+    end
+
+    attr_accessor :vertices, :edges
+
+    # Test if a given vertex token is in this graph
+    def has_vertex?(token)
+      vertex = @vertices[token]
+      return false unless vertex
+      return ! vertex[:removed]
+    end
+
+    # Test if an edge exists between the given vertices
+    def has_edge?(from, to)
+      edge = @edges[edge_token(from, to)]
+      return false unless edge
+      return ! edge[:observed].empty?
+    end
+
+    # Get a list of all the edges that originate at the given vertex
+    def outgoing_edges(from)
+      @vertices[from][:outgoing_edges].map { |to| [from, to] }
+    end
+
+    # Get a list of all the edges that terminate at the given vertex
+    def incoming_edges(to)
+      @vertices[to][:incoming_edges].map { |from| [from, to] }
+    end
+
+    # Add a new vertex to the graph
+    #
+    # @return token representing the newly created vertex
+    def create_vertex
+      token = issue_token
+      # the edge arrays are a performance optimization to provide O(1) lookup for edges by vertex
+      @vertices[token] = { incoming_edges: [], outgoing_edges: [], removed: false }
+      return token
+    end
+
+    # add an edge leading from the given vertex to the given vertex
+    #
+    # @return token representing the created edge
+    def add_edge(from, to)
+      @vertices[from][:outgoing_edges] << to
+      @vertices[to][:incoming_edges] << from
+      token = edge_token(from, to)
+      @edges[token] ||= { observed: [], removed: [] }
+      @edges[token][:observed] << issue_token
+
+      return token
+    end
+
+    # remove a vertex from this graph, and any edges that involve it
+    def remove_vertex(vertex)
+      @vertices[vertex][:removed] = true
+      (incoming_edges(vertex) + outgoing_edges(vertex)).each do |from, to|
+        remove_edge(from, to)
+      end
+    end
+
+    # remove an edge from this graph
+    def remove_edge(from, to)
+      edge = @edges[edge_token(from, to)]
+      edge[:removed] += edge[:observed]
+      edge[:observed] = []
+      @vertices[from][:outgoing_edges] -= [to]
+      @vertices[to][:outgoing_edges] -= [from]
+    end
+
+    # Get a hash representation of this graph, suitable for serialization to JSON
+    def to_h
+      return {
+        node_identity: @node_identity,
+        token_counter: @token_counter,
+        vertices: @vertices,
+        edges: @edges,
+      }
+    end
+
+    # Create a new Graph from a hash, such as that deserialized from JSON
+    def self.from_h(hash)
+      graph = ORGraph.new(hash["node_identity"], hash["token_counter"])
+
+      hash["vertices"].each do |token, vertex|
+        graph.vertices[token] ||= {
+          incoming_edges: vertex[:incoming_edges].dup,
+          outgoing_edges: vertex[:outgoing_edges].dup,
+          removed: vertex[:removed],
+        }
+      end
+      hash["edges"].each do |token, edge|
+        graph.edges[token] = {
+          observed: edge[:observed].dup,
+          removed: edge[:removed].dup,
+        }
+      end
+
+      return graph
+    end
+
+    # Perform a one-way merge, bringing in changes from another graph
+    def merge(other)
+      other.vertices.each do |token, vertex|
+        @vertices[token] ||= {
+          incoming_edges: [],
+          outgoing_edges: [],
+          removed: false,
+        }
+
+        # cleaning out removed edges is taken care of while merging edges
+        @vertices[token][:incoming_edges] |= vertex[:incoming_edges]
+        @vertices[token][:outgoing_edges] |= vertex[:outgoing_edges]
+        @vertices[token][:removed] |= vertex[:removed]
+      end
+      other.edges.each do |edge_token, edge|
+        from, to = from_edge_token(edge_token)
+        @edges[edge_token] ||= {
+          observed: [],
+          removed: [],
+        }
+
+        @edges[edge_token][:observed] |= edge[:observed]
+        @edges[edge_token][:removed] |= edge[:removed]
+        @edges[edge_token][:observed] -= @edges[edge_token][:removed]
+
+        # vertex removal takes precedence over edge creation
+        if @vertices[from][:removed] || @vertices[to][:removed]
+          @edges[edge_token][:removed] += @edges[edge_token][:observed]
+          @edges[edge_token][:observed] = []
+        end
+
+        if @edges[edge_token][:observed].empty?
+          @vertices[to][:incoming_edges].delete(from)
+          @vertices[from][:outgoing_edges].delete(to)
+        end
+      end
+    end
+
+    private
+    # issue a token unique to this node
+    def issue_token
+      @token_counter += 1
+      token = "#{@node_identity}:#{@token_counter}"
+    end
+
+    def edge_token(from, to)
+      "#{from}->#{to}"
+    end
+
+    def from_edge_token(token)
+      token.split("->")
+    end
+  end
+end

data/lib/crdt/or_set.rb

@@ -28,6 +28,18 @@ module CRDT
       return ! tokens[:observed].empty?
     end
 
+    def each
+      if block_given?
+        @items.each do |item, record|
+          next if record[:observed].empty?
+          yield item
+        end
+      else
+        return to_enum
+      end
+    end
+    include Enumerable
+
     # Add an item to this set
     def add(item)
       # the token in this implementation is "better", since it's easier for us to parse/garbage collect
@@ -72,8 +84,8 @@ module CRDT
     def merge(other)
       other.items.each do |item, record|
         @items[item] ||= {observed: [], removed: []}
-        @items[item][:observed] += record[:observed]
-        @items[item][:removed] += record[:removed]
+        @items[item][:observed] |= record[:observed]
+        @items[item][:removed] |= record[:removed]
         @items[item][:observed] -= @items[item][:removed]
       end
     end

data/lib/crdt/pn_counter.rb

@@ -12,8 +12,7 @@ module CRDT
   # The space cost of synchronization is O(m)
   #
   # # Implementation notes:
-  # This implementation is a CvRDT. That means it takes 
-  # This implementation doesn't support garbage collection, although you could add it by removing a node's records, and folding it into a base value.
+  # This implementation is a CvRDT. That means it sends a full copy of the entire structure, rather than messages
   class PNCounter
     # @param hash [Hash] a serialized PNCounter, conforming to the format here
     # 
@@ -27,7 +26,7 @@ module CRDT
     #   }
     # }
     def self.from_h(hash)
-      counter = PNCounter.new
+      counter = PNCounter.new(hash["node_identity"], hash["base_value"])
 
       hash["positive"].each do |source, amount|
         counter.increase(amount, source)
@@ -42,6 +41,8 @@ module CRDT
     # Get a hash representation of this object, which is suitable for serialization to JSON
     def to_h
       return {
+        node_identity: @node_identity,
+        base_value: @base_value,
         cached_value: @cached_value,
         positive: @positive_counters,
         negative: @negative_counters,
@@ -50,12 +51,13 @@ module CRDT
 
     # Create a new counter
     #
-    # @param this_source Identifier for this node, used for tracking changes to the counter. Defaults to the current Thread's object ID
-    def initialize(this_source = Thread.current.object_id)
-      @cached_value = 0
+    # @param node_identity Identifier for this node, used for tracking changes to the counter. Defaults to the current Thread's object ID
+    def initialize(node_identity = Thread.current.object_id, base_value = 0)
+      @base_value = base_value
+      @cached_value = base_value
       @positive_counters = {}
       @negative_counters = {}
-      @this_source = this_source
+      @node_identity = node_identity
     end
 
     attr_accessor :positive_counters, :negative_counters
@@ -64,7 +66,7 @@ module CRDT
     #
     # @param amount [Number] a non-negative amount to decrease this counter by
     def increase(amount, source = nil)
-      source ||= @this_source
+      source ||= @node_identity
       positive_counters[source] ||= 0
       positive_counters[source] += amount
       @cached_value += amount
@@ -76,7 +78,7 @@ module CRDT
     #
     # @param amount [Number] a non-negative amount to decrease this counter by
     def decrease(amount, source = nil)
-      source ||= @this_source
+      source ||= @node_identity
       negative_counters[source] ||= 0
       negative_counters[source] += amount
       @cached_value -= amount
@@ -87,23 +89,25 @@ module CRDT
     # Add something to this counter
     #
     # @param other [Number] the amount to add to this counter
-    def +=(other)
+    def +(other)
       if other > 0
         increase(other)
       else
         decrease(- other)
       end
+      self
     end
 
     # Subtract something from this counter
     #
     # @param other [Number] the amount to subtract from this counter
-    def -=(other)
+    def -(other)
       if other > 0
         decrease(other)
       else
         increase(- other)
       end
+      self
     end
 
     def value
@@ -139,5 +143,15 @@ module CRDT
 
       return self
     end
+
+    # Garbage collect a node, removing its counters and folding them into the new base value.
+    #
+    # This should only be called if your cluster management has indicated that a node has left the cluster permanently.
+    def gc(node)
+      @base_value += @positive_counters[node]
+      @base_value -= @negative_counters[node]
+      @positive_counters.delete(node)
+      @negative_counters.delete(node)
+    end
   end
 end

data/lib/crdt/version.rb

@@ -1,3 +1,3 @@
 module CRDT
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crdt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Steven Karas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-24 00:00:00.000000000 Z
+date: 2015-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,7 @@ files:
 - crdt.gemspec
 - lib/crdt.rb
 - lib/crdt/lww_register.rb
+- lib/crdt/or_graph.rb
 - lib/crdt/or_set.rb
 - lib/crdt/pn_counter.rb
 - lib/crdt/vector_clock.rb