appswarm 0.0.1

data/apps/new_network_node/new_network_node.rb

@@ -0,0 +1,427 @@
+require 'service.rb'
+require 'net_service.rb'
+require 'breaking_mutex.rb'
+require File.expand_path('../../network_node/secure_node.rb',__FILE__)
+
+class NewNetworkNodeApp<Service
+  
+  NODE_TYPE=SecureNetNode
+
+  class NodeNotReachable<Exception
+  end
+
+  
+  Node=Struct.new(:node,:hops,:route,:timestamp)
+  class Node
+    alias :oldInit :initialize 
+    def initialize(n=nil,h=nil,r=nil)
+      h||=:unreachable
+      oldInit(n,h,r,Node::currentTimestamp)
+    end
+    
+    def self.currentTimestamp
+      Time.now.to_f
+    end
+    
+    def olderThan(other)
+      assert{(self<=>other)==0}
+      timestamp<other.timestamp 
+    end
+    def ==(other)
+      [:node,:hops,:route].each{|i|
+        return false if self.send(i)!=other.send(i)
+      }
+      true
+    end
+    def <=>(other)
+      assert{self.class==other.class}
+      if self.hops==:unreachable
+        if other.hops!=:unreachable
+          return -1
+        end
+      else
+        if other.hops==:unreachable
+          return 1
+        else
+          a=(self.hops<=>other.hops)
+          return a if a!=0
+        end
+      end
+      a=(self.node<=>other.node)
+      return a if a!=0
+      if self.route.nil?
+        unless other.route.nil?
+          return -1
+        end
+      else
+        if other.route.nil?
+          return 1
+        else
+          a=(self.route<=>other.route)
+          return a if a!=0
+        end
+      end
+      0      
+    end
+  end
+
+  
+
+  # these are default settings and can be overridden by *options*
+  MIN_COMPANIONS=5
+  MAX_COMPANIONS=10
+  MAX_HOPS=5
+  
+  attr_reader :transceiver, :services
+  
+  event :connected,1
+
+  def initialize(cluster,options)
+    
+    super(cluster,options,:newNetworkNode)
+    
+    @minCompanions=options[:minCompanions]
+    @maxCompanions=options[:maxCompanions]
+    
+    @minCompanions||=MIN_COMPANIONS
+    @maxCompanions||=MAX_COMPANIONS
+    
+    port=nil
+    port=cluster.options[:port]
+    loop do
+      break if NetService.checkPort(port)
+      port=rand(2000)+2000
+    end
+    sleep 0.1
+    @listMutex=BreakingMutex.new
+    @nodeList=[]
+    
+    hash=options[:nodeHash]
+    hash||=genNodeHash
+    
+    assert{hash.is_a?(String)}
+    
+    @transceiver=NODE_TYPE.new(port,self,hash)
+    @hooks={}
+    @transceiver.setHook do |*s|
+      pp "NetworkNode hook #{s[0]}"
+      case s[0]
+        when :nodeListRoute
+          nodeListRoute
+        when :newNodes
+          log "new Nodes:-)"
+          gotNewNodes(*(s[1..-1]))
+        when :eventConnected
+          eventConnected(*(s[1..-1]))
+        when :serviceList
+          cluster.getGlobalServices.map{|s|RemoteServiceID.new(myNodeId,s.name,s.provides)}
+        when :call
+          incomingCall(*(s[1..-1]))
+        when :remoteApp
+          remoteApp(*(s[1..-1]))
+        when :run
+          incomingRun(*(s[1..-1]))
+        when :hook
+          if @hooks.key?(s[0])
+            @hooks[s[0]].call(*(s[1..-1]))
+          end
+        else
+          log "Unknown Message #{s}"
+      end
+    end
+  end
+  
+  def hook(name,&block)
+    @hooks[name]=block
+  end
+  def unhook(name)
+    @hooks.delete(name)
+  end
+  def remoteApp(nodeId,name,*args)
+    log "remoteApp called #{nodeId} #{myNodeId}"
+    if nodeId==myNodeId
+      log "LOCAL"
+      if @hooks.key?(name)
+        log "hook found"
+        @hooks[name].call(*args)
+      else
+        log "no hook found for #{name}!"
+      end
+    else
+      puts "REMOTE #{nodeId}"
+      nextHop=getValidRoutes(nodeId)[0].node
+      puts "ROUTE #{nextHop.inspect}"
+      pp @transceiver.nodeList
+      nextHop=nodeId if @transceiver.nodeList.member?(nodeId)
+      puts "ROUTE #{nextHop.inspect}"
+      return nil if nextHop.nil?
+      @transceiver.getConnection(nextHop).remoteCallSync(:remoteApp,nodeId,name,*args)
+    end
+  end
+  
+  def genNodeHash
+    Crypt::digest(rand.to_s)
+  end
+  
+  def info
+    {
+     :transceiver=>@transceiver.info,
+     :nodelist=>@nodeList,
+     :services=>@services
+    }
+  end
+  
+  # @deprecated
+  def nodeList
+    nodeIdList
+    #@nodeList.map{|node|node.node}
+  end
+  def nodeIdList
+    @nodeList.map{|node|node.node}.uniq
+  end
+  def nodeListRoute(timestamp=0)
+    @nodeList.map{|node|
+      n=node.dup
+      n.route=myNodeId
+      n
+    }.select{|n|n.timestamp>timestamp}
+  end
+  
+  def getRoutesDirectly
+    @nodeList
+  end
+  def getAllNodes
+    @nodeList
+  end
+
+  def cron
+    log("cron")
+    measureTime {
+      #log "routes:",getRoutesDirectly
+      begin
+        log "register at master..."
+        registerAtMasterServer
+        log "get new from local storage..."
+        getNewFromLocalStorage
+        if @nodeList.length==0
+          log "get new from master..."
+          getNewFromMaster
+        end
+        log "get new from neighbors..."
+        log "connected nodes:",@transceiver.nodeList.length
+        getNodesFromNeighbors
+        log "call connectNodes..."
+        connectNodes
+        log "ready connectNodes."
+        log "ndodelist:",@nodeList.length
+        log "connected nodes:",@transceiver.nodeList.length
+        super
+      rescue Exception=>e
+        log "Error in cron:",e,e.backtrace,e.class
+      end
+      #log("cron ready",getRoutesDirectly,"--")
+      
+      log("checking connected nodes")
+      #pp getRoutesDirectly
+      @transceiver.nodeList.each{|l|
+          log "checking:",l
+          assert{nodeReachable(l)}
+      }
+      log("checked connected nodes")
+    }
+    @cronCount||=0
+    @cronCount+=1
+    log "connected nodes:",@transceiver.nodeList.length
+    log "cron #",@cronCount
+  end
+  
+  def myNodeId
+    @transceiver.nodeId
+  end
+  
+  
+  def stop
+    super
+    @transceiver.stop
+  end
+  
+  
+  def getNodesFromNeighbors
+    @lastTimestamp||=0
+    time=Node::currentTimestamp
+    result=(@transceiver.sendAll(:nodeListRoute,@lastTimestamp)+nodeListRoute).flatten.uniq
+    @lastTimestamp=time
+    log "getNodesFromNeighbors..."
+    result.each{|node|
+      insertNodeFromNeighbor(node)
+    }
+    
+    result.map{|node|node.node}.uniq
+  end
+
+  def getValidRoutes(node,maxAge=100000)
+    @nodeList.select{|n|n.node==node && n.timestamp>Node::currentTimestamp-maxAge && n.hops!=:unreachable && n.route!=nil}
+  end  
+  
+  def nodeReachable(node)
+    getValidRoutes(node).length>0
+  end
+  
+  def call(service,s)
+    nextHop=getRoute(service.nodeInformation)
+    raise NodeNotReachable.new if nextHop.nil?
+    # maybe raise ??? 
+    @transceiver.getConnection(nextHop).remoteCallSync(:call,service,s)
+  end
+  def callRun(service,s)
+    nextHop=getRoute(service.nodeInformation)
+    raise NodeNotReachable.new if nextHop.nil?
+    # maybe raise ??? 
+    @transceiver.getConnection(nextHop).remoteCall(:call,service,s)
+  end
+  
+private
+
+  def insertNodeFromNeighbor(node)
+    node.hops+=1 if node.hops!=:unreachable
+    insertNode(node)
+  end
+
+  def insertNode(node)
+    @listMutex.synchronize {
+      @nodeList<<node
+      
+      cleanUpNodeList
+    }
+  end
+  
+  def cleanUpNodeList
+    log "-----",@nodeList
+    
+    # remove nodes without route, if route is available
+    routeAvail=@nodeList.select{|n|n.route}.map{|n|n.node}
+    
+    @nodeList=@nodeList.select{|n| not (routeAvail.member?(n) and n.route.nil?)}
+
+    # remote route-entries, that are older than others with same route
+    routeAge=@nodeList.group_by{|n|[n.node,n.route]}.max_by_value{|n|n.timestamp}
+
+    @nodeList=@nodeList.select{|n|n.route.nil? or routeAge[[n.node,n.route]]==n.timestamp}
+    
+    log "=======",@nodeList.uniq_count{|n|n.node}
+
+    log "----",@nodeList
+  end
+
+
+  def incomingCall(service,s)
+    if service.nodeInformation==myNodeId
+      # do it
+      # FIXME: check rights
+      pp "doing it",*s
+      app=cluster.getApp(service.name)
+      pp "on:",app
+      app.send(*s)
+    else
+      # relay
+      call(service,s)
+    end
+  end
+  
+  def registerAtMasterServer
+    app=getApp(:networkLookup)
+    app.register(myNodeId) if app
+  end
+  
+  def eventConnected(by)
+    log "eventConnected by #{by.pretty_inspect} me:#{myNodeId}"
+    insertNode( Node.new(by,0,by))
+    isConnected(by)
+  end
+  
+  def getNewFromLocalStorage
+    pp "getNewFromLOCAL"
+    if @nodeList.length==0
+      app=cluster.getApp(:localTupleSpace)
+      if app
+        servers=app.read(:networkNodeList)
+        if servers
+          servers.each{|server|
+            log "got server #{server} from local storage"
+            n=Node.new(server,:unreachable,nil)
+            pp n
+            log "add to list #{n.inspect}"
+            insertNode(n)
+            log "inserted server #{server}"
+          }
+        end
+      end
+    end
+  end
+  
+  
+  def connectNodes
+    log "connectNodes..."
+    if @transceiver.nodeList.length<@minCompanions
+      
+      
+      # FIXME: make this tx shorter !!!!
+        log "connectNode!"
+        # only reading - no mutex needed
+        possible=nodeIdList-@transceiver.nodeList
+        log "nodelist #:",@nodeList.length
+        log "possible #:",possible.length
+        if possible.length>0
+          log possible
+          possible.shuffle!
+      
+          log "sorting"
+          
+          # TODO: sort by distance - take this, which is farthest away
+          
+      
+          begin
+            @transceiver.connect(possible[0]) if possible.length>0
+          
+            possible=possible[0]
+            insertNode(Node.new(possible,0,possible))
+          rescue Errno::ECONNREFUSED
+            log "Connection refused"
+          end 
+        end
+      
+    end
+  end
+  
+  def getNewFromMaster
+    log "current nodecount #{@nodeList.length}"
+    lookupApp=getApp(:networkLookup)
+    if lookupApp
+      servers=lookupApp.getServers
+      log "loaded Servers from master:",servers
+      servers.each{|server|
+        log "add to list #{server}"
+        insertNode(Node.new(server))
+        #if @nodeList[server].nil?
+        #  n=Node.new(server,:unreachable,nil)
+        #  log "add to list #{n.inspect}"
+        #  @nodeList[server]=n
+        #end
+      }
+    else
+     log "getNewFromMaster - failed - no networklookup"
+    end 
+    log "getNewFromMaster - ready"
+  end
+  
+  def getFromMaster
+    log "fetch servers from master"
+    servers=cluster.getApp(:networkLookup).getServers
+    servers.each{|server|
+      log "got server #{server} from master"
+      insertNewNodeDirect(Node.new(server,0))
+      log "inserted server #{server}"
+    }
+  end
+  
+end

data/apps/new_network_node/spec/new_network_node_spec.rb

@@ -0,0 +1,186 @@
+require 'network_node.rb'
+
+describe "New Network node" do
+
+  after(:each) do
+    TestBed::testbeds.should == []
+    TestBed::testbeds.each{|tb|tb.stop}
+  end
+  
+  it "should gather nodes from local storage" do
+    testBed1=TestBed.new
+    node1=testBed1.run("NewNetworkNode")
+    testBed2=TestBed.new
+    st=testBed2.run("LocalTupleSpace")
+    nodeList=[node1.myNodeId]
+    st.store(:networkNodeList,nodeList)
+    node2=testBed2.run("NewNetworkNode")
+    sleep 2
+    ((node2.nodeList-[node2.myNodeId]).sort).should == (nodeList.sort)
+    ((node1.nodeList-[node1.myNodeId]).sort).should == [node2.myNodeId]
+    testBed1.stop
+    testBed2.stop
+  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("NewNetworkNode")
+    n1=testBed2.run("NewNetworkNode")
+    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("NewNetworkNode",{:cronTime=>10000})
+      st<<b.run("LocalTupleSpace")
+    }
+    st[0].store(:networkNodeList,[ns[1].myNodeId])
+    puts "CRON>>>>>>>>>"
+    ns[0].runCron
+    # wait for ns[1] to answer
+    sleep 0.5
+    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
+  
+  
+  
+  it "should process local routes correctly" do
+    options={:minCompanions=>1}
+    testBed1=TestBed.new
+    testBed2=TestBed.new
+    testBed3=TestBed.new
+    n1=testBed1.run("NewNetworkNode",options)
+    n2=testBed2.run("NewNetworkNode",options)
+    n3=testBed3.run("NewNetworkNode",options)
+    
+    t1=testBed1.run("LocalTupleSpace")
+    t3=testBed3.run("LocalTupleSpace")
+    
+    t1.store(:networkNodeList,[n2.myNodeId])
+    t3.store(:networkNodeList,[n2.myNodeId])
+    
+    n1.runCron
+    n3.runCron
+    sleep 2
+    
+    nodes=[n1,n2,n3]
+    
+    nodes.map{|node|node.getRoutesDirectly}.flatten.each{|n|nodes.map{|m|m.myNodeId}.member?(n.node).should == true}
+
+    # chcek direct routes
+    n1.getValidRoutes(n2.myNodeId).map{|n|n.node}.should ==[n2.myNodeId]
+    n3.getValidRoutes(n2.myNodeId).map{|n|n.node}.should ==[n2.myNodeId]
+
+    n1.runCron
+    n3.runCron
+    
+    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("NewNetworkNode")
+    n2=bed2.run("NewNetworkNode")
+    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
+    
+  def dummyServers
+    [
+      NodeInformation.new("127.0.0.1",5678,:secure,"1234"),
+      NodeInformation.new("127.0.0.1",5900,:secure,"3456")
+    ]
+  end
+end