more_rinda 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*~
+*.dat
+pkg/*
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,20 @@
+# MoreRinda
+
+## Summary
+
+Extension to rinda tuplespace
+
+- rinda_eval = simple parallel programming utility. runs a computation inside child process and returns the result via tuple.
+
+- ptuplespace = persistency later
+
+- njet = rinda's pattern matcher to match any changes.
+
+## Install
+
+gem install more_rinda
+
+
+## Example Usage.
+
+Please see "test" and "sample" directories for the usage.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/example/eval0.rb

@@ -0,0 +1,15 @@
+require 'rinda/tuplespace'
+require 'rinda/eval'
+
+place = Rinda::TupleSpace.new
+DRb.start_service
+
+10.times do |n|
+  Rinda::rinda_eval(place) do |ts|
+    [:sqrt, n, Math.sqrt(n)]
+  end
+end
+
+10.times do |n|
+  p place.read([:sqrt, n, nil])
+end

data/example/nqueen.rb

@@ -0,0 +1,78 @@
+require 'rinda/tuplespace'
+require 'rinda/eval'
+
+module NQueen
+  module_function
+  def concat(board, row)
+    board.each_with_index do |v, col|
+      check = (v - row).abs
+      return nil if check == 0
+      return nil if check == board.size - col
+    end
+    board + [row]
+  end
+
+  def nq(size, board=[])
+    found = 0
+    size.times do |row|
+      fwd = concat(board, row)
+      next unless fwd
+      return 1 if fwd.size == size
+      found += nq(size, fwd)
+    end
+    found
+  end
+
+  def nq2(size, r1, r2)
+    board = concat([r1], r2)
+    return 0 unless board
+    nq(size, board)
+  end
+end
+
+def invoke_engine(rinda, num)
+  num.times do
+    Rinda::rinda_eval(rinda) do |ts|
+      begin
+        while true
+          sym, size, r1, r2 = ts.take([:nq, Integer, Integer, Integer])
+          ts.write([:nq_ans, size, r1, r2, NQueen.nq2(size, r1, r2)])
+        end
+      rescue
+      end
+      [:nq_engine]
+    end
+  end
+end
+
+def write_q(rinda, size)
+  size.times do |r1|
+    size.times do |r2|
+      rinda.write([:nq, size, r1, r2])
+    end
+  end
+end
+
+def take_a(rinda, size)
+  found = 0
+  size.times do |r1|
+    size.times do |r2|
+      tuple = rinda.take([:nq_ans, size, r1, r2, nil])
+      found += tuple[4]
+    end
+  end
+  found
+end
+
+def resolve(rinda, size)
+  write_q(rinda, size)
+  take_a(rinda, size)
+end
+
+
+DRb.start_service
+rinda = Rinda::TupleSpace.new
+size = (ARGV.shift || '5').to_i
+
+invoke_engine(rinda, 4)
+puts resolve(rinda, size)

data/example/phil.rb

@@ -0,0 +1,62 @@
+require 'rinda/tuplespace'
+require 'rinda/eval'
+
+class Phil
+  def initialize(ts, n, num)
+    @ts = ts
+    @right = n
+    @left = (n + 1) % num
+  end
+
+  def run
+    while running?
+      do_it(:think)
+      @ts.take([:room_ticket])
+      @ts.take([:chopstick, @right])
+      @ts.take([:chopstick, @left])
+      do_it(:eat)
+      @ts.write([:chopstick, @right])
+      @ts.write([:chopstick, @left])
+      @ts.write([:room_ticket])
+    end
+  end
+  
+  def running?
+    @ts.read_all([:done]).size == 0
+  end
+  
+  def do_it(symbol)
+    sleep(rand)
+    @ts.write(p [symbol, @right])
+  end
+end
+
+def main
+  place = Rinda::TupleSpace.new
+  DRb.start_service
+
+  num = 10
+  num.times do |n|
+    place.write([:chopstick, n])
+    Rinda::rinda_eval(place) do |ts|
+      phil = Phil.new(ts, n, num)
+      phil.run
+      [:phil, n]
+    end
+  end
+
+  (num - 1).times do |n|
+  place.write([:room_ticket])
+  end
+  
+  sleep(10)
+  
+  place.write([:done])
+
+  num.times do |n|
+    place.take([:phil, n])
+    p [n, place.read_all([:think, n]).size]
+  end
+end
+
+main

data/example/rk09/agent.rb

@@ -0,0 +1,53 @@
+require 'thread'
+require 'drb/drb'
+require 'rinda/rinda'
+
+class Agent
+  def initialize(name, url, desc)
+    @tuple = [name, url, desc]
+    @inbox = Queue.new
+    @renewer = Rinda::SimpleRenewer.new(15)
+  end
+  
+  def pop
+    @inbox.pop
+  end
+  
+  def hello(name, url, desc)
+    @inbox.push([name, url, desc])
+    return @tuple
+  end
+
+  def meet(who)
+    tuple = who.hello(*@tuple)
+    @inbox.push(tuple)
+  end
+  
+  def enter(place)
+    place.write([:agent, @tuple[0], self], @renewer)
+  end
+
+  def broadcast(place)
+    place.read_all([:agent, String, DRbObject]).each do |k, name, ro|
+      next if name == @tuple[0]
+      ro.meet(self) rescue nil
+    end
+  end
+end
+
+DRb.start_service
+place = DRbObject.new_with_uri(ARGV.shift)
+
+name = ARGV.shift || 'your_nick'
+url = ARGV.shift || 'http://www.druby.org'
+desc = ARGV.shift || 'no comment is good comment'
+
+agent = Agent.new(name, url, desc)
+agent.enter(place)
+agent.broadcast(place)
+
+while true
+  p agent.pop
+end
+
+

data/example/rk09/card.rb

@@ -0,0 +1,10 @@
+require 'drb/drb'
+
+ro = DRbObject.new_with_uri(ARGV.shift)
+
+name = ARGV.shift || 'your_nick'
+url = ARGV.shift || 'http://www.druby.org'
+desc = ARGV.shift || 'no comment is good comment'
+
+p ro.exchange(name, url, desc)
+

data/example/rk09/card_holder.rb

@@ -0,0 +1,18 @@
+require 'rinda/tuplespace'
+require 'rinda/njet'
+
+class CardHolder
+  def initialize
+    @ts = Rinda::TupleSpace.new
+    @ts.write(['m_seki', 'http://d.hatena.ne.jp/m_seki', 'Hello, Again'])
+  end
+
+  def exchange(name, url, desc)
+    @ts.write([name, url, desc])
+    @ts.take([Rinda::Njet.new(name), nil, nil])
+  end
+end
+
+DRb.start_service('druby://:56789', CardHolder.new)
+puts DRb.uri
+DRb.thread.join

data/example/rk09/place.rb

@@ -0,0 +1,17 @@
+require 'rinda/tuplespace'
+require 'rinda/inspect'
+require 'rinda/njet'
+
+ts = Rinda::TupleSpace.new(15)
+DRb.start_service('druby://:56788', ts)
+
+while true
+  puts
+  puts DRb.uri
+  ts.report.tuple.each do |t|
+    p [t[0], t[1], t[2].__drburi]
+  end
+  sleep 10
+end
+
+

data/example/sleeping_barber_actor.rb

@@ -0,0 +1,85 @@
+require 'thread'
+
+class ActorsOffice
+  def initialize(actor)
+    @queue = Queue.new
+    @thread = Thread.new(actor) do
+      catch(actor) do
+        while true
+          msg, arg, blk = @queue.pop
+          actor.__send__(msg, *arg, &blk)
+        end
+      end
+    end
+  end
+  def __thread__; @thread; end
+
+  def method_missing(m, *a, &b)
+    @queue.push([m, a, b])
+  end
+end
+
+class BarberShop
+  def initialize
+    @chairs = []
+  end
+
+  def barber=(barber)
+    @barber = barber
+  end
+
+  def new_customer(name)
+    puts "<< arriving #{name}"
+    if (@chairs.size >= 3)
+      puts "** sorry, no room for #{name} **"
+    else
+      @chairs << name
+      @barber.wake_up
+    end
+  end
+
+  def customer_leaves
+    barber_check
+  end
+
+  def barber_check
+    @barber.customer(@chairs.shift) unless @chairs.empty?
+  end
+
+  def quit
+    puts 'quit'
+    throw(self)
+  end
+end
+
+class Barber
+  def initialize(shop)
+    @shop = shop
+  end
+
+  def cut(name)
+    puts "cutting #{name}."
+    sleep(rand(5))
+    puts "finishing cutting #{name}.>>"
+    @shop.customer_leaves
+  end
+
+  def wake_up
+    @shop.barber_check
+  end
+
+  def customer(name)
+    cut(name)
+    @shop.barber_check
+  end
+end
+
+shop = ActorsOffice.new(BarberShop.new)
+shop.barber = ActorsOffice.new(Barber.new(shop))
+
+%w(jack john henry tom bob m_seki makoto).each do |name|
+  shop.new_customer(name)
+  sleep(1)
+end
+
+gets

data/example/sleeping_barber_rinda.rb

@@ -0,0 +1,102 @@
+require 'rinda/tuplespace'
+require 'rinda/eval'
+
+class BarberShop
+  def initialize(ts)
+    @ts = ts
+    @waiting = []
+  end
+
+  def start
+    @ts.write([:shop, @waiting])
+    while true
+      addr, msg, arg = @ts.take([:shop, nil, nil])
+      case msg
+      when :new_customer
+        name = arg
+        puts "<< arriving #{name}"
+        if (@waiting.size >= 3)
+          puts "** sorry, no room for #{name} **"
+        else
+          @waiting << name
+          @ts.write([:barber, :wake_up, nil])
+        end
+      when :customer_leaves
+        puts "leaving #{@waiting.shift}>>"
+        @ts.write([:barber, :customer, @waiting[0]])
+      when :barber_check
+        @ts.write([:barber, :customer, @waiting[0]])
+      when :quit
+        return
+      end
+      @ts.take([:shop, nil])
+      @ts.write([:shop, @waiting])
+    end
+  end
+end
+
+class Barber
+  def initialize(ts)
+    @ts = ts
+  end
+
+  def start
+    @ts.write([:barber, 'sleep'])
+    while true
+      addr, msg, arg = @ts.take([:barber, nil, nil])
+      case msg
+      when :wake_up
+        @ts.take([:barber, nil])
+        @ts.write([:barber, 'wake up'])
+        @ts.write([:shop, :barber_check, nil])
+      when :customer
+        if arg
+          cut(arg)
+          @ts.write([:shop, :customer_leaves, nil])
+        else
+          puts "                     sleeping"
+          @ts.take([:barber, nil])
+          @ts.write([:barber, 'sleep'])
+        end
+      when :quit
+        return
+      end
+    end
+  end
+
+  def cut(name)
+    puts "                     cutting #{name}."
+    rand(5).times do
+      puts "                        cutting..."
+      sleep(1)
+    end
+    puts "                     finishing cutting #{name}."
+  end
+end
+
+place = Rinda::TupleSpace.new
+DRb.start_service('druby://localhost:0')
+
+Rinda::rinda_eval(place) do |ts|
+  BarberShop.new(ts).start
+  [:shop]
+end
+
+Rinda::rinda_eval(place) do |ts|
+  Barber.new(ts).start
+  [:barber]
+end
+
+%w(jack john henry tom bob m_seki makoto).each do |name|
+  place.write([:shop, :new_customer, name])
+  sleep(2)
+end
+
+p place.read([:shop, []])
+p place.read([:barber, 'sleep'])
+
+place.write([:shop, :quit, nil])
+place.write([:barber, :quit, nil])
+
+p place.take([:shop])
+p place.take([:barber])

data/install.rb

@@ -0,0 +1,11 @@
+require 'rbconfig'
+require 'fileutils'
+
+dest = RbConfig::CONFIG['sitelibdir'] + '/rinda'
+src = ['lib/rinda/eval.rb']
+
+FileUtils.mkdir_p(dest, {:verbose => true})
+src.each do |s|
+  FileUtils.install(s, dest, {:verbose => true, :mode => 0644})
+end
+                  

data/lib/rinda/eval.rb

@@ -0,0 +1,19 @@
+require 'drb/drb'
+require 'rinda/rinda'
+
+module Rinda
+  module_function
+  def rinda_eval(ts)
+    Thread.pass # FIXME
+    ts = DRbObject.new(ts) unless DRbObject === ts
+    pid = fork do
+      Thread.current['DRb'] = nil
+      DRb.stop_service
+      DRb.start_service
+      place = TupleSpaceProxy.new(ts)
+      tuple = yield(place)
+      place.write(tuple) rescue nil
+    end
+    Process.detach(pid)
+  end
+end

data/lib/rinda/inspect.rb

@@ -0,0 +1,63 @@
+require 'drb/drb'
+require 'rinda/tuplespace'
+
+module Rinda
+  class TupleSpace
+    attr_reader :bag, :read_waiter, :take_waiter, :notify_waiter
+
+    def report
+      synchronize do
+        TupleSpaceReport.new(self)
+      end
+    end
+  end
+
+  class TupleBag
+    include Enumerable
+    def each(&blk)
+      each_entry(&blk)
+    end
+  end
+
+  class WaitTemplateEntry
+    attr_reader :cond
+  end
+
+  class TupleSpaceReport
+    def initialize(ts)
+      @tuple = ts.bag.collect {|t| t.value}
+      @reader = ts.read_waiter.collect {|t| [t.value, waiters(t)]}
+      @taker = ts.take_waiter.collect {|t| [t.value, waiters(t)]}
+    end
+    attr_reader :tuple, :reader, :taker
+
+    def waiters(tuple)
+      tuple.cond.instance_variable_get(:@waiters).collect do |th|
+        [th, (th[:DRb]['client'].stream.peeraddr rescue nil)]
+      end[0]
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'pp'
+
+  def report(ts)
+    pp ts.report
+  end
+  
+  ts = Rinda::TupleSpace.new
+  DRb.start_service(nil, ts)
+  p DRb.uri
+  
+  t1 = Thread.new { p ts.take([:hello, :world]) }
+  t2 = Thread.new { p ts.read([:hello, :nil]) }
+  sleep 1
+  report(ts)
+  ts.write([:hello, :world])
+  report(ts)
+  sleep 1
+  report(ts)
+  gets
+  report(ts)
+end

data/lib/rinda/njet.rb

@@ -0,0 +1,11 @@
+module Rinda
+  class Njet
+    def initialize(value)
+      @value = value
+    end
+    
+    def ===(other)
+      @value != other
+    end
+  end
+end

data/lib/rinda/ptuplespace.rb

@@ -0,0 +1,178 @@
+require 'rinda/tuplespace'
+require 'rinda/tuplestore'
+require 'singleton'
+require 'weakref'
+
+module Rinda
+  class PTupleEntryCache
+    include Singleton
+
+    def initialize
+      @cache = {}
+    end
+
+    def [](serial)
+      ref = @cache[serial]
+      return nil unless ref
+      it = ref.__getobj__
+      @cache.delete(serial) unless it
+      return it
+    end
+
+    def register(tuple)
+      @cache[tuple.serial] = WeakRef.new(tuple)
+    end
+  end
+
+  class PTupleEntry < TupleEntry
+    def self.new_with_desc(key, desc)
+      store = Rinda.tuple_store
+      it = allocate
+      it.instance_variable_set('@store', store)
+      it.instance_variable_set('@serial', key)
+      it.instance_variable_set('@tuple', desc[:tuple])
+      it.instance_variable_set('@expires', desc[:expires])
+      it.instance_variable_set('@cancel', desc[:cancel])
+      it.instance_variable_set('@renewer', desc[:renewer])
+      PTupleEntryCache.instance.register(it)
+      it
+    end
+
+    def to_store
+      { :tuple => @tuple,
+        :expires => @expires,
+        :cancel => @cancel,
+        :renewer => @renewer }
+    end
+
+    def initialize(*arg)
+      super(*arg)
+      @store = Rinda.tuple_store
+      @serial = @store.add(to_store)
+      PTupleEntryCache.instance.register(self)
+    end
+    attr_reader :serial
+
+    def cancel
+      super
+      @store.set_cancel(@serial)
+    end
+
+    def delete
+      @store.delete(@serial)
+    end
+
+    def expires=(it)
+      super(it)
+      @store.set_expires(@serial, it)
+    end
+
+    def renew(it)
+      old = @expires
+      super(it)
+      return unless @store
+      @store.set_expires(@serail, @expires) unless old == @expires
+    end
+  end
+
+  class PTupleSpace < TupleSpace
+    def initialize(*arg)
+      super(*arg)
+      @bag = PTupleBag.new
+    end
+
+    def create_entry(tuple, sec)
+      PTupleEntry.new(tuple, sec)
+    end
+
+    def restore
+      @bag.restore
+    end
+  end
+
+  class PTupleBag < TupleBag
+    def initialize(*var)
+      super(*var)
+    end
+    attr_reader :store
+
+    def delete(tuple)
+      it = super(tuple)
+      return nil unless it
+      tuple.delete
+      it
+    end
+
+    def restore
+      Rinda.tuple_store.each do |k, v|
+        tuple = PTupleEntry.new_with_desc(k, v)
+        push(tuple)
+        nil
+      end
+    end
+  end
+
+  class TupleStoreIdConv < DRb::DRbIdConv
+    def tuple_store?(ref)
+      return false unless ref.kind_of?(Array)
+      return false unless ref[0] == :TupleStoreId
+      return true
+    end
+
+    def to_obj(ref)
+      if tuple_store?(ref)
+        PTupleEntryCache.instance[ref[1]]
+      else
+        super(ref)
+      end
+    end
+
+    def to_id(obj)
+      if obj.class == PTupleEntry
+        [:TupleStoreId, obj.serial]
+      else
+        super(obj)
+      end
+    end
+  end
+
+  def setup_tuple_store(store)
+    raise "tuple_store was assinged" if @tuple_store
+    @tuple_store = store
+  end
+  module_function :setup_tuple_store
+
+  def tuple_store
+    @tuple_store
+  end
+  module_function :tuple_store
+end
+
+if __FILE__ == $0
+#  store = DRbObject.new_with_uri('druby://localhost:12345')
+  store = Rinda::TupleStoreLog.new('ts_log')
+  Rinda::setup_tuple_store(store)
+  
+  DRb.install_id_conv(Rinda::TupleStoreIdConv.new)
+  ts = Rinda::PTupleSpace.new
+  DRb.start_service('druby://localhost:23456', ts)
+  ts.restore
+#  sleep
+
+  ts.write(['Hello', 'World'])
+  p ts.read_all(['Hello', nil])
+  p ts.take(['Hello', nil])
+
+  x = ts.write(['Hello', 'cancel'], 2)
+  p ts.read_all(['Hello', nil])
+  ref = DRbObject.new(x)
+  ref.cancel
+  p ts.read_all(['Hello', nil])
+  x = ts.write(['Hello', 'World'])
+
+  p DRbObject.new(x)
+  
+  File.open('test.dat', 'wb') do |x|
+    Marshal.dump(store, x)
+  end 
+end

data/lib/rinda/tokyotuplestore.rb

@@ -0,0 +1,122 @@
+require 'rinda/tuplestore'
+require 'tokyocabinet'
+
+module Rinda
+  class TokyoStore < TupleStore
+    class BDBError < RuntimeError
+      def initialize(bdb)
+        super(bdb.errmsg(bdb.ecode))
+      end
+    end
+
+    class BDB < TokyoCabinet::BDB
+      def exception
+        BDBError.new(self)
+      end
+      
+      def cursor
+        TokyoCabinet::BDBCUR.new(self)
+      end
+      
+      def self.call_or_die(*ary)
+        file, lineno = __FILE__, __LINE__
+        if /^(.+?):(\d+)(?::in `(.*)')?/ =~ caller(1)[0]
+          file = $1
+          lineno = $2.to_i
+        end
+        ary.each do |sym|
+          module_eval("def #{sym}(*arg); super || raise(self); end",
+                      file, lineno)
+        end
+      end
+      
+      call_or_die :open, :close
+      call_or_die :tranbegin, :tranabort, :trancommit
+      call_or_die :vanish
+    end
+
+    include MonitorMixin
+    def initialize(name)
+      super()
+      @name = name
+      @bdb = BDB.new
+      writer {}
+    end
+
+    def transaction(mode)
+      synchronize do
+        begin
+          @bdb.open(@name, mode)
+          return yield
+        ensure
+          @bdb.close
+        end
+      end
+    end
+
+    def reader(&block)
+      transaction(BDB::OREADER, &block)
+    end
+
+    def writer(&block)
+      transaction(BDB::OWRITER | BDB::OCREAT, &block)
+    end
+
+    def load(val)
+      val ? Marshal.load(val) : nil
+    end
+
+    def each
+      reader do
+        cursor = @bdb.cursor
+        cursor.jump('t.')
+        while cursor.key
+          break unless /^t\.(\w+)/ =~ cursor.key
+          key = $1
+          desc = Hash.new
+          desc[:tuple] = load(cursor.val)
+          cursor.next
+          next unless desc[:tuple]
+          next if @bdb["c.#{key}"]
+          desc[:renewer] = load(@bdb["r.#{key}"])
+          desc[:expires] = load(@bdb["e.#{key}"])
+          yield(key, desc)
+        end
+      end
+    end
+
+    def add(desc)
+      writer do
+        ser = (@bdb['ser'] || 0).to_i + 1
+        @bdb['ser'] = ser
+        key = ser.to_s(36)
+        @bdb["t.#{key}"] = Marshal.dump(desc[:tuple])
+        @bdb["r.#{key}"] = Marshal.dump(desc[:renewer])
+        @bdb["e.#{key}"] = Marshal.dump(desc[:expires])
+        @bdb["c.#{key}"] = 't' if desc[:cancel]
+        return key
+      end
+    end
+    
+    def delete(key)
+      writer do
+        @bdb.out("t.#{key}")
+        @bdb.out("r.#{key}")
+        @bdb.out("e.#{key}")
+        @bdb.out("c.#{key}")
+      end
+    end
+
+    def set_cancel(key)
+      writer do
+        @bdb["c.#{key}"] = 't'
+      end
+    end
+
+    def set_expires(key, value)
+      writer do
+        @bdb["e.#{key}"] = Marshal.dump(value)
+      end
+    end
+  end
+end

data/lib/rinda/tuplestore.rb

@@ -0,0 +1,139 @@
+require 'rinda/tuplespace'
+require 'monitor'
+
+module Rinda
+  class TupleStore
+    def each; end
+    def add(desc); end
+    def delete(key); end
+    def set_cancel(key); end
+    def set_expires(key, value); end
+  end
+
+  class TupleStoreSimple < TupleStore
+    include MonitorMixin
+
+    def initialize
+      super()
+      @ser = 0
+      @hash = {}
+    end
+
+    def each
+      @hash.each do |k, v|
+        next unless v
+        next if v[:cancel]
+        yield(k, v) if v
+      end
+    end
+    
+    def add(desc)
+      synchronize do
+        @ser += 1
+        @hash[@ser] = desc
+        return @ser
+      end
+    end
+    
+    def delete(key)
+      @hash.delete(key)
+    end
+
+    def set_cancel(key)
+      return unless @hash[key]
+      @hash[key][:cancel] = true
+    end
+
+    def set_expires(key, value)
+      return unless @hash[key]
+      @hash[key][:expires] = value
+    end
+  end
+
+  class TupleStoreLog < TupleStore
+    include MonitorMixin
+
+    def initialize(log_dir)
+      super()
+      @log_dir = log_dir
+      Dir::mkdir(log_dir) rescue nil
+      @ser = 0
+      @hash = {}
+      restore
+    end
+
+    def each
+      @hash.each do |k, v|
+        next unless v
+        next if v[:cancel]
+        yield(k, v) if v
+      end
+    end
+    
+    def add(desc)
+      synchronize do
+        @ser += 1
+        @hash[@ser] = desc
+        File.open(File.join(@log_dir, @ser.to_s), 'wb') do |f|
+          Marshal.dump(desc, f)
+        end
+        return @ser
+      end
+    end
+    
+    def delete(key)
+      synchronize do
+        @hash.delete(key)
+        fname = File.join(@log_dir, key.to_s)
+        File.rename(fname, fname + '_del')
+        nil
+      end
+    end
+
+    def set_attr(key, name, value)
+      synchronize do
+        return unless @hash[key]
+        @hash[key][name] = value
+        fname = File.join(@log_dir, key.to_s)
+        File.open(fname + 'tmp', 'wb') do |f|
+          Marshal.dump(@hash[key], f)
+        end
+        File.rename(fname + 'tmp', fname)
+      end
+    end
+
+    def set_cancel(key)
+      set_attr(key, :cancel, true)
+    end
+
+    def set_expires(key, value)
+      set_attr(key, :expires, value)
+    end
+
+    def restore
+      Dir.foreach(@log_dir) do |file|
+        num = desc = nil
+        if /([0-9]+)(_del)?/ =~ file
+          num = $1.to_i
+          @ser = num if @ser < num
+          next if $2
+          begin
+            File.open(File.join(@log_dir, file), 'rb') do |f|
+              desc = Marshal.load(f)
+              @hash[num] = desc
+            end
+          rescue
+          end
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  uri = ARGV.shift || 'druby://localhost:12345'
+  store = Rinda::TupleStoreLog.new('ts_log')
+  DRb.start_service(uri, store)
+  DRb.thread.join
+end
+

data/lib/rinda/version.rb

@@ -0,0 +1,3 @@
+module MoreRinda
+  VERSION = "0.0.1"
+end

data/more_rinda.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rinda/version"
+
+Gem::Specification.new do |s|
+  s.name        = "more_rinda"
+  s.version     = MoreRinda::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Masatoshi Seki"]
+  s.homepage    = "https://github.com/seki/MoreRinda"
+  s.summary     = %q{Various extensions for Rinda::TupleSpace lovers.}
+  s.description = ""
+
+  s.rubyforge_project = "drip"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/ptuplespace_sample.rb

@@ -0,0 +1,25 @@
+require 'rinda/ptuplespace'
+
+#  store = DRbObject.new_with_uri('druby://localhost:12345')
+store = Rinda::TupleStoreLog.new('ts_log')
+Rinda::setup_tuple_store(store)
+  
+DRb.install_id_conv(Rinda::TupleStoreIdConv.new)
+ts = Rinda::PTupleSpace.new
+DRb.start_service('druby://localhost:23456', ts)
+ts.restore
+#  sleep
+
+ts.write(['Hello', 'World'])
+p ts.read_all(['Hello', nil])
+p ts.take(['Hello', nil])
+
+x = ts.write(['Hello', 'cancel'], 2)
+p ts.read_all(['Hello', nil])
+ref = DRbObject.new(x)
+ref.cancel
+p ts.read_all(['Hello', nil])
+x = ts.write(['Hello', 'World'])
+
+p DRbObject.new(x)
+

data/test/test_njet.rb

@@ -0,0 +1,34 @@
+require 'rinda/tuplespace'
+require 'rinda/njet'
+require 'test/unit'
+
+class NjetTest < Test::Unit::TestCase
+  include Rinda
+  def test_match
+    ts = Rinda::TupleSpace.new
+    assert_equal([], ts.read_all([Njet.new(10)]))
+    ts.write([10])
+    assert_equal([], ts.read_all([Njet.new(10)]))
+    ts.write([11])
+    assert_equal([[11]], ts.read_all([Njet.new(10)]))
+    ts.write([12])
+    assert_equal([[11], [12]], ts.read_all([Njet.new(10)]).sort)
+  end
+
+  def test_wait_for_change
+    ts = Rinda::TupleSpace.new
+
+    ts.write([:state, 1])
+    _, last_state = ts.read([:state, nil])
+
+    assert_raise(Rinda::RequestExpiredError) do
+      ts.read([:state, Njet.new(last_state)], 0)
+    end
+
+    tuple = ts.take([:state, nil])
+    tuple[1] += 1
+    ts.write(tuple)
+
+    assert_equal([:state, 2], ts.read([:state, Njet.new(last_state)], 0))
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: more_rinda
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Masatoshi Seki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-09 00:00:00 Z
+dependencies: []
+
+description: ""
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- example/eval0.rb
+- example/nqueen.rb
+- example/phil.rb
+- example/rk09/agent.rb
+- example/rk09/card.rb
+- example/rk09/card_holder.rb
+- example/rk09/place.rb
+- example/sleeping_barber_actor.rb
+- example/sleeping_barber_rinda.rb
+- install.rb
+- lib/rinda/eval.rb
+- lib/rinda/inspect.rb
+- lib/rinda/njet.rb
+- lib/rinda/ptuplespace.rb
+- lib/rinda/tokyotuplestore.rb
+- lib/rinda/tuplestore.rb
+- lib/rinda/version.rb
+- more_rinda.gemspec
+- test/ptuplespace_sample.rb
+- test/test_njet.rb
+homepage: https://github.com/seki/MoreRinda
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: drip
+rubygems_version: 1.8.6.1
+signing_key: 
+specification_version: 3
+summary: Various extensions for Rinda::TupleSpace lovers.
+test_files: 
+- test/ptuplespace_sample.rb
+- test/test_njet.rb