spinoza 0.1 → 0.2

data/lib/spinoza/common.rb

@@ -1,2 +1,5 @@
 module Spinoza
 end
+
+module Calvin
+end

data/lib/spinoza/system/link.rb

@@ -0,0 +1,33 @@
+require 'spinoza/system/model'
+require 'spinoza/system/timeline'
+
+# Models a comm link between nodes, including the latency between sender and
+# receiver. The class is stateless: the state of the channnel (messages and
+# their scheduled arrivals) is part of the global timeline.
+class Spinoza::Link < Spinoza::Model
+  # Source and destination nodes.
+  attr_reader :src, :dst
+  
+  # Delay between send by source and receive by destination.
+  attr_reader :latency
+  
+  def initialize src: raise, dst: raise, latency: 0.100, **rest
+    super **rest
+    @src, @dst, @latency = src, dst, latency
+  end
+  
+  class << self
+    alias [] new
+  end
+
+  def inspect
+    "<#{self.class}: #{src} -> #{dst}>"
+  end
+  
+  # The src node calls this to send a message. The message is scheduled for
+  # arrival at the destination.
+  def send_message msg
+    timeline << Spinoza::Event[actor: dst, time: time_now + latency,
+      action: :recv, msg: msg]
+  end
+end

data/lib/spinoza/system/lock-manager.rb

@@ -3,6 +3,13 @@ require 'spinoza/common'
 # Manages concurrency in the spinoza system model, which explicitly schedules
 # all database reads and writes. So all this does is check for concurrency
 # violations; nothing actually blocks.
+#
+# The +txn+ references in this class care only about identity, so they could
+# all be ids or they could all be transaction objects. Similarly the resource
+# being locked by a ReadLock or WriteLock can be anything whose identity is
+# defined by hash equality, i.e. #eql?. Typically, we use `[table, key]` pairs,
+# where `key` is a primary key reference like `{id: ...}`.
+#
 class Spinoza::LockManager
   class ConcurrencyError < StandardError; end
   
@@ -74,8 +81,8 @@ class Spinoza::LockManager
     end
   end
 
-   # { resource => WriteLock | ReadLock | nil, ... }
-   # typically, resource == [table, key]
+  # { resource => WriteLock | ReadLock | nil, ... }
+  # typically, resource == [table, key]
   attr_reader :locks
   
   def initialize
@@ -86,10 +93,10 @@ class Spinoza::LockManager
     case lock = locks[resource]
     when nil
       locks[resource] = ReadLock.new(txn)
-    when ReadLock
+    when ReadLock, WriteLock
       lock.add txn
-    when WriteLock
-      raise ConcurrencyError, "#{resource} is locked: #{lock}"
+        # in WriteLock case, add the reader as a writer
+        # (fails if not locked by txn)
     else raise
     end
   end
@@ -109,11 +116,9 @@ class Spinoza::LockManager
   def unlock_read resource, txn
     lock = locks[resource]
     case lock
-    when WriteLock
-      raise ConcurrencyError, "#{resource} is write locked: #{lock}"
     when nil
       raise ConcurrencyError, "#{resource} is not locked"
-    when ReadLock
+    when ReadLock, WriteLock
       begin
         lock.remove txn
         locks.delete resource if lock.unlocked?
@@ -142,6 +147,15 @@ class Spinoza::LockManager
     end
   end
   
+  def unlock_all txn
+    locks.delete_if do |resource, lock|
+      if lock and lock.includes? txn
+        lock.remove txn
+        lock.unlocked?
+      end
+    end
+  end
+  
   def has_read_lock? resource, txn
     lock = locks[resource]
     lock.kind_of?(ReadLock) && lock.includes?(txn)

data/lib/spinoza/system/log.rb

@@ -0,0 +1,95 @@
+require 'spinoza/common'
+
+# Model of asynchronously replicated global log, such as Cassandra. We assume
+# that each node in our system has a replica providing this service.
+class Spinoza::Log
+  # Delay for a write to become durable on "enough" replicas, from the point of
+  # view of the writing node. Adjust this quantity for your definition of
+  # durable and your network performance.
+  attr_reader :dt_durable
+
+  # Delay for a write to become "completely" replicated: readable at all nodes.
+  # Adjust this quantity for your network performance.
+  attr_reader :dt_replicated
+  
+  # We do not allow the same key to be written twice, since a key uniquely
+  # designates the logged transaction request. This error is raised if a
+  # key is overwritten.
+  class KeyConflictError < StandardError; end
+
+  class Entry
+    # Node which wrote the entry.
+    attr_reader :node
+    
+    # Data payload.
+    attr_reader :value
+    
+    # When, in the global timeline, this entry is durable enough and the
+    # writing node has been notified that this is the case.
+    attr_reader :time_durable
+
+    # When, in the global timeline, this entry is completely replicated.
+    attr_reader :time_replicated
+    
+    def initialize node: raise, value: raise,
+        time_durable: raise, time_replicated: raise
+      @node, @value, @time_durable, @time_replicated =
+        node, value, time_durable, time_replicated
+    end
+    
+    # Returns true if the writing node believes the data to be durable.
+    def durable?
+      @node.time_now >= @time_durable
+    end
+    
+    # Returns true if +other_node+ can read the entry (i.e. it has been
+    # replicated to the nodes).
+    def readable_at? other_node
+      other_node == @node or other_node.time_now >= @time_replicated
+    end
+  end
+
+  def initialize dt_durable: 0.300, dt_replicated: 0.500
+    @dt_durable = dt_durable
+    @dt_replicated = dt_replicated
+    @store = {}
+  end
+  
+  # Returns true if the writing node believes the data at +key+ is durable.
+  def durable? key
+    entry = @store[key]
+    entry && entry.durable?
+  end
+  
+  def time_durable key
+    @store[key].time_durable
+  end
+
+  def when_durable key, **event_opts
+    entry = @store[key]
+    entry.node.timeline.schedule Spinoza::Event[
+      time: entry.time_durable,
+      **event_opts
+    ]
+  end
+
+  def time_replicated key
+    @store[key].time_replicated
+  end
+
+  # Returns the entry.
+  def write key, value, node: raise
+    raise KeyConflictError if @store[key] or not value
+    @store[key] =
+      Entry.new node: node, value: value,
+        time_durable: node.time_now + dt_durable,
+        time_replicated: node.time_now + dt_replicated
+  end
+  
+  # Returns the value if the data has been propagated to +node+, otherwise,
+  # returns nil.
+  def read key, node: raise
+    entry = @store[key]
+    entry && entry.readable_at?(node) ? entry.value : nil
+  end
+end

data/lib/spinoza/system/meta-log.rb

@@ -0,0 +1,103 @@
+require 'spinoza/system/timeline'
+
+# Model of synchronously replicated, linearizable global log, such as Zookeeper.
+class Spinoza::MetaLog
+  # Time to replicate a write to a quorum of MetaLog nodes, and for a unique
+  # sequence number to be assigned, and for that to be communicated to the
+  # writer node.
+  attr_reader :dt_quorum
+  
+  # Delay for a write to become "completely" replicated: readable at all nodes.
+  # Adjust this quantity for your network performance.
+  attr_reader :dt_replicated
+
+  class Entry
+    # Node which wrote the entry.
+    attr_reader :node
+    
+    # Data payload.
+    attr_reader :value
+    
+    # When, in the global timeline, this entry has reached a quorum and the
+    # writing node has been notified that this is the case.
+    attr_reader :time_quorum
+
+    # When, in the global timeline, this entry is completely replicated.
+    attr_reader :time_replicated
+    
+    def initialize node: raise, value: raise,
+        time_quorum: raise, time_replicated: raise
+      @node, @value, @time_quorum, @time_replicated =
+        node, value, time_quorum, time_replicated
+    end
+    
+    # Returns true if the writing node knows the data is at a quorum.
+    def quorum?
+      @node.time_now >= @time_quorum
+    end
+    
+    # Returns true if +other_node+ can read the entry (i.e. it has been
+    # replicated to the nodes).
+    def readable_at? other_node
+      other_node == @node or other_node.time_now >= @time_replicated
+    end
+  end
+
+  def initialize dt_quorum: 0.300, dt_replicated: 0.500
+    @dt_quorum = dt_quorum
+    @dt_replicated = dt_replicated
+    @store = []
+    @replication_listeners = []
+  end
+  
+  # Returns true if the writing node knows that the data at +id+ has been
+  # replicated to a quorum of nodes.
+  def quorum? id
+    entry = @store[id]
+    entry && entry.quorum?
+  end
+  
+  def time_quorum id
+    @store[id].time_quorum
+  end
+
+  def time_replicated id
+    @store[id].time_replicated
+  end
+
+  # Request that, whenever a new entry is created, an event be added to the
+  # schedule that will fire at entry.time_replicated. The event will send
+  # the method named `action` to `actor`, with id, node, and value arguments.
+  # Note that events fire in id order (because of the strong consistency
+  # guarantees that the meta-log's underlying store is assumed to have).
+  def on_entry_available actor, action
+    @replication_listeners << [actor, action]
+  end
+
+  # Append value to the MetaLog, assigning it a unique monotonically increasing
+  # ID. In our use case, the value will be a key (or batch of keys) of the Log.
+  # Returns an id, which can be used to retrieve the entry in the order it was
+  # appended. The returned id should only be used to observe the model, and not
+  # used within the model itself, since the id won't be available to the
+  # requesting process until `time_quorum(id)`.
+  def append value, node: raise
+    entry = Entry.new(node: node, value: value,
+      time_quorum: node.time_now + dt_quorum,
+      time_replicated: node.time_now + dt_replicated)
+    @store << entry
+    id = @store.size - 1
+    @replication_listeners.each do |actor, action|
+      node.timeline << Spinoza::Event[
+        time: entry.time_replicated, actor: actor, action: action,
+        id: id, node: node, value: value]
+    end
+    id
+  end
+  
+  # Returns the value if the data has been propagated to +node+, otherwise,
+  # returns nil.
+  def get id, node: raise
+    entry = @store[id]
+    entry && entry.readable_at?(node) ? entry.value : nil
+  end
+end

data/lib/spinoza/system/model.rb

@@ -0,0 +1,14 @@
+require 'spinoza/common'
+
+# Base class for all model classes that know about the passage of time.
+class Spinoza::Model
+  attr_reader :timeline
+
+  def initialize timeline: nil
+    @timeline = timeline
+  end
+
+  def time_now
+    timeline.now
+  end
+end

data/lib/spinoza/system/node.rb

@@ -1,17 +1,66 @@
+require 'spinoza/system/model'
 require 'spinoza/system/store'
-require 'spinoza/system/table-spec'
+require 'spinoza/system/table'
 require 'spinoza/system/lock-manager'
 
-# A top level entity in the system model, representing on whole node of
-# the disrtibuted system, typically one per host.
-class Spinoza::Node
+# A top level entity in the system model, representing one node of
+# the distributed system, typically one per host. Nodes are connected by Links.
+# Node is stateful.
+class Spinoza::Node < Spinoza::Model
+  attr_reader :name
   attr_reader :store
   attr_reader :lock_manager
   
+  # Outgoing links to peer nodes, as a map `{node => link, ...}`.
+  # Use `links[node].send_message(msg)` to send a message to a peer.
+  # Use Node#recv to handle received messages.
+  attr_reader :links
+  
+  @next_name = 0
+  def self.new_name
+    @next_name.tap {@next_name += 1}.to_s
+  end
+
+  def new_name
+    Spinoza::Node.new_name
+  end
+  
   # Create a node whose store contains the specified tables and which has
   # its own lock manager.
-  def initialize *table_specs
-    @store = Store.new *table_specs
-    @lock_manager = LockManager.new
+  def initialize *tables, name: new_name, **rest
+    super **rest
+    @store = Spinoza::Store.new *tables
+    @name = name
+    @lock_manager = Spinoza::LockManager.new
+    @links = {}
+  end
+  
+  def inspect
+    "<Node #{name}>"
+  end
+  
+  def to_s
+    name.to_s
+  end
+  
+  def link dst, **opts
+    require 'spinoza/system/link'
+
+    if links[dst]
+      raise "Link from #{self} to #{dst} already exists."
+    end
+    links[dst] = Spinoza::Link[timeline: timeline, src: self, dst: dst, **opts]
+  end
+
+  def tables
+    store.tables
+  end
+  
+  class << self
+    alias [] new
+  end
+
+  def recv msg: raise
+    # Defined in subclasses.
   end
 end

data/lib/spinoza/system/operation.rb

@@ -23,7 +23,7 @@ module Spinoza
 
   class InsertOperation < Operation
     attr_reader :row
-    def initialize txn = nil, table: table, row: row
+    def initialize txn = nil, table: nil, row: nil
       @txn = txn
       @table, @row = table, row
     end
@@ -35,11 +35,15 @@ module Spinoza
     def check lm
       true
     end
+
+    def inspect
+      "<insert #{table}: #{row}>"
+    end
   end
 
   class UpdateOperation < Operation
     attr_reader :key, :row
-    def initialize txn = nil, table: table, row: row, key: key
+    def initialize txn = nil, table: nil, row: nil, key: nil
       @txn = txn
       @table, @key, @row = table, key, row
     end
@@ -51,11 +55,15 @@ module Spinoza
     def check lm
       lm.has_write_lock? table, key, txn
     end
+
+    def inspect
+      "<update #{table} #{key}: #{row}>"
+    end
   end
 
   class DeleteOperation < Operation
     attr_reader :key
-    def initialize txn = nil, table: table, key: key
+    def initialize txn = nil, table: nil, key: nil
       @txn = txn
       @table, @key = table, key
     end
@@ -63,17 +71,25 @@ module Spinoza
     def execute ds
       ds.where(key).delete
     end
+
+    def inspect
+      "<delete #{table} #{key}>"
+    end
   end
 
   class ReadOperation < Operation
     attr_reader :key
-    def initialize txn = nil, table: table, key: key
+    def initialize txn = nil, table: nil, key: nil
       @txn = txn
       @table, @key = table, key
     end
 
     def execute ds
-      ReadResult.new(op: self, val: ds.where(key).all)
+      ReadResult.new(op: self, val: ds.where(key).first)
+    end
+
+    def inspect
+      "<read #{table} #{key}>"
     end
   end
 
@@ -81,7 +97,7 @@ module Spinoza
   # particular time.
   class ReadResult
     attr_reader :op, :val
-    def initialize op: op, val: val
+    def initialize op: nil, val: nil
       @op, @val = op, val
     end
   end