appswarm 0.0.1

data/apps/node_broadcast/node_broadcast.rb

@@ -0,0 +1,167 @@
+require 'secure_marshal.rb'
+require 'ipaddr'
+
+class NodeBroadcastApp<Service
+  
+  provides :udpBroadcast
+  
+  
+  PORT=8472
+  UDPSize = 512
+  
+  SO_REUSEPORT = 0x0200
+
+  MULTICAST_ADDR= '228.5.6.8'
+
+  def initialize(cluster,options)
+    super(cluster,options,:udpBroadcast)
+    
+    @port=options[:broadcast_port]
+    #@bind="localhost"
+    #    @bcs=['<broadcast>','localhost','<any>',MULTICAST_ADDR]
+    @bcs=[MULTICAST_ADDR]
+    
+    @protocols={}
+    
+    @bind=MULTICAST_ADDR
+    @port||=PORT
+    
+    addr=@bind
+    host  = Socket.gethostname
+    maddr = addr.split('.').collect! { |b| b.to_i }.pack('CCCC')
+  
+    sa=(Socket.gethostbyname(host)[3])[4..7]
+
+    mreq  = maddr + sa
+    ip=mreq
+    @socket=UDPSocket.open
+    
+    # enable support for multiple apps on single pc
+    @socket.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR,1)
+    @socket.setsockopt(Socket::SOL_SOCKET,SO_REUSEPORT,1)
+    
+    # bind
+    @socket.bind(@bind,@port)
+    # submit membership to multicasting
+    @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, ip)
+    
+    @mutex=Mutex.new
+    @inBuffer=[]
+    @connectIds=0
+  end
+  
+  def run
+    begin
+      recvLoop
+    rescue
+    end
+  end
+  
+  class Protocol
+    def initialize(name,proxy)
+      @name=name
+      @blocks=[]
+      @proxy=proxy
+    end
+    def push(block,id)
+      @blocks<<[block,id]
+    end
+    def close(id)
+      @blocks.delete_if{|i|i[1]==id}
+    end
+    def send(x)
+      @proxy.send(@name,x)
+    end
+    def recv(o)
+      @blocks.each{|b|b[0].call(o)}
+    end
+  end
+  class Connection
+    def initialize(id,protocol)
+      @id=id
+      @protocol=protocol
+    end
+    def close
+      @protocol.close(id)
+    end
+    def send(x)
+      @protocol.send(x)
+    end
+  end
+  
+  def connect(protocol,&block)
+    id=nil
+    Thread.critical do
+      @connectIds+=1
+      id=@connectIds
+    end
+    @protocols[protocol]||=Protocol.new(protocol,self)
+    
+    @protocols[protocol].push(block,id)
+    
+    
+    Connection.new(id,@protocols[protocol])
+  end
+  
+  def send(name,object)
+    sendStr(Secure::Marshal::dump([name,object]))
+  end
+  
+  def stop
+    @quit=true
+    @socket.close
+    super
+  end
+  
+  
+  def buffer(&block)
+    finished=false
+    while finished==false do
+      arg=nil
+      @mutex.synchronize {
+        if @inBuffer.length>0
+          arg=@inBuffer.shift
+        end
+      }
+      block.call(arg) unless arg.nil?
+      @mutex.synchronize {
+        finished=true if @inBuffer.length==0
+      }
+    end
+  end
+  
+  def push(str)
+    begin
+      s=str[0]
+      o=Secure::Marshal::load(s)
+      if @protocols[o[0]]
+        @protocols[o[0]].recv(o[1])
+      else
+        warning "WARNING: NodeBroadcast: Protocol #{o[0]} unknown !!!!!"
+      end
+    rescue Object=>e
+      pp e
+      @inBuffer << str
+    end
+  end
+  
+  def sendStr(str)
+    soc=UDPSocket.open
+    soc.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+    @bcs.each{|bc|
+      begin
+        soc.send(str,0,bc,@port)
+      rescue Object=>e
+        pp e
+      end
+    }
+  end
+  
+  def recvLoop
+    loop do
+      IO.select([@socket])
+      r=@socket.recvfrom_nonblock(UDPSize)
+      push(r)
+    end
+  end
+end

data/apps/node_broadcast/spec/node_broadcast_spec.rb

@@ -0,0 +1,59 @@
+describe "Node broadcasting" do
+  it "should work at all" do
+    b=TestBed.new
+    bc=b.run("NodeBroadcast")
+    str="HUPE"
+    bc.sendStr(str)
+    ret=:nothinYet
+    sleep 0.05
+    bc.buffer{|buffer|
+      ret=buffer[0]
+    }
+    ret.should == str
+    b.stop
+  end
+  
+  
+  it "should work for simple protocols" do
+    b=TestBed.new
+    bc=b.run("NodeBroadcast")
+    result=nil
+    connection=bc.connect("nodeBroadcasting"){|result|
+    }
+    str="MUH sdkjhdf kdjh sh"
+    connection.send(str)
+    sleep 0.5
+    result.should == str
+    b.stop
+  end
+  
+  it "should work with 2 (or more) broadcasters on a single pc" do
+    b1=TestBed.new
+    b2=TestBed.new
+    
+    bc1=b1.run("NodeBroadcast")
+    bc2=b2.run("NodeBroadcast")
+    
+    r1=[]
+    r2=[]
+    
+    c1=bc1.connect("bcTest"){|result|
+      r1 << result
+    }
+    c2=bc2.connect("bcTest"){|result|
+      r2 << result
+    }
+    
+    c1.send("C1")
+    c2.send("C2")
+    
+    sleep 2
+    
+    r1.uniq.should == r2.uniq
+    r1.uniq.sort.should == ["C1","C2"].sort
+
+    b1.stop
+    b2.stop
+
+  end
+end

data/apps/permaspace/permaspace.rb

@@ -0,0 +1,47 @@
+require 'service.rb'
+
+class PermaspaceApp<Service
+  provides :permaspace
+  def initialize(cluster,options)
+    super(cluster,options,:permaspace)
+  end
+  def store(name,what)
+    mid=id(name)
+    if name!=""
+      f=File.open(File.join(getAppDataWritePath,mid),"w")
+
+      f.print what
+      f.close
+      return true
+    end
+    false
+  end
+  def load(name)
+    mid=id(name)
+    if mid!=""
+      getAppDataPaths.each{|path|
+        fname=File.join(path,mid)
+        if File.exists?(fname)
+          f=File.open(fname)
+          what=f.read
+          f.close
+          return what
+        end
+      }
+    end
+    nil
+  end
+  
+  def rm(name)
+    mid=id(name)
+    fname=File.join(getAppDataWritePath,mid)
+    if File.exists?(fname)
+      File.rm_f(fname)
+    end
+  end
+  
+  private 
+  def id(name)
+    name.gsub(/[^a-zA-Z0-9_]/,'')
+  end
+end

data/apps/plaindb/lib/btree.rb

@@ -0,0 +1,38 @@
+class BTree
+
+  class Node
+    def initialize(tree,parent)
+      @parent=parent
+      @tree=tree
+      @values=[]
+      @nodes=[]
+    end  
+    
+    
+    
+    private
+    def check
+      if @nodes.length>@tree.maxNodes
+      elsif @nodes.length<@tree.minNodes
+      end 
+    end
+  end  
+  
+  attr_reader :maxNodes, :minNodes
+  
+  def initialize(minNodes,maxNodes)
+    @minNodes=minNodes
+    @maxNodes=maxNodes
+    @root=Node.new(self,nil)    
+  end
+  
+  def insert(element)
+    @root.insert(element)
+  end
+  
+  def delete(element)
+    @root.delete(element)
+  end
+  
+  
+end

data/apps/plaindb/plaindb.rb

@@ -0,0 +1,199 @@
+require 'service.rb'
+
+class PlaindbApp<Service
+  
+  class Column
+    attr_reader :name, :length, :type
+    def initialize(name,length,type)
+      @name=name
+      @length=length
+      @type=type
+    end
+    
+    def self.int(name)
+      Column.new(name,4,:int)
+    end
+    def self.string(name,len=256)
+      Column.new(name,len,:string)
+    end
+    def packString
+      case @type
+        when :int
+          "N"
+        when :string
+          "a#{@length}"
+      end      
+    end
+  end
+  
+  class TableDefinition
+    attr_reader :columns
+    def initialize
+      @columns=[]
+    end
+    def add(column)
+      @columns<<column
+    end
+    def getId(name)
+      @columns.select{|col|col.name==name}[0]
+    end
+    def packString
+      columns.map{|col|
+        col.packString
+      }.join("")
+    end
+  end
+  
+  class Row
+    attr_accessor :definition
+    attr_reader :data
+    
+    def initialize(*data)
+      if data.length==2
+        if data[1].is_a?(TableDefinition) and data[0].is_a?(String)
+          @definition=data[1]
+          colCount=@definition.columns.length
+          tmp=data[0].unpack(@definition.packString+"N"*colCount)
+          @data=tmp[0..(colCount-1)]
+          lens=tmp[colCount..-1]
+          (0...colCount).each{|i|
+            if @definition.columns[i].type==:string
+              @data[i]=@data[i][0...lens[i]]
+            end
+          }
+          
+          return
+        end
+        
+      end
+      @data=data
+    end    
+    def ==(row)
+      @data==row.data
+    end
+    def [](id)
+      if id.is_a?(Numeric)
+        @data[id]
+      else
+        @data[@definition.getId[id]]
+      end     
+    end
+    
+    def to_bs(definition)
+      @data.pack(definition.packString)+@data.map{|d|
+        if d.respond_to?(:length)
+          d.length
+        else
+          0          
+        end
+      }.pack("N"*@data.length)
+    end      
+    
+  end
+  
+  class Table
+    attr_reader :rowLength
+    def initialize(db,table,definition)
+      @db=db
+      @table=table
+      @definition=definition
+      
+      @rowLength=@definition.columns.inject(0){|size,column|size+column.length}+[0].pack("N").length*@definition.columns.length
+    end
+    
+    def [](id)
+      
+    end
+    
+    def insert(row)
+      
+    end
+    def rows
+      
+    end
+    
+  end
+  
+  class FileTable<Table
+    VALID_RECORD=0
+    INVALID_RECORD=1
+    
+    def initialize(db,table,definition)
+      super
+      @filename=db+"_"+table+".tab"
+      @handle=File.open(@filename,"w+")
+      @@stateSize=[VALID_RECORD].pack("N").length
+    end
+    def flush
+      @handle.flush
+    end
+    def size
+      @handle.lstat.size/rowLength
+    end
+    
+    def delete(rowNumber)
+      pos=getPos(rowNumber)
+      @handle.seek(pos,IO::SEEK_SET)
+      @handle.write([INVALID_RECORD].pack("N"))
+    end
+
+    def insert(row)
+      store(row,size)
+    end
+    def store(row,rowNumber)
+      pos=getPos(rowNumber)
+      @handle.seek(pos,IO::SEEK_SET)
+      state=VALID_RECORD #
+      data=[state].pack("N")+row.to_bs(@definition)
+      @handle.write(data)
+    end
+    def load(rowNumber)
+      pos=getPos(rowNumber)
+      @handle.seek(pos,IO::SEEK_SET)
+      data=@handle.read(rowLength+@@stateSize)
+      state=data.unpack("N")
+      return nil if state==INVALID_STATE
+      data=data[@@stateSize..-1]
+      data=Row.new(data,@definition)
+    end
+   private
+    def getPos(rowNumber)
+      rowNumber*(rowLength+@@stateSize)
+    end
+  end
+  
+  class DB
+    def initialize(db)
+      @db=db
+      @tables={}
+    end
+    
+    def getTable(table,definition=nil)
+      @tables[table]||=FileTable.new(@db,table,definition)
+    end
+    
+    private
+    
+  end
+  
+  class Join
+    
+  end
+  
+  def initialize(cluster,options)
+    super(cluster,options,:plaindb)
+    @dbs={}
+  end
+  
+  def getDB(user,pw)
+    id=getID(user,pw)
+    @dbs[id]||=DB.new(getAppDataPath,id)
+  end
+  
+  private
+  def getID(user,pw)
+    #FIXME: use sha1 or the like
+    user+pw
+  end
+
+end