appswarm 0.0.1

data/lib/appswarm/routing/spec/routing_spec.rb

@@ -0,0 +1,91 @@
+if false
+
+$: << File.expand_path("../..",__FILE__)
+require File.expand_path('../../routing.rb',__FILE__)
+
+describe "Local Routing" do
+  it "should be possible to encode a neighbor and use it for routing" do
+    network=Nodes.new(30)
+    network.computeDistances
+    b=network.nodes[0]
+    l=LocalRouting.new(b,network)
+    n=b.neighbors[1]
+    p=l.getNodePos(n)
+    r=l.getRouteOrder(p)
+    puts r
+  end
+  
+end
+describe "Global Routing" do
+  it "positions should transferable forth and back" do
+    network=Nodes.new(30)
+    network.computeDistances
+    rts=network.nodes.map2hash{|n|
+      GlobalRouting.new(n,network)
+    }
+    b=network.nodes[0]
+    n=b.neighbors[1]
+    n2=(n.neighbors-b.neighbors)[0]
+    
+    p0=rts[n].getNodePos(n2)
+    p1=rts[b].translateFromNeighborToLocal(p0,n)
+    
+    p2=rts[n].translateFromNeighborToLocal(p1,b)
+    
+    perm0=p0.to_a.flatten.createPermutationFromOrder
+    perm1=p1.to_a.flatten.createPermutationFromOrder
+    perm2=p2.to_a.flatten.createPermutationFromOrder
+    
+    # the order should be the same
+    
+    perm0.should == perm2
+  end
+  it "should be possible to create global routing for all nodes in a decent time" do
+    network=Nodes.new(30)
+    network.computeDistances
+    i=0
+    rts=network.nodes.map2hash{|n|
+      puts i+=1
+      GlobalRouting.new(n,network)
+    }
+    
+    a,b=network.nodes[0..1]
+    
+    shortestPath=network.shortestPath(a,b)
+    puts shortestPath
+    
+    # propagate pos of b through *shortestPath* til a
+    p=rts[b].getNodePos(b)
+    last=b
+    puts p
+    
+    shortestPath.nodes.reverse[0..-1].each{|n|
+      i=shortestPath.nodes.index(n)
+      p=rts[n].translateFromNeighborToLocal(p,last)
+      puts "P #{i} #{p}"
+      last=n
+    }
+    puts "==="
+    # compute path from a to b
+    a2=a
+    i=1
+    p=rts[a2].getNodePos(shortestPath.nodes[1])
+    loop do
+      puts "I:",i
+      puts "P #{i} #{p}"
+      r=rts[a2].getRouteOrder(p)[0]
+      r.id.should == shortestPath.nodes[i].id
+      
+      break if r==b
+      p=rts[r].translateFromNeighborToLocal(p,a2)
+      a2=r
+      i+=1
+    end
+    
+  end
+  
+end
+
+  
+
+end

data/lib/appswarm/secure_con.rb

@@ -0,0 +1,437 @@
+require 'gserver'
+require 'secure_marshal.rb'
+require 'whiteboard.rb'
+
+module Secure
+  
+  
+  class IServer<GServer
+    def initialize(server,port,*args)
+      super(port,*args)
+      @server=server
+    end
+    
+    def serve(io)
+      begin
+        c=Connection.new(io,@server)
+        @server.addConnection(c)
+        c.receiveLoop
+      rescue Object=>e
+        pp "SERVING EXCEPTION",e
+      end 
+    end
+  end
+  
+  class Connection
+    attr_reader :valid
+    def initialize(conn,server)
+      @conn=conn
+      @data=""
+      @server=server
+      @conn.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      @valid=true
+      @mutex=Mutex.new
+    end
+    def send(*what)
+      return unless @valid
+        begin
+          data=Secure::Marshal.dump(what)
+          puts "Sending data #{data.length} from #{@conn.addr} to #{@conn.peeraddr}"
+          @mutex.synchronize {
+            if @valid
+              len=data.length
+              result=@conn.write(data)
+              assert {len==result}
+              @conn.flush
+            else
+              raise "Connection invalid"
+            end
+          }
+        rescue Exception=>e
+          glog e,e.backtrace
+          @valid=false
+        end
+    end
+    
+    def remotePort
+      begin
+        @conn.peeraddr[1]
+      rescue
+      end
+    end
+    def remoteHost
+      begin
+        @conn.peeraddr[3]
+      rescue
+      end
+    end
+
+    def disconnect(notifyRemote=true)
+      puts "Disconnecting from #{@conn.addr} to #{@conn.peeraddr}"
+      begin
+      #self.send(:closeConnection) if notifyRemote
+      #@mutex.synchronize {
+        #puts "SYNC Disconnecting from #{@conn.addr} to #{@conn.peeraddr}"
+        @valid=false
+        @server.removeConnection(self)
+        @conn.close
+      #}
+      rescue Object=>e
+        glog e
+      end
+    end
+    
+    # pseudo-private
+    def receiveLoop
+      return unless @valid
+      begin
+       loop do
+         curdata=@conn.recv(1012)
+         @data+=curdata
+         if curdata.length>0
+           pp "GOT DATA (at #{@conn.addr}) #{@data.length}"
+         else
+           puts "NO DATA"
+           break
+         end
+         d=Secure::Data.new(@data)
+         begin
+           result=Secure::Marshal.load(d)
+           # important: loop until buffer is empty, because it's possible that there are more than 1 messages in @data
+           while result
+             @server.receive(self,result)
+             @data=d.str
+             result=Secure::Marshal.load(d)
+           end
+         rescue Secure::Marshal::OutOfData=>e
+           pp e,@data
+         end
+         break unless @valid
+       end
+      rescue Exception=>e
+        #glog e,e.backtrace,self
+        unless e.inspect.to_s=="#<RuntimeError: stop>"
+          pp e,e.backtrace,self
+        end
+      end
+      @server.removeConnection(self)
+      @valid=false
+    end
+  end
+  
+  class Server
+    attr_reader :messages
+    attr_reader :connections
+    def initialize(port)
+      @iserver=IServer.new(self,port,"127.0.0.1",40)
+      @iserver.audit = true 
+      @iserver.start
+      @connections=[]
+      @messages=[]
+      @threads=[]
+      @hook=nil
+      @hookConnected=nil
+      @hookDisconnected=nil
+    end
+    def stop
+      @iserver.stop
+      @threads.each{|th|th.kill}
+    end
+    
+    def hook(&b)
+      @hook=b
+    end
+    def hookDisconnected(&b)
+      @hookDisconnected=b
+    end
+    def host
+      @iserver.host
+    end
+    def port
+      @iserver.port
+    end
+        
+    def receive(from,xy)
+      #pp "RECVED:#{from}:#{xy}"
+      if @xy==:closeConnection
+        from.disconnect(false)
+      elsif @hook
+        #pp "calling hook"
+        @hook.call(from,xy,Time.now)
+      else
+        #pp "pushing message"
+        @messages<<[from,xy,Time.now]
+      end
+    end
+    
+    def connect(there,port)
+      puts "#{self}:CONNECTING #{there} #{port}"
+      host=Socket.gethostbyname(there)
+      sock=TCPSocket.new(there,port)
+      c=Connection.new(sock,self)
+      @connections<<c
+      @threads<<Thread.new{
+        begin
+          puts "RECEIVING"
+          c.receiveLoop
+        rescue Object=>e
+          glog "Exception in connect-Thread " ,e
+        end
+      }
+      c
+    end
+    
+    def hookConnected(&hook)
+      @hookConnected=hook
+    end
+    
+    def eventConnected(con)
+      glog "eventConnected #{con}"
+      @hookConnected.call(con) if @hookConnected
+    end
+    
+    def addConnection(con)
+      glog "addConnection #{con}"
+      assert{con.is_a?(Connection)}
+      @connections<<con
+      eventConnected(con)
+    end
+    def removeConnection(con)
+      assert{con.is_a?(Connection)}
+      @connections.delete(con)
+      @hookDisconnected.call(con)
+    end
+  end
+  
+  Call=Struct.new(:type,:name,:args,:tx)
+  
+  class SimpleConnection
+    attr_writer :remotePort, :remoteHost
+    def initialize(server,c,localHost,localPort)
+      @c=c
+      @server=server
+      @c.send(Call.new(:hi,"hi",{:port=>localPort,:host=>localHost},true))
+    end
+    def method_missing(name,*args)
+      if @server.remote_sync_func?(name)
+        tx=@server.getTxId(self)
+        call=Call.new(:call,name,args,tx)
+        #puts "simplecon: sending #{call.inspect}"
+        @c.send(call)
+        # wait for @server to get return
+        #puts "WAIT FOR RETURN OF #{name} #{args.inspect} in tx #{tx}"
+        @server.getReturn(tx,self)
+      elsif @server.remote_func?(name)
+        call=Call.new(:call,name,args,nil)
+        pp "CALL",call
+        @c.send(call)
+      else
+        super
+      end
+    end
+    def remoteHost
+      return @remoteHost if @remoteHost
+      @c.remoteHost
+    end
+    def remotePort
+      return @remotePort if @remotePort
+      @c.remotePort
+    end
+    
+    def disconnect
+      @c.disconnect
+    end
+    
+    def connection
+      @c
+    end
+  end
+  
+  RemoteExceptionMS=Struct.new(:embedded)
+  class RemoteExceptionMS
+    def initialize(emb=nil)
+      self.embedded=[]
+      if emb.is_a?(Exception)
+        self.embedded=[emb.to_s,emb.backtrace.to_s]
+      end
+    end
+  end
+  
+  class RemoteException<Exception
+    attr_reader :embedded
+    def initialize(rems)
+      @embedded=rems.embedded
+    end
+    def to_s
+      super+":["+@embedded.to_s+"]"
+    end
+  end
+  
+  class SimpleServer
+    def initialize(port)
+      @@allowed||=[]
+      @remote=[]
+      @txMutex=Mutex.new
+      @txId=0
+      @server=Server.new(port)
+      @rtMutex=Mutex.new
+      @returns={}
+      @exceptions={}
+      @connections={}
+      @identified={}
+      @txs={}
+      @whiteboard=Whiteboard.new
+      
+      @server.hookDisconnected{|from|
+        if @txs[from]
+          @whitebaord.put(@txs[from],:disconnected)
+        end
+      }
+      
+      @server.hook{|from,msg,time|
+        msg=msg[0]
+        # pp "MSG:#{msg}"
+        if msg.is_a?(Call)
+          if msg.type==:call
+            name=msg.name
+            if @@allowed.member?(name)
+              args=msg.args
+              finished=false
+              begin
+                result=self.send(name,*args)
+                finished=true
+              rescue Object=>e
+                if msg.tx
+                  from.send(Call.new(:exception,name,RemoteExceptionMS.new(e),msg.tx))
+                end
+              end
+              if msg.tx
+                if finished
+                  from.send(Call.new(:return,name,result,msg.tx))
+                else
+                end
+              end
+
+            else
+              glog "invalid access with #{msg} from #{from} at #{time}"
+            end
+          elsif msg.type==:return
+            @whiteboard.put(msg.tx,[:return,msg.args])
+            if false
+              @rtMutex.synchronize {
+                #puts "adding return #{msg.tx} #{msg.tx.class} on #{self}"
+                @returns[msg.tx]=msg.args
+                ##pp @returns
+              }
+            end
+          elsif msg.type==:exception
+            @whiteboard.put(msg.tx,[:exception,msg.args])
+            #@rtMutex.synchronize {
+            #  @exceptions[msg.tx]=msg.args
+            #}
+          elsif msg.type==:hi
+            con=checkCon(from)
+            con.remotePort=msg.args[:port]
+            con.remoteHost=msg.args[:host]
+            eventConnected(con.remoteHost,con.remotePort)
+          end
+        end
+      }
+      @server.hookConnected {|con|
+        # nothing ATM - let it say "hi" first (see above)
+      }
+    end
+    
+    def getReturn(tx,conn)
+      result=@whiteboard.get(tx)
+      case result[0]
+        when :return
+          return result[1]
+      else
+          raise RemoteException.new(result[1])
+      end
+      
+      
+      loop do
+        #puts "waiting for return...#{tx} #{tx.class} (on #{self})"
+        @rtMutex.synchronize {
+          if @returns.key?(tx)
+            r=@returns[tx] 
+            @returns.delete(tx)
+            return r
+          end
+          if @exceptions.key?(tx)
+            r=@exceptions[tx] 
+            @exceptions.delete(tx)
+            raise RemoteException.new(r)
+          end
+        }
+        raise "Connection closed" unless conn.connection.valid
+        sleep 0.1
+      end      
+    end
+    
+    def getTxId(conn)
+      cid=nil
+      @txMutex.synchronize {
+        @txId+=1
+        cid=@txId
+        @txs[cid]=conn
+      }
+      cid
+    end
+    
+    def self.allow(*funcNames)
+      @@allowed||=[]
+      @@allowed+=funcNames
+    end
+    def self.remote(*funcNames)
+      @@remote||=[]
+      @@remote+=funcNames
+    end
+    def self.remote_sync(*funcNames)
+      @@remote_sync||=[]
+      @@remote_sync+=funcNames
+    end
+    
+    def connections
+      @server.connections.map{|c|checkCon(c)}
+    end
+    
+    def connect(host,port)
+      checkCon(@server.connect(host,port))
+    end
+    
+    def remote_func?(name)
+      @@remote||=[]
+      @@remote.member?(name)
+    end
+    def remote_sync_func?(name)
+      @@remote_sync||=[]
+      @@remote_sync.member?(name)
+    end
+    
+    def localHost
+      @server.host
+    end
+    def localPort
+      @server.port
+    end
+    
+    def stop
+      @server.stop
+    end
+    
+    def eventConnected(host,port)
+      glog "eventConnected #{host},#{port}"
+      #  pure virtual
+    end
+    private
+    def checkCon(con)
+      assert{con.valid}
+      @connections[con]||=SimpleConnection.new(self,con,localHost,localPort)
+      @connections[con]
+    end
+      
+  end
+end