spinoza 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 868a9f9ccabcf28a96ace9484c9c0caf0bbacd26
+  data.tar.gz: 42d844a448adc075556b5933731bcb90e4a58356
+SHA512:
+  metadata.gz: 4c178a4b1cf1e14cf538dec9602c4a25eca2f57a003a8f8db2b2b92fb9b55feb9014979db38caabc6af9ce2f7fc26dfda73b564da454599fb8b054f80132585b
+  data.tar.gz: ae5bcbdf391a45950d1d3aa4efc0ac52f10d99d413f0ee96e639c179ecb054a311ae14ab3448d0ecbc22976162e02e22d71a0cbb4088e091aa193decb7a1c86a

data/COPYING

@@ -0,0 +1,22 @@
+Copyright (c) 2013-2014, Joel VanderWerf
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,22 @@
+spinoza
+=======
+
+A model of the Calvin distributed database.
+
+Spinoza, like Calvin, was a philosopher who dealt in determinism.
+
+The model of the underlying computer and network system is in lib/spinoza/system.
+
+Calvin is developed by the Yale Databases group; the open-source releases are at https://github.com/yaledb.
+
+Contact
+=======
+
+Joel VanderWerf, vjoel@users.sourceforge.net, [@JoelVanderWerf](https://twitter.com/JoelVanderWerf).
+
+License and Copyright
+========
+
+Copyright (c) 2014, Joel VanderWerf
+
+License for this project is BSD. See the COPYING file for the standard BSD license.

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rake'
+require 'rake/testtask'
+
+PRJ = "spinoza"
+
+def version
+  @version ||= begin
+    require 'spinoza/version'
+    warn "Spinoza::VERSION not a string" unless Spinoza::VERSION.kind_of? String
+    Spinoza::VERSION
+  end
+end
+
+def tag
+  @tag ||= "#{PRJ}-#{version}"
+end
+
+desc "Run all tests"
+task :test => %w{ test:unit }
+
+namespace :test do
+  desc "Run unit tests"
+  Rake::TestTask.new :unit do |t|
+    t.libs << "lib"
+    t.test_files = FileList["test/*.rb"]
+  end
+end
+
+desc "Commit, tag, and push repo; build and push gem"
+task :release => "release:is_new_version" do
+  require 'tempfile'
+  
+  sh "gem build #{PRJ}.gemspec"
+
+  file = Tempfile.new "template"
+  begin
+    file.puts "release #{version}"
+    file.close
+    sh "git commit --allow-empty -a -v -t #{file.path}"
+  ensure
+    file.close unless file.closed?
+    file.unlink
+  end
+
+  sh "git tag #{tag}"
+  sh "git push"
+  sh "git push --tags"
+  
+  sh "gem push #{tag}.gem"
+end
+
+namespace :release do
+  desc "Diff to latest release"
+  task :diff do
+    latest = `git describe --abbrev=0 --tags --match '#{PRJ}-*'`.chomp
+    sh "git diff #{latest}"
+  end
+
+  desc "Log to latest release"
+  task :log do
+    latest = `git describe --abbrev=0 --tags --match '#{PRJ}-*'`.chomp
+    sh "git log #{latest}.."
+  end
+
+  task :is_new_version do
+    abort "#{tag} exists; update version!" unless `git tag -l #{tag}`.empty?
+  end
+end

data/lib/spinoza/common.rb

@@ -0,0 +1,2 @@
+module Spinoza
+end

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

@@ -0,0 +1,154 @@
+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.
+class Spinoza::LockManager
+  class ConcurrencyError < StandardError; end
+  
+  # State of lock on one resource (e.g., a row), which may be held concurrently
+  # by any number of threads. Reentrant.
+  class ReadLock
+    attr_reader :txns
+
+    def initialize txn
+      @txns = Hash.new(0)
+      add txn
+    end
+    
+    def unlocked?
+      @txns.all? {|t,c| c == 0}
+    end
+    
+    def includes? txn
+      @txns[txn] > 0
+    end
+    
+    def add txn
+      @txns[txn] += 1
+    end
+    
+    def remove txn
+      if includes? txn
+        @txns[txn] -= 1
+        @txns.delete txn if @txns[txn] == 0
+      else
+        raise ConcurrencyError, "#{self} is not locked by #{txn}"
+      end
+    end
+  end
+
+  # State of lock on one resource (e.g., a row), which may be held concurrently
+  # by at most one thread. Reentrant.
+  class WriteLock
+    attr_reader :txn, :count
+
+    def initialize txn
+      @txn = txn
+      @count = 1
+    end
+    
+    def unlocked?
+      @txn == nil
+    end
+
+    def includes? txn
+      @txn == txn && @count > 0
+    end
+    
+    def add txn
+      if includes? txn
+        @count += 1
+      else
+        raise ConcurrencyError, "#{self} is not locked by #{txn}"
+      end
+    end
+
+    def remove txn
+      if includes? txn
+        @count -= 1
+        @txn = nil if @count == 0
+      else
+        raise ConcurrencyError, "#{self} is not locked by #{txn}"
+      end
+    end
+  end
+
+   # { resource => WriteLock | ReadLock | nil, ... }
+   # typically, resource == [table, key]
+  attr_reader :locks
+  
+  def initialize
+    @locks = {}
+  end
+  
+  def lock_read resource, txn
+    case lock = locks[resource]
+    when nil
+      locks[resource] = ReadLock.new(txn)
+    when ReadLock
+      lock.add txn
+    when WriteLock
+      raise ConcurrencyError, "#{resource} is locked: #{lock}"
+    else raise
+    end
+  end
+  
+  def lock_write resource, txn
+    case lock = locks[resource]
+    when nil
+      locks[resource] = WriteLock.new(txn)
+    when WriteLock
+      lock.add txn
+    when ReadLock
+      raise ConcurrencyError, "#{resource} is locked: #{lock}"
+    else raise
+    end
+  end
+  
+  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
+      begin
+        lock.remove txn
+        locks.delete resource if lock.unlocked?
+      rescue ConcurrencyError => ex
+        raise ConcurrencyError "#{resource}: #{ex.message}"
+      end
+    else raise
+    end
+  end
+  
+  def unlock_write resource, txn
+    lock = locks[resource]
+    case lock
+    when ReadLock
+      raise ConcurrencyError, "#{resource} is read locked: #{lock}"
+    when nil
+      raise ConcurrencyError, "#{resource} is not locked"
+    when WriteLock
+      begin
+        lock.remove txn
+        locks.delete resource if lock.unlocked?
+      rescue ConcurrencyError => ex
+        raise ConcurrencyError "#{resource}: #{ex.message}"
+      end
+    else raise
+    end
+  end
+  
+  def has_read_lock? resource, txn
+    lock = locks[resource]
+    lock.kind_of?(ReadLock) && lock.includes?(txn)
+  end
+  
+  def has_write_lock? resource, txn
+    lock = locks[resource]
+    lock.kind_of?(WriteLock) && lock.includes?(txn)
+  end
+end

data/lib/spinoza/system/node.rb

@@ -0,0 +1,17 @@
+require 'spinoza/system/store'
+require 'spinoza/system/table-spec'
+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
+  attr_reader :store
+  attr_reader :lock_manager
+  
+  # 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
+  end
+end

data/lib/spinoza/system/operation.rb

@@ -0,0 +1,88 @@
+require 'spinoza/common'
+
+module Spinoza
+  # Operations are stateless and do not reference any particular store. Hence
+  # they can be serialized and passed around the system.
+  class Operation
+    # Name of table.
+    attr_reader :table
+
+    # Transaction this operation belongs to.
+
+    # ds is Sequel dataset representing the table
+    def execute ds
+      raise
+    end
+
+    # check that this operation is allowed to execute
+    # lm is LockManager
+    def check lm
+      raise
+    end
+  end
+
+  class InsertOperation < Operation
+    attr_reader :row
+    def initialize txn = nil, table: table, row: row
+      @txn = txn
+      @table, @row = table, row
+    end
+
+    def execute ds
+      ds << row
+    end
+
+    def check lm
+      true
+    end
+  end
+
+  class UpdateOperation < Operation
+    attr_reader :key, :row
+    def initialize txn = nil, table: table, row: row, key: key
+      @txn = txn
+      @table, @key, @row = table, key, row
+    end
+
+    def execute ds
+      ds.where(key).update(row)
+    end
+
+    def check lm
+      lm.has_write_lock? table, key, txn
+    end
+  end
+
+  class DeleteOperation < Operation
+    attr_reader :key
+    def initialize txn = nil, table: table, key: key
+      @txn = txn
+      @table, @key = table, key
+    end
+
+    def execute ds
+      ds.where(key).delete
+    end
+  end
+
+  class ReadOperation < Operation
+    attr_reader :key
+    def initialize txn = nil, table: table, key: key
+      @txn = txn
+      @table, @key = table, key
+    end
+
+    def execute ds
+      ReadResult.new(op: self, val: ds.where(key).all)
+    end
+  end
+
+  # Result of executing a read operation on a particular node at a
+  # particular time.
+  class ReadResult
+    attr_reader :op, :val
+    def initialize op: op, val: val
+      @op, @val = op, val
+    end
+  end
+end

data/lib/spinoza/system/store.rb

@@ -0,0 +1,44 @@
+require 'sequel'
+require 'spinoza/system/operation'
+
+# Represents the storage at one node. In our model, this consists of an
+# in-memory sqlite database with some very simple tables.
+class Spinoza::Store
+  def initialize *table_specs
+    @db = Sequel.sqlite
+    @table_specs = table_specs
+
+    table_specs.each do |table_spec|
+      @db.create_table table_spec.name do
+        table_spec.column_specs.each do |col|
+          case col.type
+          when "integer", "string", "float"
+            column col.name, col.type, primary_key: col.primary
+          else
+            raise ArgumentError,
+              "Bad col.type: #{col.type} in table #{table_spec.name}"
+          end
+        end
+      end
+    end
+  end
+  
+  def tables
+    @db.tables
+  end
+  
+  def inspect
+    "<#{self.class.name}: #{tables.join(', ')}>"
+  end
+  
+  # Execute the operations on this store, skipping any that do not refer to
+  # a table in this store.
+  def execute *operations
+    results = operations.map do |op|
+      if tables.include? op.table
+        op.execute @db[op.table]
+      end
+    end
+    results.grep(ReadResult)
+  end
+end

data/lib/spinoza/system/table-spec.rb

@@ -0,0 +1,31 @@
+require 'spinoza/common'
+
+# Defines the schema for one table in all replicas.
+class Spinoza::TableSpec
+  attr_reader :name
+  attr_reader :column_specs
+  
+  class ColumnSpec
+    attr_reader :name
+    attr_reader :type
+    attr_reader :primary
+    
+    def initialize name, type, primary
+      @name, @type, @primary = name, type, primary
+    end
+  end
+  
+  # Usage:
+  #
+  #   create_table :Widgets, id: "integer", weight: "float", name: "string"
+  #
+  # The first column is the primary key for the table.
+  #
+  def initialize name, **specs
+    @name = name
+    @column_specs = []
+    specs.each_with_index do |(col_name, col_type), i|
+      @column_specs << ColumnSpec.new(col_name, col_type, (i==0))
+    end
+  end
+end

data/lib/spinoza/transaction.rb

@@ -0,0 +1,56 @@
+require 'spinoza/system/operation'
+
+class Spinoza::Transaction
+  attr_reader :ops
+
+  class RowLocation
+    def initialize txn, table, key
+      @txn, @table, @key = txn, table, key
+    end
+    
+    def insert row
+      @txn.ops << InsertOperation.new(@txn, table: @table, row: row)
+    end
+
+    def update row
+      @txn.ops << UpdateOperation.new(@txn, table: @table, row: row, key: @key)
+    end
+
+    def delete
+      @txn.ops << DeleteOperation.new(@txn, table: @table, key: @key)
+    end
+
+    def read
+      @txn.ops << ReadOperation.new(@txn, table: @table, key: @key)
+    end
+  end
+
+  # A txn is just a list of operations, each on a specific table and key.
+  # The ACID guarantees are not provided by this class.
+  #
+  # Example:
+  #
+  # txn = transaction do
+  #   at(:persons, name: "Fred").update(age: 41, phrase: "yabba dabba doo")
+  #   at(:persons, name: "Wilma").delete
+  #   at(:persons, name: "Barney").read
+  #   at(:persons).insert(name: "Betty", age: 65)
+  # end
+  #
+  # node.store.execute txn # ==> [ReadResult(...)]
+  #
+  def initialize &block
+    @ops = []
+    if block
+      if block.arity == 0
+        instance_eval &block
+      else
+        yield self
+      end
+    end
+  end
+  
+  def at table, **key
+    RowLocation.new(self, table, key)
+  end
+end

data/lib/spinoza/version.rb

@@ -0,0 +1,3 @@
+module Spinoza
+  VERSION = "0.1"
+end

data/test/test-node.rb

@@ -0,0 +1,87 @@
+require 'minitest/autorun'
+require 'spinoza/system/node'
+
+include Spinoza
+
+class TestNode < Minitest::Test
+  def setup
+    @node = Node.new(
+      TableSpec.new :foos, id: "integer", name: "string", len: "float"
+    )
+  end
+  
+  def test_store
+    assert_equal [:foos], @node.store.tables
+  end
+  
+  def test_ops
+    store = @node.store
+    
+    op_i = InsertOperation.new(table: :foos, row: {id: 1, name: "a", len: 1.2})
+    op_r = ReadOperation.new(table: :foos, key: {id: 1})
+    rslt = store.execute op_i, op_r
+    
+    assert_equal(1, rslt.size)
+    r_tuples = rslt[0].val
+    assert_equal(1, r_tuples.size)
+    assert_equal({id: 1, name: "a", len: 1.2}, r_tuples[0])
+    
+    op_u = UpdateOperation.new(table: :foos, key: {id: 1}, row: {name: "b"})
+    rslt = store.execute op_u, op_r
+    
+    assert_equal(1, rslt.size)
+    r_tuples = rslt[0].val
+    assert_equal(1, r_tuples.size)
+    assert_equal({id: 1, name: "b", len: 1.2}, r_tuples[0])
+
+    op_d = DeleteOperation.new(table: :foos, key: {id: 1})
+    rslt = store.execute op_d, op_r
+    assert_equal(1, rslt.size)
+    r_tuples = rslt[0].val
+    assert_equal(0, r_tuples.size)
+  end
+  
+  def test_locks
+    lm = @node.lock_manager
+    
+    rs1 = [:foos, 1]
+    rs2 = [:foos, 2]
+    
+    lm.lock_read rs1, :t1
+    assert lm.has_read_lock?(rs1, :t1)
+    refute lm.has_read_lock?(rs1, :t2)
+
+    lm.lock_read rs1, :t2
+    assert lm.has_read_lock?(rs1, :t1)
+    assert lm.has_read_lock?(rs1, :t2)
+
+    lm.unlock_read rs1, :t1
+    refute lm.has_read_lock?(rs1, :t1)
+    assert lm.has_read_lock?(rs1, :t2)
+    
+    assert_raises LockManager::ConcurrencyError do
+      lm.lock_write rs1, :t1
+    end
+
+    lm.lock_read rs1, :t2
+    assert lm.has_read_lock?(rs1, :t2)
+    lm.unlock_read rs1, :t2
+    assert lm.has_read_lock?(rs1, :t2)
+    lm.unlock_read rs1, :t2
+    refute lm.has_read_lock?(rs1, :t2)
+    
+    lm.lock_write rs2, :t1
+    assert lm.has_write_lock?(rs2, :t1)
+    assert_raises LockManager::ConcurrencyError do
+      lm.lock_read rs2, :t2
+    end
+    assert lm.has_write_lock?(rs2, :t1)
+
+    lm.lock_write rs2, :t1
+    assert lm.has_write_lock?(rs2, :t1)
+    lm.unlock_write rs2, :t1
+    assert lm.has_write_lock?(rs2, :t1)
+    lm.unlock_write rs2, :t1
+    refute lm.has_write_lock?(rs2, :t1)
+  end
+end

data/test/test-transaction.rb

@@ -0,0 +1,37 @@
+require 'minitest/autorun'
+require 'spinoza/system/node'
+require 'spinoza/transaction'
+
+include Spinoza
+
+class TestTransaction < Minitest::Test
+  def setup
+    @node = Node.new(
+      TableSpec.new :foos, id: "integer", name: "string", len: "float"
+    )
+  end
+  
+  def test_txn
+    txn = Transaction.new do
+      at(:foos).insert id: 1, name: "a", len: 1.2
+      at(:foos).insert id: 2, name: "b", len: 3.4
+      at(:foos, id: 2).read
+      at(:foos).insert id: 3, name: "c", len: 5.6
+      at(:foos, id: 2).delete
+      at(:foos, id: 2).read
+      at(:foos, id: 3).update len: 7.8
+      at(:foos, id: 3).read
+    end
+    
+    rslt = @node.store.execute(*txn.ops)
+    assert_equal(3, rslt.size)
+
+    assert_equal(1, rslt[0].val.size)
+    assert_equal({id: 2, name: "b", len: 3.4}, rslt[0].val[0])
+
+    assert_equal(0, rslt[1].val.size)
+
+    assert_equal(1, rslt[2].val.size)
+    assert_equal({id: 3, name: "c", len: 7.8}, rslt[2].val[0])
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: spinoza
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Joel VanderWerf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Model of Calvin distributed database.
+email: vjoel@users.sourceforge.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- COPYING
+files:
+- COPYING
+- README.md
+- Rakefile
+- lib/spinoza/common.rb
+- lib/spinoza/system/link.rb
+- lib/spinoza/system/lock-manager.rb
+- lib/spinoza/system/node.rb
+- lib/spinoza/system/operation.rb
+- lib/spinoza/system/store.rb
+- lib/spinoza/system/table-spec.rb
+- lib/spinoza/transaction.rb
+- lib/spinoza/version.rb
+- test/test-node.rb
+- test/test-transaction.rb
+homepage: https://github.com/vjoel/spinoza
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- spinoza
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Model of Calvin distributed database.
+test_files:
+- test/test-node.rb
+- test/test-transaction.rb
+has_rdoc: