appswarm 0.0.1

data/lib/appswarm/tools/treetop_test_grammar.rb

@@ -0,0 +1,114 @@
+module TreetopTestGrammar
+  include Treetop::Runtime
+
+  def root
+    @root || :BasicString
+  end
+
+  module BasicString0
+  end
+
+  module BasicString1
+  end
+
+  def _nt_BasicString
+    start_index = index
+    if node_cache[:BasicString].has_key?(index)
+      cached = node_cache[:BasicString][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index('"', index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3 = index
+        i4, s4 = index, []
+        if input.index('\\', index) == index
+          r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('\\')
+          r5 = nil
+        end
+        s4 << r5
+        if r5
+          if index < input_length
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("any character")
+            r6 = nil
+          end
+          s4 << r6
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(BasicString0)
+        else
+          self.index = i4
+          r4 = nil
+        end
+        if r4
+          r3 = r4
+        else
+          if input.index(Regexp.new('[^"\\\\]'), index) == index
+            r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            r7 = nil
+          end
+          if r7
+            r3 = r7
+          else
+            self.index = i3
+            r3 = nil
+          end
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        if input.index('"', index) == index
+          r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('"')
+          r8 = nil
+        end
+        s0 << r8
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(BasicString1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:BasicString][start_index] = r0
+
+    return r0
+  end
+
+end
+
+class TreetopTestGrammarParser < Treetop::Runtime::CompiledParser
+  include TreetopTestGrammar
+end
+

data/lib/appswarm/tools/treetop_test_grammar.tt

@@ -0,0 +1,7 @@
+grammar TreetopTestGrammar
+   #
+
+  rule BasicString
+     '"' ('\\' . / [^"\\])* '"'
+  end
+end

data/lib/appswarm/tools/waiting_prio_queue.rb

@@ -0,0 +1,47 @@
+class WaitingPrioQueue
+  def initialize(&block)
+    @mutex=Mutex.new
+    if block
+      @block=block
+    else
+      @block=lambda {|a,b|a<=>b}
+    end
+    @buf=[]
+  end
+  
+  def push(value)
+    @mutex.synchronize {
+      @buf<<value
+    }
+    @waitThreads.each{|th|th.wakeup}
+    @waitThreads.uniq!
+    pp "PUSH",@waitThreads
+  end
+  def <<(value)
+    push(value)
+  end
+    
+  def pop
+    @waitThreads<<Thread.current
+    loop do
+      Thread.stop if empty?
+      @mutex.synchronize {
+        unless empty?
+          value=getBest
+          @waitThreads.delete(self)
+          pp "POP",@waitThreads
+          @waitThreads.uniq!
+          return value
+        end
+        
+      }
+    end
+  end
+  
+  private
+  def getBest
+    best=@buf.min(&block)
+    @buf.delete(best)
+    best
+  end
+end

data/lib/appswarm/tools/waiting_queue.rb

@@ -0,0 +1,34 @@
+class WaitingQueue<Queue
+  def initialize(*args)
+    super
+    @mutex=Mutex.new
+    @waitThreads=[]
+  end
+  
+  def push(value)
+    @mutex.synchronize {
+      super
+    }
+    @waitThreads.each{|th|th.wakeup}
+    @waitThreads.uniq!
+  end
+  def <<(value)
+    push(value)
+  end
+    
+  def pop
+    @waitThreads<<Thread.current
+    loop do
+      Thread.stop if empty?
+      @mutex.synchronize {
+        unless empty?
+          value=super
+          @waitThreads.delete(self)
+          @waitThreads.uniq!
+          return value
+        end
+        
+      }
+    end
+  end
+end

data/lib/appswarm/whiteboard.rb

@@ -0,0 +1,73 @@
+# whiteboard.rb contains Whiteboard class
+require 'thread'
+require 'pp'
+
+
+# Whiteboard is a pretty simple messaging class, that can be used for
+# different (local) threads. It's meant for use in storing incoming messages
+# for later processing.
+#  
+# The normal usage looks like this:
+#  w=Whiteboard.new
+#  <spawn thread1 and thread2>
+#  thread1: a=w.get(:myKey)
+#  <thread1 is suspended, because myKey is not there>
+#  thread2: w.put(:myKey,:myValue)
+#  <thread1 is woken up and has a==:myValue>
+#
+# This is NOT Possible:
+#  Whiteboard.new.put(:myKey,:myValue)
+# because nobody's listening for myKey
+#
+# This is NOT possible either:
+#  w=Whiteboard.new
+#  thread1: w.get(:myValue) 
+#  thread2: w.get(:myValue)
+# because thread1 is already waiting for this value
+#
+# in practise this is not a problem, because the values are transaction-ids within node communication should not be duplicated. 
+
+class Whiteboard
+  def initialize()
+    @cvs={}
+    @values={}
+    @mutex=Mutex.new
+  end
+  
+  # sends +value+ directly to the listening thread waiting for +name+
+  # if there's no waiting thread an exception is raised  
+  def put(name,value)
+    @mutex.synchronize {
+      raise "Conflict in put" if @values[name]
+      @values[name]=value
+      raise "No one listening" if @cvs[name].nil?
+      @cvs[name].wakeup
+      @cvs.delete(name)
+    }
+  end
+  
+  # waits for name to be put into the local store then returns the value
+  def get(name,timeout=nil)
+    value=nil
+    measureTime(7) {
+      @mutex.synchronize {
+        raise "Already value there" if @values[name]
+        raise "Already listening" if @cvs[name]
+        @cvs[name]=Thread.current
+      }
+      if timeout.nil?
+        Thread.stop
+      else
+        # FIXME:wait until timeout
+        Thread.stop
+      end
+      
+      @mutex.synchronize {
+        value=@values[name]
+        @values.delete(name)
+      }
+    }
+    value
+  end
+end
+

data/nettest.rb

@@ -0,0 +1,50 @@
+require 'pp'
+require 'rbconfig'
+require 'optparse'
+
+
+# run a new ruby-interpreter in a separate process and return it's pid 
+def ruby(*x)
+  rb="ruby"
+  $pcount||=0
+  $pcount+=1
+  pcount=$pcount
+  Process.fork {
+    fn="log#{pcount}.txt"
+    puts fn
+    puts `#{rb} #{x.join(" ")} >#{fn}` 
+  }
+end
+
+# default number of process is 4
+options={:count=>4}
+opts=OptionParser.new do |opts|
+  opts.banner = "Usage: nettest [options]"
+ 
+  opts.separator ""
+  opts.separator "Specific options:"
+ 
+  opts.on("-d", "--enable-debug",
+         "enable debugging") do 
+   options[:debug]=true
+  end
+  opts.on("--count PROESS_COUNT") do |count|
+    options[:count]=count.to_i
+  end
+  if block_given?
+   yield opts
+  end
+
+end
+
+opts.parse!
+pp options
+
+options[:count].times{|c|
+  puts "starting Process #{c}"
+  ruby("main.rb","--http-port",2000+c)
+}
+
+puts "Waiting for processes to finish..."
+
+Process.wait

data/packages/README.txt

@@ -0,0 +1 @@
+This directory will include packages with sandboxed applications.

data/packages/msandbox/data/packages/store/my.txt

@@ -0,0 +1 @@
+huhuhuhuhuhu

data/packages/msandbox/interfaces.rb

@@ -0,0 +1,172 @@
+#class InterfaceBase
+  def exposeInterface(klass,box,definition,*args)
+    klassName=klass.to_s
+    #args=args.map{|a|"'"+a.to_s+"'"}.join(",")
+    name=definition.name
+    iname=klassName+name
+    api=klass.interfaceApi.map{|f|
+      "def self.#{f}(*s)
+         begin
+           @@i.#{f}(*s)
+         rescue Object=>e
+           BasicInterface::puts e
+         end
+       end"
+    }.join("\n")
+    $myargs = args
+    s="
+    module #{iname}
+      @@i=#{klassName}.new(*$myargs)
+      #{api}
+    end"
+    #pp s
+    eval(s,binding)
+    
+    klass.class_eval("@@interface=#{iname}
+      def interface
+        @@interface
+      end
+    ")
+    
+    
+    $myargs = nil
+    
+    #pp iname
+    #exit
+    s="box.ref(#{iname})"
+    pp s
+    eval(s)
+    s="box.eval('#{klassName}=#{iname}')"
+    eval(s)
+
+  end
+
+
+class Class
+  def interfaceApi(*s)
+    @@interfaces||=[]
+    @@interfaces << self
+    @@api||=[]
+    s.each{|f|
+      @@api << f
+    }
+    @@api
+  end
+  def self.interfaceClasses
+     @@interfaces.uniq
+  end
+end
+
+
+class BasicInterface
+  interfaceApi :test, :puts, :pp
+  def test
+    puts "TEST"
+  end
+  def puts(*s)
+    Kernel::puts(*s)
+  end
+  def pp(*s)
+    self.puts s.inspect
+  end
+end
+
+class FSInterface
+  def initialize(dir)
+    @dir=dir
+  end
+
+  interfaceApi :save, :load
+
+  def save(filename,content)
+    raise AccessViolation unless filename=~/^[a-zA-Z_\.0-9]*$/
+    p=File.join(@dir,filename)
+    puts "saving ",p
+    File.open(p,"w") do |f|
+      f.puts content
+    end
+  end
+
+  def load(filename)
+    raise AccessViolation unless filename=~/^[a-zA-Z_\.0-9]*$/
+    p=File.join(@dir,filename)
+    #puts "loading ",p
+    File.open(p) do |f|
+      f.read
+    end
+  end
+  
+
+  def self.create(box,definition,server)
+    exposeInterface(self,box,definition,"data/packages/#{definition.name}")
+  end
+end
+
+class RequireInterface
+  interfaceApi :loadPrg
+  
+  def initialize(path)
+    @path=path
+  end
+  
+  def loadPrg(filename)
+    raise AccessViolation unless filename=~/^[a-zA-Z_\.0-9]*$/
+    p=File.join(@path,filename)
+    File.open(p) do |f|
+      f.read
+    end
+  end
+  
+  def self.create(box,definition,server)
+    exposeInterface(self,box,definition,"packages/#{definition.name}")
+  end
+  
+end
+
+class OtherPackage
+  def initialize(pkgname)
+    @pkgname=pkgname
+  end
+  def method_missing(*s)
+    #pp s
+    PackageInterface::run(@pkgname,*s)
+  end
+end
+
+
+class PackageInterface
+  interfaceApi :package, :run
+  
+  def initialize(server)
+    @server=server
+  end
+  
+  def run(*x)
+    
+    pp x
+    @server.interface(x[0]).send(*x[1..-1])
+  end
+  
+  def package(name)
+    pp "PACKAGE:",name,interface
+    OtherPackage.new(name)
+    #nil
+  end
+  
+  def self.create(box,definition,server)
+    box.eval("class OtherPackage
+  def initialize(interface,pkgname)
+    @interface=interface
+    @pkgname=pkgname
+  end
+     def method_missing(*s)
+       PackageInterface::run(@pkgname,*s)
+     end
+end
+")
+       
+    exposeInterface(self,box,definition,server)
+  end
+end
+
+#INTERFACES=[BasicInterface,FSInterface]