appswarm 0.0.1

data/apps/udp_network/simple_api.rb

@@ -0,0 +1,180 @@
+require 'whiteboard.rb'
+
+class RemoteSimpleAPI
+  class CallingTransaction
+    def initialize(app,txid)
+      @app=app
+      @txid=txid
+    end
+    def sendResult(r)
+      @app.sendResult(@txid,r)
+    end
+  end
+  
+  class SentTransaction
+    TIMEOUT=10 # 
+    
+    def initialize(app,txid,from)
+      @app=app
+      @from=from
+      @txid=txid
+    end
+    
+    # waits for the return value
+    def wait(timeout=nil)
+      timeout||=TIMEOUT
+      @app.getFromWhiteboard(@txid,@from,timeout)
+    end
+    
+    def valueAvailable?
+      raise :NotImplementedYet # FIXME
+    end
+  end
+  
+  class Service
+    # this function should not be called except through RewmoteSimpleAPI::hook(.) 
+    def initialize(app,sname,pblock)
+      @app=app
+      @sname=sname
+      @block=pblock
+    end
+ 
+    # call service with *args and don't return anything - you won't get any info, if this succeeded
+    def sendAsync(node,*args)
+      @app.sendAsync(node,@sname,*data)
+    end
+    
+    # sends *data to *node* and returns a SentTransaction value
+    def send(node,*data)
+      @app.send(node,@sname,*data)
+    end
+    
+    # closes the service
+    def close
+      @app.closeService(self)
+    end
+    
+    def name
+      @sname
+    end
+    def block
+      @block
+    end
+  end
+  
+  def initialize(node)
+    @node=node
+
+    @txCount=0
+    @txMutex=Mutex.new
+
+    @services=[]
+    
+    @node.addReceiver(self) {|from,args|
+      receive(from,args)
+    }
+    
+    @whiteboard=Whiteboard.new
+  end
+  
+  def me
+    @node.me
+  end
+  
+  # close the api-object - api won't listen anymore
+  def close
+    @node.removeReceiver(self)
+  end
+  
+  # hook up a new service with the given name and block - returns
+  # a Service object for simple handling of this service 
+  def hook(serviceName,&block)
+    service=Service.new(self,serviceName,block)
+    @services << service
+    service
+  end
+
+  # send data to all hooks with name "serviceName" on node *node*
+  def send(node,serviceName,*data)
+    txid=nil
+    txid=getTxCount
+    sdata=Secure::Marshal::dump([false,serviceName,txid,*data])
+    @node.sendMessage(sdata,node)
+    SentTransaction.new(self,txid,node)
+  end
+  
+
+  def sendAsync(node,serviceName,*data)
+    txid=nil
+    data=Secure::Marshal::dump([false,serviceName,txid,*data])
+    
+    @node.sendMessage(data,node)
+    nil
+  end
+  def closeService(service)
+    @services.delete(service)
+  end
+  
+  def getFromWhiteboard(tx,from,timeout)
+    log "getFromWhiteboard #{tx} #{from}"
+    @whiteboard.get([tx,from],timeout)
+  end
+  def stop
+    
+  end
+
+  private
+  
+  def getTxCount
+    id=nil
+    @txMutex.synchronize {
+      id=@txCount+=1
+    }
+    id
+  end
+  
+  def receive(from,args)
+    args=Secure::Marshal.load(args)
+    #log "API RECEIVED",args.inspect
+    #log "FROM #{from}"
+    assert{args.is_a?(Array)}
+    
+    if args[0]==false
+      call(from,args[1..-1])
+    else
+      pushReturn(from,args[1..-1])
+    end
+    
+    
+  end
+  def log(*x)
+    @node.log(*x)
+    
+  end
+  
+  # call local function of service
+  def call(from,args)
+    serviceName,tx,*args=args
+    
+    @services.each{|service|
+      if service.name==serviceName
+        result=service.block.call(*args)
+        if tx
+          sendReturn(from,tx,result)
+        end
+      end
+    }
+  end
+  
+  # put return value into whiteboard for retrieval
+  def pushReturn(from,args)
+    name,tx,value=args
+    @whiteboard.put([tx,from],value)
+  end
+  
+  # send return value back to calling node
+  def sendReturn(from,tx,result)
+    data=Secure::Marshal::dump([true,nil,tx,result])
+    @node.sendMessage(data,from)
+  end
+end

data/apps/udp_network/spec/qos_queue_spec.rb

@@ -0,0 +1,99 @@
+require 'qos_queue.rb'
+require 'network_interface_api.rb' 
+
+describe "QoS Queue" do
+  
+  class TestNode<NetworkInterfaceAPI
+    attr_reader :sent
+    def initialize
+      super(nil)
+      @sent=[]
+    end
+    def sendMessage(data,node)
+      @sent<<[data,node]
+    end
+  end
+  
+  class TestRec
+    attr_reader :received
+    def initialize(qq)
+      @received=[]
+      qq.addReceiver(self) {|from,args|
+        @received<<[from,args]
+      }
+    end
+  end
+   if false
+  it "should pass packages" do
+    tn=TestNode.new
+    qq=QoSQueue.new(tn)
+    tr=TestRec.new(qq)
+    
+    data=1234
+    
+    lambda {
+      qq.receive(:from,[1,QoSQueue::NORMAL_PKG,data])
+    }.should_not cross(QoSQueue,:requestPkg)
+    tr.received.should == [[:from,data]]
+  end
+  
+  it "should request a missing first package" do
+    tn=TestNode.new
+    qq=QoSQueue.new(tn)
+    tr=TestRec.new(qq)
+    
+    data=1234
+    
+    qq.receive(:from,[2,QoSQueue::NORMAL_PKG,data])
+    sleep 0.2
+    tr.received.should == [[:from,data]]
+    tn.sent.should == [[[1,QoSQueue::REQUEST_PKG,nil],:from]]
+  end
+  
+  it "should not request a received package anymore" do
+    tn=TestNode.new
+    qq=QoSQueue.new(tn)
+    tr=TestRec.new(qq)
+    
+    data=1234
+    
+    qq.receive(:from,[2,QoSQueue::NORMAL_PKG,data])
+    qq.receive(:from,[1,QoSQueue::NORMAL_PKG,data])
+    qq.receive(:from,[3,QoSQueue::NORMAL_PKG,data])
+    qq.receive(:from,[5,QoSQueue::NORMAL_PKG,data])
+    sleep 0.2
+    tr.received.should == [[:from,data]]*4
+    tn.sent.should == [[[1,QoSQueue::REQUEST_PKG,nil],:from],[[4,QoSQueue::REQUEST_PKG,nil],:from]]
+  end
+  
+end
+  
+  
+ # if false
+    
+  it "should never miss a single package" do
+    FACTOR=200000
+    b1=TestBed.new
+    b2=TestBed.new
+    n1=b1.run("UdpNetwork").api
+    n2=b2.run("UdpNetwork").api
+    b1.run("NetworkDiscoveryUdp")
+    b2.run("NetworkDiscoveryUdp")
+    
+    sleep 2
+    service1=n1.hook("test1"){|arg|
+      arg.should == "test1Arg"*FACTOR
+      "testRet"*FACTOR
+    }
+
+    measureTime {
+      n2.send(n1.me,"test1","test1Arg"*FACTOR).wait.should == "testRet"*FACTOR
+    }
+    
+    b1.stop
+    b2.stop
+
+    
+  end
+#end
+end

data/apps/udp_network/spec/simple_api_spec.rb

@@ -0,0 +1,35 @@
+describe "Simple networking api" do
+  
+  
+  it "should provide a framework for running remote apps" do
+
+    FACTOR=200000
+       
+    b1=TestBed.new
+    b2=TestBed.new
+    
+    ["NodeBroadcast","NetworkDiscoveryUdp","NetworkDiscovery","UdpNetwork"].each{|n|
+      b1.run(n)
+      b2.run(n)
+    }
+  
+    sleep 3
+    
+    n1=b1.getApp(:fullNetworkNode).api
+    n2=b2.getApp(:fullNetworkNode).api
+    
+    service1=n1.hook("test1"){|arg|
+      arg.should == "test1Arg"*FACTOR
+      "testRet"*FACTOR
+    }
+    puts "TESTTTTTTTTTTTTTTTTTTT"
+    
+    measureTime {
+      n2.send(n1.me,"test1","test1Arg"*FACTOR).wait.should == "testRet"*FACTOR
+    }
+    
+    b1.stop
+    b2.stop
+  end
+
+end

data/apps/udp_network/spec/udp_network_spec.rb

@@ -0,0 +1,115 @@
+alias :pputs :puts
+
+def puts(*x)
+  if "#{x}"=~/.*NoMethod.*/
+    raise "MUH"
+  end
+  pputs *x
+end
+
+alias :ppp :pp
+def pp(*x)
+  if "#{x}"=~/.*NoMethod.*/
+    raise "MUH"
+  end
+  ppp *x
+end
+
+
+describe "UDP Network" do
+  
+  it "should offer itself over network discovery" do
+    b=TestBed.new
+    ["NetworkDiscovery","NetworkDiscoveryUdp","UdpNetwork"].each{|n|b.run(n)}
+    sleep 2
+    dis=b.getApp(:networkDiscovery)
+    pp dis.get
+    dis.get.should == [b.getApp(:fullNetworkNode).me]
+    
+    b.stop
+  end
+  
+  it "should connect to another node" do
+    b1=TestBed.new
+    b2=TestBed.new
+    ["UdpNetwork"].each{|n|
+      b1.run(n)
+      b2.run(n)
+    }
+    
+    n1=b1.getApp(:fullNetworkNode)
+    n2=b2.getApp(:fullNetworkNode)
+    
+    sleep 5
+    
+    pp b1.getApp(:networkDiscovery).get
+    pp b2.getApp(:networkDiscovery).get
+    
+    b2.getApp(:networkDiscovery).get.sort.should == [n1.me,n2.me].sort
+    b1.getApp(:networkDiscovery).get.sort.should == [n1.me,n2.me].sort
+    
+    b1.stop
+    b2.stop
+
+  end
+  
+  it "should provide some functions for spreading udp-node-information" do
+    b1=TestBed.new
+    b2=TestBed.new
+    b3=TestBed.new
+    
+    [b1,b2,b3].each{|b|
+      b.run("NetworkDiscovery",{:discovery=>[:networkDiscoveryLocalstore]})
+    }
+    
+    n1=b1.run("UdpNetwork")
+    n2=b2.run("UdpNetwork")
+    n3=b3.run("UdpNetwork")
+    
+    store=b2.getApp(:networkDiscoveryLocalstore)
+    store.add(n1.me)
+    store.add(n3.me)
+    
+    sleep UdpNetworkApp::SPREADING_INTERVAL*2
+    
+    all=[n1,n2,n3].map{|n|n.me}.sort
+    
+    n2.knownNodes.sort.should == all 
+    n1.knownNodes.sort.should == all 
+    n3.knownNodes.sort.should == all 
+  end
+
+  it "should provide a framework for running remote apps" do
+    b1=TestBed.new
+    b2=TestBed.new
+    
+    ["NodeBroadcast","NetworkDiscoveryUdp","NetworkDiscovery","UdpNetwork"].each{|n|
+      b1.run(n)
+      b2.run(n)
+    }
+  
+    sleep 3
+    
+    n1=b1.getApp(:fullNetworkNode).api
+    n2=b2.getApp(:fullNetworkNode).api
+    
+    service1=n1.hook("test1"){|arg|
+      arg.should == "test1Arg"
+      "testRet"
+    }
+    service2=n2.hook("test1"){|arg|
+      arg.should == "test1Arg"
+      "testRet2"
+    }
+    measureTime {
+      n2.send(n1.me,"test1","test1Arg").wait.should == "testRet"
+    }
+    
+    measureTime {
+      service1.send(n2.me,"test1Arg").wait.should == "testRet2"
+    }
+    b1.stop
+    b2.stop
+  end
+end
+

data/apps/udp_network/spec/udp_transceiver_spec.rb

@@ -0,0 +1,90 @@
+require 'udp_transceiver.rb'
+
+describe "UDP Transceiver" do
+  it "should send a packet correctly" do
+    bind="127.0.0.1"
+    udp1=UdpTransceiver.new(bind,8889)
+    udp2=UdpTransceiver.new("localhost",8898)
+    c12=udp1.connect(udp2.me)
+    c21=udp2.connect(udp1.me)
+    
+    str="MUH"*10
+    
+    c21.send(str)
+    sleep 0.5
+    
+    c12.read.should == str
+    
+    udp1.close!
+    udp2.close!
+  end
+  
+  it "should work as a stream correctly" do
+    bind="127.0.0.1"
+    udp1=UdpTransceiver.new(bind,8889)
+    udp2=UdpTransceiver.new("localhost",8898)
+    c12=udp1.connect(udp2.me).stream
+    c21=udp2.connect(udp1.me).stream
+    
+    str="MUH"*10000
+    
+    c21.write(str)
+    sleep 0.1
+    
+    c12.read.should == str
+
+    udp1.close!
+    udp2.close!
+  end
+  
+  it "should support several separate streams simultaneously"
+
+  it "should ignore broken packets and afterwards it should continue" do
+    bind="127.0.0.1"
+    udp1=UdpTransceiver.new(bind,8889)
+    udp2=UdpTransceiver.new("localhost",8898)
+    c12=udp1.connect(udp2.me)
+    udp2.close!
+    sock=UDPSocket.open
+    sock.send("BUGGYTEXT",0,bind,8889)
+    c12.read.should be_nil
+
+    udp2=UdpTransceiver.new("localhost",8898)
+    c21=udp2.connect(udp1.me)
+    c21.send("MUH")
+    sleep 0.1
+    c12.read.should == "MUH"
+    
+    udp1.close!
+    udp2.close!
+  end
+  
+  it "should provide a receiving event-handler" do
+    bind="127.0.0.1"
+    udp1=UdpTransceiver.new(bind,8889)
+    udp2=UdpTransceiver.new(bind,8898)
+    c12=udp1.connect(udp2.me)
+    res=nil
+    udp2.receive{|from,packet|
+      puts "__________________________"
+      res=packet
+    }
+    
+    str="MUH"*10
+    
+    c12.send(str)
+    sleep 0.5
+    
+    res.should == str
+    
+    udp1.close!
+    udp2.close!
+    
+  end
+  
+  it "should request a missing packet"
+  it "should send acks every few messages"
+  
+end
+
+