appswarm 0.0.1

data/apps/network_node/remote_service.rb

@@ -0,0 +1,45 @@
+
+
+RemoteServiceID=Struct.new(:nodeInformation,:name,:provides)
+
+class RemoteService
+  def initialize(serviceID,networkNode)
+    @service=serviceID
+    @networkNode=networkNode
+  end 
+  
+  def method_missing(*s)
+    log "remoteService calling #{s.inspect}"
+    if s[0].to_s=~/.*!/
+      res=@networkNode.callRun(@service,s)
+    else
+      res=@networkNode.call(@service,s)
+    end
+    log "RESULT:",res
+    res
+  end
+  
+  def log(*s)
+    @networkNode.log(*s)
+  end
+end
+
+class RemoteCall
+  def intialize(remoteService,calledBy,name,args)
+    
+  end
+end
+
+def RemoteReturn
+  def initialize(to,what)
+    @to=to
+    @what=what
+  end  
+end
+
+class RemoteRun
+  def initialize(remoteService,name,args)
+    @args=args
+  end
+end
+

data/apps/network_node/secure_node.rb

@@ -0,0 +1,125 @@
+require File.expand_path('../abstract_node.rb',__FILE__)
+require 'secure_con.rb'
+
+class WrongProtocol<Exception
+  
+end
+
+class ConnectionClosed<Exception
+  
+end
+
+class SecureNetNode<Secure::SimpleServer
+  
+  attr_reader :protocol
+  def initialize(port,app,hash)
+    @protocol=:secure
+    @closeMutex=Mutex.new
+    @hash=hash
+    @app=app
+    @nodeList=[]
+    assert{@hash.is_a?(String)}
+    super(port)
+    taint
+  end
+  
+  def nodeList
+    @nodeList.select{|k|getConnection(k)}
+  end
+  def nodeId
+    NodeInformation.new(localHost,localPort,:secure,@hash)
+  end
+  
+  def stop
+    @server.stop
+  end
+  
+  def close(nodeId)
+    cs=connections{|c|c.remoteHost==nodeId.address and c.remotePort==nodeId.port}
+    cs.each{|c|disconnect}
+  end
+  
+  def info
+    {:protocol=>@protocol,
+      :connections=>connections.length
+    }
+  end
+  
+  def connect(rnodeId)
+    return if nodeList.member?(rnodeId)
+    raise "Can't connect to myself" if rnodeId==nodeId
+    begin
+      pp "NODE-ID #{rnodeId}"
+      pp "NODE-ID #{rnodeId.protocol}"
+      raise WrongProtocol if rnodeId.protocol!=:secure
+      puts "#{nodeId} CONNCTING #{rnodeId} "
+      
+      c=super(rnodeId.address,rnodeId.port)
+      puts "#{nodeId} CONNECTED #{rnodeId} "
+       
+      Thread.new {
+        @nodeList << c.identifyMe(nodeId)
+        @app.log "connected #{nodeId}"
+      }
+      c
+    rescue ConnectionClosed=>e
+      nil
+    end
+  end
+  
+  def getConnection(rNodeId)
+    connections.select{|c|c.remoteHost==rNodeId.address and c.remotePort==rNodeId.port}[0]
+  end
+  
+  
+  def sendAll(*s)
+    connections.p_map{|c|
+      begin
+        c.remoteCallSync(*s)
+      rescue ConnectionClosed=>e
+        :nothing
+      end
+    }.select{|x|x!=:nothing}
+  end
+    
+  # FIXME: may be deprecated
+  def setHook(&hook)
+    @hook=hook
+  end
+  
+  
+  remote :remoteCall, :close
+  remote_sync :remoteCallSync, :identifyMe
+  allow :remoteCall, :identifyMe, :remoteCallSync
+  
+  def remoteCall(name,*s)
+    pp "RemoteCall #{name}"
+    @hook.call(name,*s)
+  end
+  
+  def remoteCallSync(name,*s)
+    pp "RemoteCall #{name}"
+    @hook.call(name,*s)
+  end
+
+  
+  def eventConnected(host,port)
+    super
+    all=connections.select{|i|i.remoteHost==host and i.remotePort==port}
+    
+    if all.length>1
+      pp "FOUND:",all.length
+      all[1..-1].each{|c|
+        pp "NOT YET CLOSE #{c}"
+        #c.disconnect  # close last in list
+      }
+    end
+  end
+#end  
+  def identifyMe(pid)
+    connection=getConnection(pid)
+    @nodeList<<pid
+    @hook.call(:eventConnected,pid) #NodeInformation.new(host,port,:secure))
+    nodeId
+  end
+end

data/apps/network_node/spec/drb_spec.rb

@@ -0,0 +1,41 @@
+require 'drb_node.rb'
+def resetLog
+  $log=""
+end
+def log(*s)
+  $log||=""
+  if s.length>0
+    s=s.join(" ")
+    $log<<s<<";"
+    puts s
+  end
+  $log
+end
+
+if false
+describe "Drb Node" do
+  it "should connect to another node" do
+    a=DrbNetNode.new(4000,nil)
+    class DrbNetNode
+      def hi(*what)
+        @hi=what.join("") if what.length>0
+        @hi
+      end
+    end
+    b=DrbNetNode.new(4041,nil)
+    a.connect(b.id)
+    b.sendAll(:hi,"hello1")
+    a.sendAll(:hi,"hello2")
+    a.hi.should == "hello1"
+    b.hi.should == "hello2"
+    b.close(a.node)
+    b.sendAll(:hi,"hello3")
+    a.sendAll(:hi,"hello4")
+    a.hi.should == "hello1"
+    b.hi.should == "hello2"
+  end
+end
+
+
+  
+end

data/apps/network_node/spec/network_node_spec_not.rb

@@ -0,0 +1,264 @@
+require 'network_node.rb'
+
+describe "Network node" do
+
+  after(:each) do
+    TestBed::testbeds.should == []
+    TestBed::testbeds.each{|tb|tb.stop}
+  end
+  
+  if false
+  it "should gather nodes from local storage" do
+    testBed=TestBed.new
+    s=testBed.run("LocalTupleSpace")
+    s.should be_a_kind_of(LocalTupleSpaceApp)
+    s.store(:networkNodeList,dummyServers)
+    node=testBed.run("NetworkNode")
+    sleep 2
+    (node.nodeList.sort).should == (dummyServers.sort)
+    testBed.stop
+  end
+end  
+  it "should gather nodes from master server and connect some nodes" do
+    TestBed::testbeds.should == []
+    testBed=TestBed.new
+    testBed2=TestBed.new
+    testBed2.options[:httpPort]=2001
+    s=testBed.run("Master")
+    l1=testBed.run("NetworkLookup")
+    
+    l1=testBed2.run("NetworkLookup")
+    
+    n0=testBed.run("NetworkNode")
+    n1=testBed2.run("NetworkNode")
+    n0.runCron
+    n1.runCron
+    n0.runCron
+    sleep 0.5
+    s.clients.length == 2
+    sleep 2
+    pp "MYNODELIST:",n0.nodeList
+    pp "MYNODELIST:",n1.nodeList
+    n0.nodeList.sort.should == ([n1.myNodeId,n0.myNodeId].sort)
+    n0.nodeList.should be_member(n1.myNodeId)
+    n1.nodeList.should be_member(n0.myNodeId)
+    testBed.stop
+    testBed2.stop
+  end
+  
+  it "should not connect an already connected node"
+  
+  it "should get nodes from neighbors" do
+    bs=[]
+    ns=[]
+    st=[]
+    3.times{bs<<TestBed.new}
+    bs.each{|b|
+      ns<<b.run("NetworkNode",{:cronTime=>10000})
+      st<<b.run("LocalTupleSpace")
+    }
+    st[0].store(:networkNodeList,[ns[1].myNodeId])
+    puts "CRON>>>>>>>>>"
+    ns[0].runCron
+    puts "CRON<<<<<<<<<<"
+    ns[0].nodeList.should==[ns[1].myNodeId]
+    puts "_______"
+    ns.each{|n|
+      pp n.myNodeId,n.transceiver.nodeList,n.nodeList
+    }
+puts "_______"
+    ns[0].transceiver.nodeList.should==[ns[1].myNodeId]
+    ns[1].transceiver.nodeList.should==[ns[0].myNodeId]
+    ns[1].nodeList.should==[ns[0].myNodeId]
+    
+    st[2].store(:networkNodeList,[ns[0].myNodeId])
+    ns[2].runCron # getting at least ns0
+    sleep 0.5 # let network process a little
+    ns[2].nodeList.member?(ns[0].myNodeId).should be_true
+    ns[2].transceiver.nodeList.member?(ns[0].myNodeId).should be_true
+puts "CRON>>>>>>>>>"
+    ns[2].runCron # getting ns2
+sleep 0.5 # let network process a little
+    pp "TRANSLIST",ns[2].transceiver.nodeList
+    ns[2].transceiver.nodeList.length.should >= 2
+puts "CRON<<<<<<<<<<"
+ns[1].runCron # getting ns2
+sleep 0.5 # let network process a little
+    ns[1].nodeList.member?(ns[2].myNodeId).should be_true
+    
+    
+    bs.each{|b|b.stop}
+    
+  end
+
+  #if false
+    
+  
+  it "should give you access to services" do
+    testBed1=TestBed.new
+    testBed2=TestBed.new
+    testBed1.run("Master")
+    testBed1.run("NetworkLookup")
+    testBed2.run("NetworkLookup")
+    n1=testBed1.run("NetworkNode",{:cronTime=>1})
+    n2=testBed2.run("NetworkNode",{:cronTime=>1})
+    testBed1.run("LocalTupleSpace")
+    
+    #sleep 4
+    4.times {|i|
+    
+pp "CRON #{i} n1"
+t=testBed1.getThread(n1)
+     pp t
+     pp t[:caller]
+      pp "CRON #{i}"
+      n1.runCron
+pp "CRON #{i} n2"
+t=testBed2.getThread(n2)
+     pp t
+     pp t[:caller]
+      n2.runCron
+pp "CRON #{i}"
+    }
+    
+    while not n2.nodeReachable(n1.myNodeId)
+      puts "WWAIT"
+      pp n2.services
+      pp n2.getRoutesDirectly
+      sleep 0.2
+    end
+    
+    sv=testBed2.getApp(:networkNode).getRemoteService(:localTupleSpace)
+    puts "STORING....."
+    sv.store(:a,"A")
+    puts "STORED"
+    sv.read(:a).should == "A"
+    
+    testBed1.stop
+    testBed2.stop
+  end
+  
+  
+  it "should process routes correctly" do
+    options={:minCompanions=>1}
+    testBed1=TestBed.new
+    testBed2=TestBed.new
+    testBed3=TestBed.new
+    n1=testBed1.run("NetworkNode",options)
+    n2=testBed2.run("NetworkNode",options)
+    n3=testBed3.run("NetworkNode",options)
+    
+    t1=testBed1.run("LocalTupleSpace")
+    t3=testBed3.run("LocalTupleSpace")
+    
+    t1.store(:networkNodeList,[n2.myNodeId])
+    t3.store(:networkNodeList,[n2.myNodeId])
+    
+    n1.runCron
+    n3.runCron
+    
+    nodes=[n1,n2,n3]
+    
+    nodes.map{|node|node.getRoutesDirectly}.flatten.each{|n|nodes.map{|m|m.myNodeId}.member?(n.node).should == true}
+
+    n1.getRoutesDirectly.should == [NetworkNodeApp::Node.new(n2.myNodeId,0,n1.myNodeId)]
+    #(n2.getRoutesDirectly.sort).should == ([NetworkNodeApp::Node.new(n1.myNodeId,0,n2.myNodeId),
+    #  NetworkNodeApp::Node.new(n3.myNodeId,0,n2.myNodeId)].sort)
+    n3.getRoutesDirectly.should == [NetworkNodeApp::Node.new(n2.myNodeId,0,n3.myNodeId)]
+
+    n1.runCron
+    n3.runCron
+    
+    #pp n1.nodeListRoute.sort
+    
+    pp "NODELISTROUTE:","____________________________________"
+      
+    
+    pp  "N1:",n1.myNodeId, n1.getRoutesDirectly,n1.transceiver.nodeList
+    pp  "N2:",n2.myNodeId, n2.getRoutesDirectly
+    pp  "N3:",n3.myNodeId, n3.getRoutesDirectly
+    
+    l1=n1.getRoutesDirectly.select{|node|node.node==n3.myNodeId}
+    l1.length.should == 1
+    l1.each{|info|info.hops.should == 1
+      info.route.should == n2.myNodeId
+    }
+    
+    nodes.each{|node|
+     node.getRoutesDirectly.select{|info|info.node==node.myNodeId}.each{|info|
+        [0,1].member?(info.hops).should be_true
+      }
+    }
+
+    testBed1.stop
+    testBed2.stop
+    testBed3.stop
+    
+  end
+  
+  
+  it "should be possible to define a hook from another app" do
+    bed1=TestBed.new
+    bed2=TestBed.new
+    bed1.run("Master")
+    bed1.run("NetworkLookup")
+    bed2.run("NetworkLookup")
+    n1=bed1.run("NetworkNode")
+    n2=bed2.run("NetworkNode")
+    sleep 2
+    check=false
+    b=binding
+    n1.hook("MyTest"){|*args|
+      eval("check=true",b)
+    }
+    #n2.runCron
+    #n1.runCron
+    n2.remoteApp(n1.myNodeId,"MyTest",:check)
+    sleep 0.5
+    check.should be_true
+    bed1.stop
+    bed2.stop
+  end
+    
+  
+  it "should build a single complete network" do
+    count=7
+    testbeds=[]
+    nodes=[]
+    count.times{|i|
+      testbed=TestBed.new
+      nodes << testbed.run("NetworkNode",{:minCompanions=>5})
+      testbed.run("NetworkLookup")
+      
+      testbeds<<testbed
+    }
+    testbeds[0].run("Master")
+    
+    (count-1).times{
+      nodes.each{|node|node.runCron}
+    }
+    
+    testbeds.each{|t|t.stop}
+    ids=testbeds.map{|t|t.getApp(:networkNode).myNodeId}
+    puts "___________________________"
+    testbeds.each{|t|
+      puts t.getApp(:networkNode).nodeList.length
+      puts t.getApp(:networkNode).nodeList.uniq.length
+      puts t.getApp(:networkNode).nodeList
+    }
+    testbeds.each{|t|
+      n=t.getApp(:networkNode)
+      (n.nodeList.sort).should == (ids.sort) #-[n.myNodeId])
+    }
+  end
+  
+  it "should be possible to gather a list of near services"
+  it "should provide a list of all services"
+  
+  def dummyServers
+    [
+      NodeInformation.new("127.0.0.1",5678,:secure,"1234"),
+      NodeInformation.new("127.0.0.1",5900,:secure,"3456")
+    ]
+  end
+end