appswarm 0.0.1

data/apps/name_service/name_service.rb

@@ -0,0 +1,75 @@
+class NameServiceApp<Service
+  provides :nameService
+  requires :directoryService
+  requires :localFileStore
+  
+  def initialize(cluster,ops)
+    super(cluster,ops,:nameService)
+    @cache={}
+    tryLoad
+    @cache.each{|k,v|export(k,v)}
+  end
+  
+  def run
+    wait4DS
+    super
+    
+  end
+  
+  def get(url)
+    wait4DS
+    result=getApp(:directoryService).get([:nameService,url])
+    @cache[url]=result
+  end
+  
+
+  def export(url,instance)
+    @cache[url]=instance
+    getApp(:directoryService).set([:nameService,url],instance)
+    trySave
+  end
+  
+  def clear
+    @cache={}
+  end
+  
+  def stop
+    # FIXME: export anything to others
+    trySave
+    super
+  end
+  
+  def content
+    @cache
+  end
+  
+  #private  
+  def wait4DS
+    wait=2
+    x=0.1
+    while wait>0
+      break if getApp(:directoryService)
+      sleep x
+      wait-=x
+    end
+  end
+  private
+  
+  def trySave
+    begin
+      retrieveConfig["cache"]=@cache
+    rescue Object=>e
+      pp e,e.backtrace
+    end
+  end
+  
+  def tryLoad
+    begin
+      @cache=retrieveConfig["cache"].content
+    rescue Object=>e
+      pp e,e.backtrace
+    end
+    @cache||={}
+  end
+  
+end

data/apps/name_service/spec/name_service_spec.rb

@@ -0,0 +1,51 @@
+require 'tools/tracing.rb'
+
+#Tracer.enable
+
+describe "Name Service" do
+  it_should_behave_like "AppSwarm Test"
+  it "can export names and all connected nodes can look it up" do
+    b=NetworkTestBed.new(10)
+    b.run("NetworkDiscoveryUdp","UdpNetwork","NameService")
+    b.eachApp(:nameService){|app|app.clear}
+    n=b.first(:nameService)
+    sleepDebug 7
+    n.export("myName","myHost")
+    b.eachApp(:nameService){|app|app.get("myName").should == "myHost"}
+    b.stop
+  end
+  it "can retrieve names at will" do
+    b=NetworkTestBed.new(10)
+    b.run("NetworkDiscoveryUdp","UdpNetwork","NameService")
+    b.eachApp(:nameService){|app|app.clear}
+
+    sleepDebug 5
+    map={1=>2,3=>4,5=>6,7=>8}
+    1.upto(map.length){|i|
+      key=map.keys[i-1]
+      b.app(:nameService,i-1).export(key,map[key])
+    }
+
+    b.eachApp(:nameService){|app|
+      map.keys.each{|key|
+        app.get(key).should == map[key]
+      }
+    }
+
+    b.stop
+  end
+  it "should store and load dictionary" do
+    b=TestBed.new
+    n=b.run("NameService")
+    sleepDebug 0.2
+    n.clear
+    n.export("MyUrl","MyHost")
+    b.stop
+    b=TestBed.new(:testbedId=>b.testbedId)
+    n=b.run("NameService")
+    sleepDebug 0.1
+    pp n.content
+    n.get("MyUrl").should == "MyHost"
+    b.stop
+  end
+end

data/apps/network_discovery/network_discovery.rb

@@ -0,0 +1,45 @@
+class NetworkDiscoveryApp<Service
+  DISCOVERY=[:networkDiscoveryLocalstore,:networkDiscoveryUdp]
+  
+  requires *DISCOVERY
+  provides :networkDiscovery
+  
+  
+  def initialize(cluster,options)
+    super(cluster,options,:networkDiscovery)
+    
+    
+    @discovery=options[:discovery]
+    @discovery||=DISCOVERY
+    
+  end
+  
+  def add(node)
+    @discovery.each{|d|
+      a=getApp(d)
+      if a
+        a.add(node)
+      end
+    }
+  end
+  
+  def remove(node)
+    @discovery.each{|d|
+      a=getApp(d)
+      if a
+        a.remove(node)
+      end
+    }
+  end
+
+  def get
+    @discovery.map{|d|
+      a=getApp(d)
+      if a
+        a.get
+      else
+        []
+      end
+    }.flatten.uniq
+  end
+end

data/apps/network_discovery_localstore/network_discovery_localstore.rb

@@ -0,0 +1,20 @@
+class NetworkDiscoveryLocalstoreApp<Service
+  provides :networkDiscoveryLocalstore
+  
+  def initialize(cluster,options)
+    super(cluster,options,:networkDiscoveryLocalstore)
+    
+    @nodes=[]
+  end
+  
+  def add(node)
+    @nodes<<node
+  end
+  def remove(node)
+    @nodes.delete(node)
+  end
+  
+  def get
+    @nodes.uniq
+  end
+end

data/apps/network_discovery_udp/network_discovery_udp.rb

@@ -0,0 +1,51 @@
+class NetworkDiscoveryUdpApp<Service
+  requires :udpBroadcast
+  provides :networkDiscoveryUdp
+  
+  def initialize(cluster,options)
+    super(cluster,options,:networkDiscoveryUdp)
+    @nodes=[]
+    @myNodes=[]
+    @mutex=Mutex.new
+    @quit=false
+  end
+  
+  def add(node)
+    @myNodes << node
+  end
+  
+  def remove(node)
+    @myNodes.delete(node)
+  end
+  
+  def get
+    (@nodes+@myNodes).uniq
+  end
+  
+  def run
+    begin
+      @broadcast=getApp(:udpBroadcast)
+      sleep 2
+    end while @broadcast.nil?
+    @connection=@broadcast.connect("networkDiscovery"){|result|
+      @mutex.synchronize {
+        @nodes << result
+        @nodes.uniq!
+      }
+    }
+    
+    loop do
+      @myNodes.uniq.each{|node|
+        @connection.send(node)
+      }
+      sleep 2
+      break if @quit
+    end
+    
+  end
+  
+  def stop
+    super
+    @quit=true
+  end
+end

data/apps/network_lookup/network_lookup.rb

@@ -0,0 +1,61 @@
+#if false
+require 'service.rb'
+require 'crypt.rb'
+require 'drb'
+
+DRb.start_service
+
+class NetworkLookupApp<Service
+  attr_reader :mid
+  def initialize(cluster,options)
+    super(cluster,options,:networkLookup)
+    provides(:networkLookup)
+    @mid=rand
+    @registered=[]
+  end
+  
+  def register(info)
+    begin
+      getMaster.register(info)
+      @registered<<info
+    rescue Errno::ECONNREFUSED
+      log("Cannot register, because cannot connect to master")
+    end
+  end
+  
+  def unregister(info)
+    @registered.delete(info)
+    getMaster.unregister(info) if @registered.member?(info)
+  end
+  
+  def stop
+    #Thread.new{
+    #  @registered.each{|info|getMaster.unregister(info)}
+    #}
+  end
+  
+  def getServers
+    getAllServers-@registered
+  end
+  
+  def getAllServers
+    begin
+      getMaster.clients
+    rescue
+      []
+    end
+  end
+  
+  private
+  def getMaster
+    puts "req"
+    
+    # TODO: use list of master-servers
+    
+    server_uri="druby://127.0.0.1:#{MasterApp::MASTER_SERVICE_PORT}"
+    drb=DRbObject.new_with_uri(server_uri)
+    drb 
+  end
+end
+
+#end

data/apps/network_node/abstract_node.rb

@@ -0,0 +1,104 @@
+require 'thread'
+
+NodeInformation=Struct.new(:address,:port,:protocol,:nodeHash)
+
+class NodeInformation
+  def to_s
+    "[#{protocol}://#{address}:#{port} #{nodeHash.inspect}]"
+  end
+  
+  def <=>(i)
+    r=(self.nodeHash<=>i.nodeHash)
+    return r if r!=0
+    r=(self.address<=>i.address)
+    return r if r!=0
+    r=(self.port<=>i.port)
+    return r if r!=0
+    r=(self.protocol<=>i.protocol)
+    return r if r!=0
+    0
+  end
+end
+
+class AbstractSendConnection
+  def initialize(baseSocket)
+    @baseSocket=baseSocket
+  end
+  def method_missing(*m)
+    
+  end
+  
+  
+  private
+  def send(message)
+    @baseSocket.send(message)
+  end
+end
+
+#class AbstractReceiveConnection
+#  def run
+#    @thread=Thread.new{
+#      
+#    }
+#  end
+#end
+
+class AbstractNetNode
+  include DRbUndumped
+  attr_reader :id
+  attr_accessor :hook
+  
+  def initialize(port,app,protocol,hash)
+    @id=NodeInformation.new(address,port,protocol,hash)
+    @app=app
+    @hook=nil
+  end
+  
+  def log(*s)
+    if @app
+      @app.log(*s)
+    else
+      puts s.map{|x|x.to_s}.join(" ")
+    end
+  end
+  
+  def port
+    @id.port
+  end
+  def protocol
+    @id.protocol    
+  end
+  def address
+    # TODO
+    "127.0.0.1"
+  end
+  
+  def setHook(&b)
+    @hook=b
+  end
+  
+  def method_missing(*s)
+    return @hook.call(*s) if @hook
+    super
+  end
+  
+  def node
+    @id    
+  end
+  
+  def sendTo(nodeId,*s)
+  end
+  def sendToAll(*s)
+  end
+  
+  def connect(nodeId)
+  end
+  
+  def close(nodeId)
+  end
+  
+  def nodes
+    []    
+  end
+end
+

data/apps/network_node/drb_node.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../abstract_node.rb',__FILE__)
+
+class DrbNetNode<AbstractNetNode
+  include DRbUndumped
+  
+  def initialize(port,app)
+    begin
+      super(port,app,:drb)
+      taint
+    
+      @uri="druby://#{address}:#{port}"
+      log @uri  
+      @service=DRb.start_service(@uri,self)
+      log "listening on #{@uri}"
+    rescue Exception=>e
+      log e.to_s
+      log e.backtrace.join("\n")
+    end
+    @companions={}
+  end
+  
+  def stop
+    @service.stop_service
+  end
+  
+  def connect(nodeId)
+    log "#{id} connecting #{nodeId}..."
+    return @companions[nodeId] if @companions[nodeId]
+    begin
+      server_uri="druby://#{nodeId.address}:#{nodeId.port}"
+      c=DRbObject.new_with_uri(server_uri)
+      @companions[nodeId]=c
+      log "#{id} ready connected #{nodeId}!"
+      log "NODES:",self.nodes
+      c.connected(self)
+      return c
+    rescue Exception=>e
+      log e.to_s
+      log e.backtrace.join("\n")
+    end
+    nil
+  end
+  
+  def close(nodeId)
+    rnode=@companions[nodeId]
+    return if rnode.nil?
+    eventDisconnected(nodeId)
+    @companions.delete(nodeId)
+    rnode.close(node)
+  end
+  
+  def eventDisconnected(pid)
+    log "#{id} disconnected from #{pid}"
+  end
+  
+  def sendTo(nodeId,*msg)
+    node=@companions[nodeId]
+    if node
+      node.send(*msg)
+    end
+  end
+
+  def sendAll(*msg)
+    @companions.values.map{|node|
+      log "send to node #{node.node}"
+      log msg
+      result=node.send(*msg)
+      log "sent to node #{node.node}."
+      result
+    }
+  end
+  
+  def info
+    {node.to_s=>@companions.keys}
+  end
+    
+  def connected(from)
+    i=from.node
+    log "#{id} connected from #{i}"
+    @companions[i]=from
+    log "NODES:",self.nodes
+    eventConnected(i)
+  end
+
+  def nodes
+    @companions.keys
+  end
+  
+  
+end