appswarm 0.0.1

data/apps/todo/model/user.rb

@@ -0,0 +1,5 @@
+module TodoModell
+class User<PersistentObject
+  
+end
+end

data/apps/todo/todo.rb

@@ -0,0 +1,21 @@
+require 'model/project.rb'
+require 'model/todo.rb'
+require 'model/comment.rb'
+
+class TodoApp<HTTPApp
+  requires :localObjectStorage
+  def initialize(cluster,ops)
+    super
+
+    #p=TodoModel::Project.new(store)
+    #p.name="MyProject"
+    #p.save
+  end
+  def run
+    provides :todo
+    super
+  end
+  def store
+    getApp(:localObjectStorage)
+  end
+end

data/apps/todo/views/_commentList.rhtml

@@ -0,0 +1,7 @@
+<ul>
+  <% part.comments.each{|comment| %>
+    <li>
+      <%=comment.text%>
+    </li>
+  <% } %>
+</ul>

data/apps/todo/views/_createProject.rhtml

@@ -0,0 +1,5 @@
+<form action="<%=url(:action=>:addProject)%>" method="post">
+Create new Project:<br>
+  <input type="text" name="projectName"></input>
+  <input type="submit"/>
+</form>

data/apps/todo/views/_partList.rhtml

@@ -0,0 +1,12 @@
+<% if parts.length==0  %>
+No Parts defined yet.
+<% end %>
+<ul>
+  <%  parts.each{|part| %>
+    <li>
+      <a href="<%=url(:action=>:editPart,:part=>part.objectId)%>">
+        <%=part.name%>
+      </a>
+    </li>
+  <% } %>
+</ul>

data/apps/todo/views/_projectList.rhtml

@@ -0,0 +1,16 @@
+Project #:<%=projects.length%><br>
+<table>
+<% projects.each{|project| %>
+  <tr>
+    <td>
+      <a href="<%=url(:action=>:edit,:project=>project.objectId)%>">
+        <%=project.name%>
+      </a>
+      (<%=project.creationDate%>)
+    </td>
+    <td>
+      <a href="<%=url(:action=>:delete,:project=>project.objectId)%>">Delete</a>
+    </td>
+  </tr>
+<% } %>
+</table>

data/apps/todo/views/edit.rhtml

@@ -0,0 +1,11 @@
+Editing Project <%=@project.name%>
+<br />
+
+<%= render_partial(:partList,:project=>@project.objectId) %>
+
+<br />
+Add Part:<br />
+<form method="post" action="<%=url(:action=>:addPart,:project=>@project.objectId)%>">
+  <input type="text" name="partName"></input>
+  <input type="submit"></input>
+</form>

data/apps/todo/views/editPart.rhtml

@@ -0,0 +1,10 @@
+Edit '<%=part.name%>' of '<%=part.project.name%>'
+
+<br />
+<%= render_partial(:commentList,:part=>part) %>
+
+<form method="post" action="<%=url(:action=>:addComment,:part=>part.objectId)%>">
+  Comment:
+  <input type="text" name="text"/>
+  <input type="submit"/>
+</form>

data/apps/todo/views/index.rhtml

@@ -0,0 +1,2 @@
+<%= render_partial(:projectList)%>
+<%= render_partial(:createProject)%>

data/apps/todo/views/question.rhtml

@@ -0,0 +1,4 @@
+<%=question%>
+<% choices.each{|item| name,url=item %>
+  <a href="<%=url%>"><%=name%></a>
+<% } %>

data/apps/transparent_network/transparent_network.rb

@@ -0,0 +1,7 @@
+
+
+class TransparentNetworkApp<Service
+  def initialize(cluster,options)
+    super(cluster,options,:transparentNetwork)
+  end
+end

data/apps/udp_network/big_transfer.rb

@@ -0,0 +1,97 @@
+
+# FIXME: maybe include check for package lost
+class BigTransfer
+  def initialize(node)
+    @node=node
+
+    @receivers={}
+    
+    @mutex=Mutex.new
+    @recMutex=Mutex.new
+    @pkgId=0
+    
+    @node.addReceiver(self) {|from,args|
+      receive(from,args)
+    }
+    
+    @packages={}
+  end
+  
+  def me
+    @node.me
+  end
+  
+  def addReceiver(api,&block)
+    @receivers[api]=block
+  end
+  
+  def removeReceiver(app)
+    @receivers.delete(app)
+  end
+  def log(*x)
+    @node.log(*x)
+  end
+  def stop
+    
+  end
+
+  # close the api-object - api won't listen anymore
+  def close
+    @node.removeReceiver(self)
+  end
+
+  def receive(from,args)
+    pkgId=nil
+    pkgs=nil
+    @mutex.synchronize {
+      assert{args.is_a?(Array)}
+      pkgId,str,i,pkgs=args
+      
+      @packages[pkgId]||=[]
+      @packages[pkgId]<<[str,i,pkgs]
+    }
+    if @packages[pkgId].length>=pkgs
+      
+      @recMutex.synchronize {
+        ps=@packages[pkgId].clone
+        ps=ps.uniq{|p|p[1]}
+        if ps.length==pkgs
+          # ps is mad unique - so if length is ok, data should be ok
+          data=ps.sort{|a,b| a[1].to_i <=> b[1].to_i}.map{|p|p[0]}.join("")
+          @receivers.each{|k,v|v.call(from,data)}
+          @packages.delete(pkgId)
+        else
+          puts "PKG recv-COUNT #{ps.length} #{ps.map{|p|p[1]}}"
+        end
+        
+      }
+    end
+  end
+  
+  def sendMessage(data,node)
+    assert{data.is_a?(String)}
+    maxSize=UdpTransceiver::UDPSize-UdpTransceiver::Overhead
+    
+    pkgs=(data.length.to_f/maxSize).ceil
+    i=0
+    pkgId=getNewPkgId
+    while data and data.length>0
+      str=data[0...maxSize]
+      data=data[maxSize..-1]
+      pkg=[pkgId,str,i,pkgs]
+      i+=1
+      @node.sendMessage(pkg,node)
+    end
+  end
+  
+  private
+  def getNewPkgId
+    id=nil
+    @mutex.synchronize {
+      @pkgId+=1
+      id=@pkgId
+    }
+    id
+  end
+  
+end

data/apps/udp_network/features/information.feature

@@ -0,0 +1,7 @@
+Feature: Udp network information
+
+  Scenario: Single network node
+    Given a testbed with a "UdpNetwork" application
+    When the info function of the "UdpNetwork" application is queried
+    Then the result contains the NodeId of the "UdpNetwork" application
+

data/apps/udp_network/message_queue.rb

@@ -0,0 +1,84 @@
+require 'tools/waiting_queue.rb'
+
+class MessageQueue
+  MIDDLE_PRIORITY=10
+  
+  def initialize(node,priority=nil)
+    
+    priority||=MIDDLE_PRIORITY
+    
+    @priority=priority
+    
+    @node=node
+
+    @receivers={}
+    
+    @mutex=Mutex.new
+    @recMutex=Mutex.new
+    @pkgId=0
+    
+    @node.addReceiver(self) {|from,args|
+      receive(from,args)
+    }
+    
+    @inQueue=WaitingQueue.new
+    @outQueue=WaitingQueue.new
+    
+    @rThread=Thread.new { receiveThread}
+    @sThread=Thread.new { sendThread}
+  end
+  
+  def me
+    @node.me
+  end
+  
+  def addReceiver(api,&block)
+    @receivers[api]=block
+  end
+  
+  def removeReceiver(app)
+    @receivers.delete(app)
+  end
+  def log(*x)
+    @node.log(*x)
+  end
+
+  # close the api-object - api won't listen anymore
+  def close
+    @rThread.stop
+    @node.removeReceiver(self)
+  end
+
+  def receive(from,args)
+    @inQueue<<[from,args]
+  end
+  
+  def sendMessage(data,node)
+    @outQueue<<[data,node]
+  end
+  
+  private
+  def receiveThread
+    begin
+      loop do
+        e=@inQueue.pop
+        from,data=e
+        @receivers.each{|k,v|v.call(from,data)}
+        pp e
      end
+    rescue Object=>e
+      pp e,e.backtrace
+    end
+  end
+  def sendThread
+    begin
+      loop do
+        e=@outQueue.pop
+        data,node=e
+        @node.sendMessage(data,node)
+        #sleep 0.2
+      end
+    rescue Object=>e
+      pp e,e.backtrace
+    end
  end
+end
+

data/apps/udp_network/network_interface_api.rb

@@ -0,0 +1,39 @@
+class NetworkInterfaceAPI
+  def initialize(node)
+    @node=node
+    @receivers={}
+    if @node
+      @node.addReceiver(self) {|from,args|
+        receive(from,args)
+      }
+    end
+  end
+  def me
+    @node.me
+  end
+  
+  def addReceiver(api,&block)
+    @receivers[api]=block
+  end
+  
+  def removeReceiver(app)
+    @receivers.delete(app)
+  end
+  def log(*x)
+    @node.log(*x)
+  end
+  
+  # close the api-object - api won't listen anymore
+  def close
+    @node.removeReceiver(self)
+  end
+  
+  def receive(from,args)
+    @receivers.each{|k,v|v.call(from,args)}
+  end
+
+  def sendMessage(data,node)
+    @node.sendMessage(data,node)
+  end
+
+end

data/apps/udp_network/qos_queue.rb

@@ -0,0 +1,186 @@
+require 'network_interface_api.rb' 
+
+class QoSQueue<NetworkInterfaceAPI
+  
+  class Connection
+    MAX_ACK_WAIT=3     # in seconds
+    MAX_ACK_WAIT_QUEUE = 4
+    SEND_PKGS=4
+    WAIT_TIME=1.5
+    
+    PKG_ACK="A"
+    PKG_NORMAL="N"
+    
+    def initialize(myNode,targetNode)
+      @myNode=myNode
+      @targetNode=targetNode
+      @queue=WaitingQueue.new
+      
+      @lastRecvAck=0
+      @sendId=0
+      @missBuffer=[]
+      @sendMutex=Mutex.new
+      
+      
+      @lastSentAckTime=Time.now
+      @completeReceived=0
+      @lastReceived=0
+      @lastAckNumberSend=0
+      @recvMutex=Mutex.new
+      
+      @inBuffer=[]
+      @quit=false
+      
+      @sendThread=Thread.new {
+        begin
+          send!
+        rescue Object=>e
+          pp e,e.backtrace
+        end
+      }
+      @sendThread[:type]=:sendThread
+      @missSendThread=Thread.new {
+        begin
+          missSend!
+        rescue Object=>e
+          pp e,e.backtrace
+        end
+      }
+      @missSendThread[:type]=:sendMissThread
+      
+    end
+    
+    def stop
+      puts "STOPPING QOS"
+      @quit=true
+      sleep 0.1
+      
+      @sendThread.kill
+      @missSendThread.kill
+      if @sendThread.alive?
+        sleep 0.1
+        @sendThread.kill!
+      end 
+      if @missSendThread.alive?
+        sleep 0.1
+        @missSendThread.kill!
+        puts "HARD KILL"
+      end
+    end
+    
+    def sendMessage(msg)
+      @queue<<msg
+    end
+    
+    def recv(data,receivers)
+      id,type,data=data
+      @recvMutex.synchronize {
+        case type
+          when PKG_ACK
+            pp "GOT ACK #{id} #{type} #{data}"
+            @lastRecvAck=id
+          when PKG_NORMAL
+            @lastReceived=[@lastReceived,id].max
+            @inBuffer<<id
+            while @inBuffer.member?(@completeReceived+1)
+              @completeReceived+=1
+              @inBuffer.delete(@completeReceived)
+            end
+            if Time.now-@lastSentAckTime>MAX_ACK_WAIT || @completeReceived-@lastAckNumberSend>MAX_ACK_WAIT_QUEUE
+              sendAck
+            end
+            receivers.each{|k,v|v.call(@targetNode,data)}
+        end
+      }
+      return nil
+    end
+    
+    private
+    
+    def quit?
+      @quit
+    end
+    
+    def sendAck
+      @myNode.sendMessage([@completeReceived,PKG_ACK,nil],@targetNode)
+      @lastSentAckTime=Time.now
+      @lastAckNumberSend=@completeReceived
+      puts "SENDING ACK #{@completeReceived} --- #{@lastReceived}"
+    end
+    
+    def send!
+      while not quit?
+        data=@queue.pop
+        
+        while @sendId-@lastRecvAck>MAX_ACK_WAIT_QUEUE
+          puts "ENQUEUE (waiting: #{@queue.length}"
+          sleep 0.2 # wait
+        end
+        @sendMutex.synchronize {
+          @sendId+=1
+          @myNode.sendMessage([@sendId,PKG_NORMAL,data],@targetNode)
+          puts "QoSSEND #{@sendId}"
+          @missBuffer<<[@sendId,data]
+        }
+      end
+    end
+    
+    def missSend!
+      while not quit?
+        if @sendId-@lastRecvAck>=MAX_ACK_WAIT_QUEUE
+          @sendMutex.synchronize {
+            # resend
+            @missBuffer=@missBuffer.select{|b|b[0]>@lastRecvAck}.sort_by{|b|b[0]}
+          }
+          @missBuffer[0...SEND_PKGS].each{|b|
+            id,data=b
+            puts "RESEND #{id}"
+            @myNode.sendMessage([id,PKG_NORMAL,data],@targetNode)
+          }
+        end
+        sleep WAIT_TIME
+      end
+    end
+  end
+  
+  
+  def initialize(node)
+    super
+    
+    @mutex=Mutex.new
+    @conns={}
+    @quit=false
+
+  end
+  
+  def conn(from)
+    @mutex.synchronize {
+      return nil if @quit
+      @conns[from]||=Connection.new(@node,from)
+    }
+  end
+  
+  def stop
+    puts "TRYING TO STOP QOS_QUEUE"
+    @mutex.synchronize {
+      puts "QOS_QUEUE stop #{@conns.length}"
+      @conns.each{|k,v|
+        puts "STOP:",v
+        v.stop
+      }
+      @quit=true
+    }
+  end
+  
+  def receive(from,args)
+    c=conn(from)
+    return c.recv(args,@receivers) if c
+    nil
+  end
+  
+  def sendMessage(data,node)
+    c=conn(node)
+    return c.sendMessage(data) if c
+    nil
+  end
+end