appswarm 0.0.1

data/apps/network_node/network_app.rb

@@ -0,0 +1,9 @@
+class NetworkApp
+  def initialize(cluster)
+    super
+    cluster.getApp(:networkNode)
+    
+    assert{networkNode}
+    @networkNode=networkNode
+  end
+end

data/apps/network_node/network_node.rb

@@ -0,0 +1,471 @@
+require 'service.rb'
+require 'net_service.rb'
+require 'breaking_mutex.rb'
+require File.expand_path('../remote_service.rb',__FILE__)
+require File.expand_path('../secure_node.rb',__FILE__)
+
+class NetworkNodeApp_Disabled<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)
+      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,:networkNode)
+    
+    @minCompanions=options[:minCompanions]
+    @maxCompanions=options[:maxCompanions]
+    @maxHops=options[:maxHops]
+    
+    @minCompanions||=MIN_COMPANIONS
+    @maxCompanions||=MAX_COMPANIONS
+    @maxHops||=MAX_HOPS
+    
+    @protocol=:secure
+    
+    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={}
+    @newNodes={}
+    
+    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=getRoute(nodeId)
+      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.values,
+     :newNodes=>@newNodes.length,
+     :services=>@services
+    }
+  end
+  
+  def nodeList
+    @nodeList.values.map{|node|node.node}
+  end
+  def nodeListRoute(timestamp=0)
+    @nodeList.values.map{|node|
+      n=node.dup
+      n.route=myNodeId
+      n
+    }.select{|n|n.timestamp>timestamp}
+  end
+  
+  def getRoutesDirectly
+    @nodeList.values
+  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 # FIXME: optimize this
+      log "call connectNodes..."
+      connectNodes
+      log "ready connectNodes."
+      log "ndodelist:",@nodeList.length
+      log "connected nodes:",@transceiver.nodeList.length
+      log "call findServices...."
+      findServices
+      log "ready findServices."
+      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 complete?
+    @nodeList.values.select{|node|node.route==:unreachable}==[]
+  end
+  
+  def getAllNodes
+    @nodeList
+  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 getRemoteService(api)
+    findServices if @services.nil?
+    s=@services.select{|s|s.provides.member?(api)}
+    RemoteService.new(s[0],self)
+  end
+  
+  def services
+    @services
+  end
+  
+  def nodeReachable(node)
+    getRoute(node)
+  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)
+    server=node.node
+    if @nodeList[server].nil?
+      log "add to list #{node} from companion replacing #{@nodeList[server]} - because not known"
+      @nodeList[server]=node
+    elsif @nodeList[server].hops==:unreachable 
+      log "add to list #{node} from companion replacing #{@nodeList[server]} - because yet unreachable"
+      @nodeList[server]=node
+    elsif node.hops==:unreachable
+      #nothing
+    elsif node.hops<@nodeList[server].hops
+      log "add to list #{node} from companion replacing #{@nodeList[server]} - because shorter"
+      @nodeList[server]=node
+    end
+  end
+
+
+  def getRoute(node)
+    #node=service
+    return nil unless @nodeList.key?(node)
+    route=@nodeList[node].route
+    if route==myNodeId
+      route=node
+    end
+    route
+  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 findServices
+    findServicesFromNeighbors
+    
+    # TODO: DNS !!!
+  end
+  
+  def findServicesFromNeighbors
+    log "known nodes",@nodeList
+    log "getting serviceList..."
+    
+    services=@transceiver.sendAll(:serviceList).flatten
+    pp "SERVICES:",services,"_____"
+    @services||=[]
+    @services+=services
+    @services.uniq!
+    pp "SERVICES2:",services,"_____"
+    
+    @services
+  end
+  
+  def registerAtMasterServer
+    app=getApp(:networkLookup)
+    app.register(myNodeId) if app
+  end
+  
+  def eventConnected(by)
+    log "eventConnected by #{by.pretty_inspect} me:#{myNodeId}"
+    @nodeList[by]=Node.new(by,0,by)
+    isConnected(by)
+  end
+  
+  def getNewFromLocalStorage
+    pp "getNewFromLOCAL"
+    @listMutex.synchronize {
+      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}"
+              @nodeList[server]=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=@nodeList.keys-@transceiver.nodeList
+        log "nodelist #:",@nodeList.length
+        log "possible #:",possible.length
+        if possible.length>0
+          log possible
+          possible.shuffle!
+      
+          log "sorting"
+          pp possible
+          puts "--"
+          possible.each{|a|pp @nodeList[a]}
+          puts "--"
+          possible.sort!{|a,b|
+            @nodeList[a] <=> @nodeList[b]
+          }
+          log "sorted"
+      
+          begin
+            @transceiver.connect(possible[0]) if possible.length>0
+          
+            possible=possible[0]
+            @listMutex.synchronize {
+            @nodeList[possible].hops=0
+            @newNodes[possible]=@nodeList[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
+      @listMutex.synchronize {
+        servers.each{|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