fsevent 0.1

data/lib/fsevent/periodicschedule.rb

@@ -0,0 +1,34 @@
+# periodicschedule.rb --- periodic schedule
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class FSEvent::PeriodicSchedule
+  def initialize(initial_time, interval)
+    @initial_time = initial_time
+    @interval = interval
+    @n = 0
+  end
+
+  def first
+    @initial_time + @n * @interval
+  end
+
+  def shift
+    t = first
+    @n += 1
+    t
+  end
+end

data/lib/fsevent/processdevice.rb

@@ -0,0 +1,93 @@
+# processdevice.rb --- run device on another process
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class FSEvent::ProcessDevice < FSEvent::AbstractDevice
+  def self.spawner(defs)
+    Spawner.new(defs)
+  end
+
+  class Spawner
+    def initialize(defs)
+      @defs = defs
+    end
+
+    def assemble_code(device_name, *args)
+      code = ''
+
+      libpath = File.dirname(File.dirname(__FILE__))
+      code << "$:.unshift #{libpath.dump}\n"
+
+      code << <<-'End'
+        require 'fsevent'
+        def ep(arg) STDERR.puts arg.inspect end
+      End
+
+      code << "class FSEvent::ProcessDevice_#{device_name} < FSEvent::ProcessDeviceC\n#{@defs}\nend\n"
+      marshaled_args = Marshal.dump(args)
+      code << "FSEvent::ProcessDeviceC.main(FSEvent::ProcessDevice_#{device_name}.new(#{device_name.dump}, *(Marshal.load(#{marshaled_args.dump}))))\n"
+    end
+
+    def new(device_name, *args)
+      code = assemble_code(device_name, *args)
+      io = IO.popen([RbConfig.ruby], "r+")
+      io.sync = true
+      io.write code
+      io.write "__END__\n"
+      FSEvent::ProcessDevice.send(:new, device_name, io)
+    end
+  end
+
+  class << self
+    private :new
+  end
+
+  def initialize(device_name, io)
+    super device_name
+    @io = io
+  end
+
+  def call_subprocess(method, *args)
+    Marshal.dump([:call_child, method, *args], @io)
+    msgtype, *rest = Marshal.load(@io)
+    while msgtype == :call_parent
+      method, *args = rest
+      ret = @framework.send(method, *args)
+      Marshal.dump([:return_to_child, ret], @io)
+      msgtype, *rest = Marshal.load(@io)
+    end
+    if msgtype != :return_to_parent
+      raise RuntimeError, "unexpected message type: #{msgtype.inspect}"
+    end
+    rest[0]
+  end
+  #private :call_subprocess
+
+  def finish
+    @io.close_write
+    @io.close
+    nil
+  end
+
+  def framework=(framework)
+    @framework = framework
+    call_subprocess(:processdevice_framework_set)
+  end
+
+  def registered
+    call_subprocess(:processdevice_registered)
+  end
+end

data/lib/fsevent/processdevicec.rb

@@ -0,0 +1,79 @@
+# processdevicec.rb --- child process code for processdevice.rb
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class FSEvent::ProcessDeviceC < FSEvent::AbstractDevice
+  class StubFramework
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def add_watch(watchee_device_name, status_name)
+      @obj.call_parent(:add_watch, watchee_device_name, status_name)
+    end
+
+    def status_changed(status_name, value)
+      @obj.call_parent(:status_changed, status_name, value)
+    end
+  end
+
+  def initialize(device_name)
+    super(device_name)
+  end
+
+  def processdevice_framework_set
+    framework = StubFramework.new(self)
+    self.framework = framework
+    nil
+  end
+
+  def processdevice_registered
+    registered
+    nil
+  end
+
+  def call_parent(method, *args)
+    Marshal.dump([:call_parent, method, *args], STDOUT)
+    msgtype, *rest = Marshal.load(STDIN)
+    while msgtype == :call_child
+      method, *args = rest
+      ret = self.send(method, *args)
+      Marshal.dump([:return_to_parent, ret], STDOUT)
+      msgtype, *rest = Marshal.load(STDIN)
+    end
+    if msgtype != :return_to_child
+      raise RuntimeError, "unexpected message type: #{msgtype.inspect}"
+    end
+    rest[0]
+  end
+
+  def self.main(this_device)
+    STDOUT.sync = true
+    while true
+      begin
+        msgtype, *rest = Marshal.load(STDIN)
+      rescue EOFError
+        exit true
+      end
+      if msgtype != :call_child
+        raise RuntimeError, "unexpected message type: #{msgtype.inspect}"
+      end
+      method, *args = rest
+      ret = this_device.send(method, *args)
+      Marshal.dump([:return_to_parent, ret], STDOUT)
+    end
+  end
+end

data/lib/fsevent/schedulemerger.rb

@@ -0,0 +1,48 @@
+# schedulemerger.rb --- merge multiple schedules
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class FSEvent::ScheduleMerger
+  def initialize(*schedules)
+    @q = Depq.new
+    schedules.each {|s|
+      merge_schedule(s)
+    }
+  end
+
+  def merge_schedule(s)
+    t = s.shift
+    if t
+      @q.insert s, t
+    end
+  end
+
+  def first
+    return nil if @q.empty?
+    @q.find_min_priority[1]
+  end
+
+  def shift
+    return nil if @q.empty?
+    s, t = @q.delete_min_priority
+    t2 = s.shift
+    if t2
+      @q.insert s, t2
+    end
+    t
+  end
+end
+

data/lib/fsevent/simpledevice.rb

@@ -0,0 +1,46 @@
+# simpledevice.rb --- simple device definition using constructor arguments
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+class FSEvent::SimpleDevice < FSEvent::AbstractDevice
+  def initialize(device_name, initial_status, watches, registered_elapsed_time, schedule=nil, &run_block)
+    super device_name
+    @name = device_name
+    @initial_status = initial_status
+    @watches = watches
+    @registered_elapsed_time = registered_elapsed_time
+    @schedule.merge_schedule schedule if schedule
+    @run_block = run_block
+  end
+  attr_writer :registered_elapsed_time
+
+  def registered
+    @initial_status.each {|status_name, value|
+      define_status status_name, value
+    }
+    @watches.each {|watchee_device_name, status_name, reaction|
+      reaction ||= :immediate
+      add_watch watchee_device_name, status_name, reaction
+    }
+    if @registered_elapsed_time
+      set_elapsed_time @registered_elapsed_time
+    end
+  end
+
+  def run(watched_status_change)
+    @run_block.call watched_status_change
+  end
+end

data/lib/fsevent/util.rb

@@ -0,0 +1,77 @@
+# util.rb --- various utilities
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module FSEvent::Util
+  module_function
+
+  def nested_hash(n)
+    if n == 1
+      {}
+    else
+      Hash.new {|h, k|
+        h[k] = nested_hash(n-1)
+      }
+    end
+  end
+
+  def nonempty_hash(h, level)
+    return nil if h.nil?
+    result = {}
+    h.each {|k, v|
+      if level == 1
+        result[k] = v
+      else
+        h2 = nonempty_hash(v, level-1)
+        if h2
+          result[k] = h2
+        end
+      end
+    }
+    if result.empty?
+      nil
+    else
+      result
+    end
+  end
+
+  def reaction_immediate_at_beginning?(reaction)
+    case reaction
+    when :immediate
+      true
+    when :immediate_only_at_beginning
+      true
+    when :schedule
+      false
+    else
+      raise "unexpected reaction: #{reaction.inspect}"
+    end
+  end
+
+  def reaction_immediate_at_subsequent?(reaction)
+    case reaction
+    when :immediate
+      true
+    when :immediate_only_at_beginning
+      false
+    when :schedule
+      false
+    else
+      raise "unexpected reaction: #{reaction.inspect}"
+    end
+  end
+
+end

data/sample/repeat.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/ruby
+
+require 'time'
+require 'fsevent'
+
+class Repeater < FSEvent::AbstractDevice
+  def initialize(name, schedule)
+    super name
+    @schedule = schedule
+  end
+
+  def run(watched_status_change)
+    @framework.set_elapsed_time(1)
+    p @framework.current_time.iso8601(3)
+  end
+end
+
+schedule = FSEvent::PeriodicSchedule.new(Time.utc(2000), 10)
+repeat = Repeater.new("repeat", schedule)
+
+fsevent = FSEvent.new(Time.utc(2000))
+fsevent.register_device(repeat)
+fsevent.start
+

data/sample/repeat2.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+
+require 'fsevent'
+
+class Repeater < FSEvent::AbstractDevice
+  def initialize(name, schedule)
+    super name
+    @schedule = schedule
+  end
+
+  def run(watched_status_change)
+    p [self.name, @framework.current_time]
+  end
+end
+
+repeat1 = Repeater.new("repeat1", FSEvent::PeriodicSchedule.new(Time.now, 3))
+repeat2 = Repeater.new("repeat2", FSEvent::PeriodicSchedule.new(Time.now, 10))
+
+fsevent = FSEvent.new
+fsevent.register_device(repeat1)
+fsevent.register_device(repeat2)
+fsevent.start
+

data/test/test_failsafedevice.rb

@@ -0,0 +1,159 @@
+# test_failsafedevice.rb --- tests for fail safe device
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'test/unit'
+require 'fsevent'
+
+class TestFSEventFailSafeDevice < Test::Unit::TestCase
+  class SrcDevice < FSEvent::AbstractDevice
+    def initialize(device_name, init, pairs)
+      super device_name
+      @init = init
+      @elapsed = 1
+      @schedule = pairs.map {|t, v| t-@elapsed }
+      @values = pairs.map {|t, v| v }
+      @test_result = []
+    end
+    attr_reader :test_result
+
+    def registered
+      set_elapsed_time(1)
+      define_status("s", @init)
+    end
+
+    def run(watched_status_change)
+      @test_result << [@framework.current_time, @values.first]
+      set_elapsed_time(@elapsed)
+      status_changed "s", @values.shift
+    end
+  end
+
+  def test_srcdevice
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    srcdevice = SrcDevice.new("src", 0,
+      [[t+10,8],
+       [t+20,2],
+       [t+30,3],
+       [t+40,5],
+       [t+50,1]])
+    fsevent.register_device(srcdevice)
+    fsevent.start
+    assert_equal(
+      [[t+9,8],
+       [t+19,2],
+       [t+29,3],
+       [t+39,5],
+       [t+49,1]],
+      srcdevice.test_result)
+  end
+
+  class FailSafeDeviceT < FSEvent::FailSafeDevice
+    def registered
+      super
+      set_elapsed_time(1)
+    end
+
+    def run(watched_status_change)
+      set_elapsed_time(1)
+      super(watched_status_change)
+    end
+  end
+
+  class DstDevice < FSEvent::AbstractDevice
+    def initialize(device_name, watchee_device_name, watchee_status)
+      super device_name
+      @watchee_device_name = watchee_device_name
+      @watchee_status = watchee_status
+      @test_result = []
+    end
+    attr_reader :test_result
+
+    def registered
+      super
+      set_elapsed_time(1)
+      add_watch(@watchee_device_name, @watchee_status)
+    end
+
+    def run(watched_status_change)
+      set_elapsed_time(1)
+      @test_result << [@framework.current_time, watched_status_change]
+    end
+  end
+
+  def test_failsafe1
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    src1 = SrcDevice.new("src1", 0,
+      [[t+10,9],
+       [t+20,2],
+       [t+30,3],
+       [t+40,5],
+       [t+50,1]])
+    fsd = FailSafeDeviceT.new("fs",
+      [["s", 0, lambda {|cur, val| val }]],
+      "src1")
+    dst = DstDevice.new("dst", "fs", "s")
+    fsevent.register_device(src1)
+    fsevent.register_device(fsd)
+    fsevent.register_device(dst)
+    fsevent.start
+    assert_equal(
+      [[t + 1, {"fs"=>{"s"=>0}}],
+       [t + 11, {"fs"=>{"s"=>9}}],
+       [t + 21, {"fs"=>{"s"=>2}}],
+       [t + 31, {"fs"=>{"s"=>3}}],
+       [t + 41, {"fs"=>{"s"=>5}}],
+       [t + 51, {"fs"=>{"s"=>1}}]],
+      dst.test_result)
+  end
+
+  def test_failsafe2_max
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    src1 = SrcDevice.new("src1", 0,
+      [[t+10,9],
+       [t+20,2],
+       [t+30,3],
+       [t+40,5],
+       [t+50,1]])
+    src2 = SrcDevice.new("src2", 0,
+      [[t+11,9],
+       [t+19,2],
+       [t+31,3],
+       [t+39,5],
+       [t+51,1]])
+    fsd = FailSafeDeviceT.new("fs",
+      [["s", 0, :max]],
+      "src1", "src2")
+    dst = DstDevice.new("dst", "fs", "s")
+    fsevent.register_device(src1)
+    fsevent.register_device(src2)
+    fsevent.register_device(fsd)
+    fsevent.register_device(dst)
+    fsevent.start
+    assert_equal(
+      [[t + 1, {"fs"=>{"s"=>0}}],
+       [t + 10+1, {"fs"=>{"s"=>9}}],
+       [t + 20+1, {"fs"=>{"s"=>2}}],
+       [t + 30+1, {"fs"=>{"s"=>3}}],
+       [t + 39+1, {"fs"=>{"s"=>5}}],
+       [t + 51+1, {"fs"=>{"s"=>1}}]],
+      dst.test_result)
+  end
+
+end