Changeset 159

Show
Ignore:
Timestamp:
05/30/06 05:21:58 (2 years ago)
Author:
rosejn
Message:

Adding various packaging materials and beginning of protocol stuff.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • experiments/machine/lib/machine/eio.rb

    r152 r159  
    5959  # 
    6060  def initialize io = nil 
    61     super() # Have to call super first or add_handler fails... 
    62  
    6361    # Set the socket nonblocking. The new Ruby will actually nonblocking APIs. 
    6462    m = io.fcntl(Fcntl::F_GETFL, 0) 
     
    205203  # 
    206204  def initialize *args 
    207     super 
    208205    @pending = true 
    209206  end 
  • experiments/machine/lib/machine/event.rb

    r158 r159  
     1# This way of auto-initializing a module was taken from a ruby-talk post by 
     2# Florian Gross.  He's the man. 
     3 
    14module Machine 
    2   require 'ostruct
     5  require 'thread
    36 
    47  class Event 
     
    1518    include Base 
    1619 
    17     def initialize(*args, &block) 
     20    # Wrap the including classes initialize method so we are automatically 
     21    # initialized without the includer having to call super. 
     22    def self.included(other) 
     23      install_initialize = lambda do 
     24        other.class_eval do 
     25          alias :old_initialize :initialize 
     26 
     27          def initialize(*args, &block) 
     28            intercept_initialize unless @intercept_initialized 
     29            old_initialize(*args, &block) 
     30          end 
     31        end 
     32      end 
     33 
     34      class << other; self; end.class_eval do 
     35        alias :old_method_added :method_added 
     36 
     37        ignore = false 
     38        define_method(:method_added) do |name| 
     39          return if ignore 
     40 
     41          case name 
     42          when :initialize then 
     43            Thread.exclusive do 
     44              ignore = true 
     45              install_initialize.call 
     46              ignore = false 
     47            end 
     48          else 
     49            old_method_added(name) 
     50          end 
     51        end 
     52      end 
     53 
     54      install_initialize.call 
     55      super 
     56    end 
     57 
     58    # Called before the initialize method of the including class. 
     59    def intercept_initialize 
     60      @intercept_initialized = true 
    1861      @handlers = Hash.new do |hash, key|  
    1962        hash[key] = Hash.new {|h,k| h[k] = []}  
     
    2366 
    2467      Reactor.instance.add_dispatcher self 
     68    end 
    2569 
    26       super 
     70    unless respond_to? :initialize 
     71      def initialize 
     72      end 
    2773    end 
    2874 
  • experiments/machine/lib/machine.rb

    r156 r159  
    3131  require 'machine/signal' 
    3232  require 'machine/router' 
     33  require 'machine/protocol' 
    3334end 
  • experiments/machine/lib/machine/router.rb

    r155 r159  
    1212 
    1313  @@reactor_signal = Socket::socketpair( Socket::AF_UNIX, Socket::SOCK_STREAM, 0) 
    14   EventableIO.new(@@reactor_signal[1]) 
     14  #EventableIO.new(@@reactor_signal[1]) 
    1515  @@reactor_signalled = false 
    16  
    1716 
    1817  class << self 
    1918    def route_events 
    20       $stderr.write "R" 
     19      @@log.debug "R" 
    2120      @@reactor_signalled = false 
    2221      until @@inbound_q.empty? 
     
    4443 
    4544  def initialize args = [] 
    46     # As always, must call super to pick up the initialization in EventDispatcher 
    47     super() 
    4845    args = [args] unless args.respond_to?(:each) 
    4946    args.each {|arg| subscribe arg } 
     
    6259module Machine 
    6360module EventPublisher 
    64  
    65   def initialize 
    66     super() 
    67   end 
    6861 
    6962  def publish_event evt 
  • experiments/machine/lib/machine/signal.rb

    r144 r159  
    11module Machine 
    2   class Signaller 
     2  class SignalDispatcher 
    33    include Base 
    44    include EventDispatcher 
     
    2121 
    2222    def initialize(sig, &block) 
    23       super() 
    24  
    2523      @sig= sig 
    2624 
  • experiments/machine/lib/machine/timeout.rb

    r146 r159  
    3636 
    3737    def initialize(delay, periodic = false, &block) 
    38       super() # Have to call super first or add_handler fails... 
    3938      @delay = delay 
    4039      @periodic = periodic 
  • experiments/machine/test/eio_test.rb

    r143 r159  
    33$:.unshift(File.dirname(__FILE__) + '/../lib') 
    44 
    5 require 'test/unit' 
    6 require 'machine' 
    7 require 'socket' 
     5if __FILE__ == $0 
     6 
     7  require 'test/unit' 
     8  require 'machine' 
     9  require 'socket' 
    810 
    911 
    10 class EioTests < Test::Unit::TestCase 
    11   include Machine 
     12  class EioTests < Test::Unit::TestCase 
     13    include Machine 
    1214 
    13   def setup 
    14     #Reactor.instance.quiet 
    15     # Have a thread going, because it messes up Ruby's io.sysread function 
    16     Thread.new {sleep 1000} 
    17   end 
     15    def setup 
     16      #Reactor.instance.quiet 
     17      # Have a thread going, because it messes up Ruby's io.sysread function 
     18      Thread.new {sleep 1000} 
     19    end 
    1820 
    19   def teardown 
    20   end 
     21    def teardown 
     22    end 
    2123 
    22   def test_eio 
     24    def test_eio 
    2325=begin 
    2426    sin = Socket::pack_sockaddr_in(25, "relay.spheriq.net") 
     
    4749=end 
    4850 
    49     #sd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0) 
    50     #sockaddr = Socket.pack_sockaddr_in( 8901, "127.0.0.1" ) 
    51     #sd.bind sockaddr 
    52     #sd.listen( 100 ) 
     51      #sd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0) 
     52      #sockaddr = Socket.pack_sockaddr_in( 8901, "127.0.0.1" ) 
     53      #sd.bind sockaddr 
     54      #sd.listen( 100 ) 
    5355 
    54     File.unlink("./a.chain") 
    55     sd = Socket.new( Socket::AF_UNIX, Socket::SOCK_STREAM, 0) 
    56     sockaddr = Socket.pack_sockaddr_un( "./a.chain" ) 
    57     sd.bind sockaddr 
    58     sd.listen( 100 ) 
    59     eio = TcpServerEventableIO.new(sd) {|me| 
    60       me.add_handler(:accept) {|evt| 
    61         eio = EventableIO.new(evt.data) {|me| 
    62           me.add_handler(:read) {|evt| 
    63             me.send_data "<<<#{evt.data.chomp}>>>\n" 
     56      File.unlink("./a.chain") 
     57      sd = Socket.new( Socket::AF_UNIX, Socket::SOCK_STREAM, 0) 
     58      sockaddr = Socket.pack_sockaddr_un( "./a.chain" ) 
     59      sd.bind sockaddr 
     60      sd.listen( 100 ) 
     61      eio = TcpServerEventableIO.new(sd) {|me| 
     62        me.add_handler(:accept) {|evt| 
     63          eio = EventableIO.new(evt.data) {|me| 
     64            me.add_handler(:read) {|evt| 
     65              me.send_data "<<<#{evt.data.chomp}>>>\n" 
     66            } 
    6467          } 
    6568        } 
    6669      } 
    67     } 
    68     Reactor.instance.run 
     70      Reactor.instance.run 
    6971 
    70     assert_equal( 1,2) 
     72      assert_equal( 1,2) 
     73    end 
     74 
    7175  end 
    72  
    7376end 
    74  
  • experiments/machine/test/event_test.rb

    r137 r159  
    1919  class TestDispatcher 
    2020    include Machine::EventDispatcher 
     21 
     22    def initialize 
     23    end 
    2124  end 
    2225 
  • experiments/machine/test/router_test.rb

    r157 r159  
    22# THIS IS COPYRIGHTED SOFTWARE. 
    33 
    4 $:.unshift "../lib" 
     4$:.unshift(File.dirname(__FILE__) + '/../lib') 
    55 
    6 require 'test/unit' 
    7 require 'machine' 
    8 include Machine 
     6if __FILE__ == $0 
     7 
     8  require 'test/unit' 
     9  require 'machine' 
     10  include Machine 
    911 
    1012 
    11 class RouterTests < Test::Unit::TestCase 
    12   include Machine 
     13  class RouterTests < Test::Unit::TestCase 
     14    include Machine 
    1315 
    14   def setup 
    15     #Reactor.instance.quiet 
    16     # Have a thread going, because it messes up Ruby's io.sysread function 
    17     Thread.new {sleep 1000} 
    18   end 
     16    def setup 
     17      Reactor.instance.quiet 
     18      # Have a thread going, because it messes up Ruby's io.sysread function 
     19      Thread.new {sleep 1000} 
     20    end 
    1921 
    20   def teardown 
    21   end 
     22    def teardown 
     23    end 
    2224 
    23   class Sender 
    24     include EventDispatcher 
    25     include EventPublisher 
    26     def initialize 
    27       super() 
     25    class Sender 
     26      include EventDispatcher 
     27      include EventPublisher 
     28      def initialize 
     29        super() 
     30      end 
    2831    end 
    29   end 
    3032 
    31   def test_router 
    32     Reactor.run { 
    33       10.times { 
     33    def test_router 
     34      Reactor.run { 
     35        10.times { 
    3436        er = EventSubscriber.new(:hit_me) 
    3537        er.add_handler(:hit_me) {|evt| 
     
    4143        s = Sender.new 
    4244        s.add_handler(:hit_me_reply) {|evt| 
    43           puts "Received reply: #{evt.data}" 
     45          #puts "Received reply: #{evt.data}" 
    4446        } 
    4547        s.publish_event( DataEvent.new(:hit_me, ix) ) 
    4648      } 
    47     } 
     49      } 
     50 
     51      assert_equal(1,2) 
     52    end 
    4853 
    4954 
    50  
    51  
    52  
    53     assert_equal(1,2) 
    5455  end 
    5556 
    56  
    5757end 
    58  
    59  
  • experiments/machine/test/signal_test.rb

    r144 r159  
    1212 
    1313  def teardown 
    14     Signaller.clear 
     14    SignalDispatcher.clear 
    1515  end 
    1616 
    1717  def test_basic 
    1818    @called = 0 
    19     sig = Signaller.new(Signaller::USR1) { @called += 1 } 
     19    sig = SignalDispatcher.new(SignalDispatcher::USR1) { @called += 1 } 
    2020    sig.add_signal_handler(self, :another_handler) 
    2121 
    22     Process.kill(Signaller::USR1, Process.pid) 
     22    Process.kill(SignalDispatcher::USR1, Process.pid) 
    2323 
    2424    @reactor.iterate 
  • experiments/machine/test/timeout_test.rb

    r144 r159  
    99  def setup 
    1010    @reactor = Reactor.instance 
    11     @reactor.verbose 
     11    @reactor.quiet 
    1212  end 
    1313 
     
    1919    # Regular 
    2020    t1 = 0 
    21     Timeout.new(0) { puts "first"; t1 += 1 } 
     21    Timeout.new(0) { t1 += 1 } 
    2222 
    2323    # Periodic 
    2424    t2 = 0 
    25     Timeout.new(1, true) { puts "second"; t2 += 1 } 
     25    Timeout.new(1, true) { t2 += 1 } 
    2626 
    2727    # Method based 
     
    3232    @reactor.run 
    3333    assert_equal 1, t1, "Regular block timer did not fire." 
    34     assert_equal 3, t2, "Periodic block timer did not fire enough." 
     34    assert_equal 3, t2, "Periodic block timer did not fire correctly." 
    3535    assert_equal 1, @t3, "Method based timer did not fire." 
    3636  end 
    3737 
    3838  def stop_reactor(event) 
    39     puts "third..." 
    4039    @t3 += 1 
    4140    @reactor.stop