appswarm 0.0.1

data/lib/appswarm/simple_marshal_parser.tt

@@ -0,0 +1,158 @@
+grammar SimpleMarshal
+
+  rule Elements
+    Fill e:Element Fill {
+      def sload
+        e.sload
+      end
+    }
+  end
+  rule Element
+    Fill e:RElement Fill {
+      def sload
+        e.sload
+      end
+    } 
+  end 
+  rule RElement
+    Struct / Hash / Symbol / String / Array / Boolean / Nil / Number
+  end
+  
+  rule Symbol
+    ':' name:([_a-zA-Z] [0-9a-zA-Z_]*) {
+      def sload
+        name.text_value.to_sym
+      end
+    }
+  end
+  
+  rule Boolean
+    'true' {
+      def sload
+        true
+      end
+     }
+     /
+     'false' {
+       def sload
+         false
+       end
+     }
+  end
+  rule Nil
+    'nil' {
+      def sload
+        nil
+      end
+     }
+  end
+  
+  rule Hash
+    '{' Fill '}' {
+      def sload
+        {}
+      end
+    }
+    /
+    '{' l:HashList '}' {
+      def sload
+        l.sload
+      end
+    }
+    
+  end
+  
+  rule HashList
+    k:Element '=>' v:Element mein_rest:(',' ek:Element '=>' ev:Element)* {
+     def sload
+       h={}
+       h[k.sload]=v.sload
+       mein_rest.elements.each{|x|
+         h[x.ek.sload]=x.ev.sload
+       }
+       h
+     end
+    }
+  end
+  
+  rule Number
+    '-'? [0-9]* ('.' [0-9]*)? {
+      def sload
+        s=text_value
+        if s=~/\./
+          return s.to_f
+        else
+          return s.to_i
+        end
+      end
+    }
+  end
+  
+  rule String
+    '"' ('\\' . / [^"\\] )* '"' {
+     def sload
+#pp "TV:",text_value
+       text_value[1..-2].gsub("\\n","\n").gsub("\\\"","\"").gsub("\\\\","\\")
+     end
+   }
+  end
+  rule Fill
+    Whitespaces
+  end
+  rule Whitespaces
+    Whitespace*
+  end
+  rule Whitespace
+    ' ' / "\n" / "\t"
+  end
+  rule Array
+    '[' Fill ']' {
+      def sload
+        []
+      end
+    }
+    / 
+    '[' e:ElementList ']' { 
+      def sload
+        e.sload
+      end 
+     }
+  end
+  rule ElementList
+    e:Element mein_rest:(',' el:Element)* {
+     def sload
+       [e.sload]+mein_rest.elements.map{|x|x.el.sload}
+     end
+    }
+  end
+  
+  rule StructName
+    [A-Z] [A-Za-z0-9_:]*
+  end
+  
+  rule Any
+    .*
+  end
+  
+  rule Struct
+    '(' name:StructName Whitespace l:HashList ')' { 
+      def sload
+          klass=getClass(name.text_value)
+          mo=nil
+          hash=l.sload
+          if klass==Time
+            mo=Time.parse(hash[:data])
+          else
+              mo=klass.new
+              hash.each{|k,v|
+                k=k.to_s
+                mo.send(k+"=",v) if mo.members.member?(k) and mo.respond_to?(k+"=")
+              }
+          end
+          mo
+        
+      end
+    }
+  end
+
+end

data/lib/appswarm/spec/application_spec.rb

@@ -0,0 +1,50 @@
+require 'application.rb'
+
+describe "Application" do
+  it "should define an API based upon the 'api'-function" do
+    class MyApp<Application
+      def myFunc
+      end
+      def a(x,y)
+        x+y
+      end
+      
+      api :myFunc,:a
+    end
+    
+    app=MyApp.new(nil,{})
+    lambda {app.api(:myFunc)}.should_not raise_error(AccessViolationException)
+    lambda {app.api(:a,3,4)}.should_not raise_error(AccessViolationException)
+    app.api(:a,5,7).should == 12
+    lambda {app.api(:myFunc2)}.should raise_error(AccessViolationException)
+  end
+    
+  
+  it "APIs should not collide" do
+    class A<Application
+      def a(x,y)
+        x+y
+      end
+      api :a
+    end
+      
+    
+    class B<Application
+      def b(x,y)
+        x-y
+      end
+      api :b
+    end
+    a=A.new(nil,{})
+    b=B.new(nil,{})
+      
+    lambda {a.api(:a,3,4)}.should_not raise_error(AccessViolationException)
+    lambda {a.api(:b,3,4)}.should raise_error(AccessViolationException)
+    a.api(:a,3,4).should == 7
+    lambda {b.api(:a,3,4)}.should raise_error(AccessViolationException)
+    lambda {b.api(:b,3,4)}.should_not raise_error(AccessViolationException)
+    b.api(:b,3,4).should == -1
+
+  end
+
+end

data/lib/appswarm/spec/cluster_spec.rb

@@ -0,0 +1,2 @@
+describe "Cluster" do
+  it "should only export GlobalServices within cluster.getGlobalServices"

data/lib/appswarm/spec/hexdist_spec.rb

@@ -0,0 +1,13 @@
+require 'ubygems'
+require 'crypt.rb'
+
+describe "Computing Hex-Dist" do
+  it "should work on hashes" do
+    a=Crypt::digest("asdf1")
+    b=Crypt::digest("asdf2")
+    c=Crypt::digest("asdf3")
+    pp a,b,hexDist(a,b)
+    pp a,c,hexDist(a,c)
+    
+  end
+end

data/lib/appswarm/spec/http_controller_spec.rb

@@ -0,0 +1,18 @@
+
+require 'http/http_app.rb'
+
+describe "HttpController loading" do
+  it "should desc" do
+    b=TestBed.new
+    b.run("Admin")
+
+    pp 1
+    getClass("AdminApp").should_not be_nil
+    pp 2
+    getClass("Admin").should be_nil
+    pp 3
+    getClass("AdminApp::Admin").should_not be_nil
+    pp 4
+  end
+end
+

data/lib/appswarm/spec/main_spec.rb

@@ -0,0 +1,6 @@
+describe "Main program" do
+  it "should startup with limited set of applications only"
+  it "should load configured programs in the set state"
+  it "should provide a simple way to stop the cluster"
+  it "should open a browser when starting up"
+end

data/lib/appswarm/spec/parallel_each_spec.rb

@@ -0,0 +1,30 @@
+require 'parallel_each.rb'
+require 'pp'
+
+describe "Parallelizing each/map" do
+  it_should_behave_like "AppSwarm Test"
+  it "should work at all" do
+    Thread.list.select{|t|t.alive?}.length.should == 1
+    ma=[]
+    mutex=Mutex.new
+    a=(0..10).to_a
+    a.p_each{|x|sleep rand(0.3); puts x;
+      mutex.synchronize {
+        ma<<x 
+      }
+    }
+    while ma.length<a.length
+      sleep 0.1
+    end
+    ma.sort.should == a
+    Thread.list.select{|t|t.alive?}.length.should == 1
+  end
+  it "should work for adding 1 in map" do
+    a=(0..10).to_a
+    a.p_map do |x|
+      sleep rand(0.2)
+      x+1
+    end.should == a.map{|x|x+1}
+    Thread.list.select{|t|t.alive?}.length.should == 1
+  end
+end

data/lib/appswarm/spec/secure_connection_spec.rb

@@ -0,0 +1,108 @@
+require 'secure_marshal.rb'
+require 'secure_con.rb'
+
+describe "secure connection" do
+  it "should be possible to setup a server and take it down" do
+    s=Secure::Server.new(7777)
+    s.stop
+  end
+  
+  it "should be possible to connect a server" do
+    s=Secure::Server.new(7777)
+    o=Secure::Server.new(7778)
+    c=o.connect("127.0.0.1",7777)
+    pp "C:#{c}"
+    while s.connections.length<1
+      sleep 0.01
+    end
+    c2=s.connections[0]
+    c.send(:hi,"MUH")
+    c2.send(:smoerebroed)
+    c.send(:hdfi,["M3fUH",1])
+    c.send(:hdfi,["M3fUH",1])
+    c.send(:hdfi,["M3fUH",1])
+    c2.should be_a_kind_of(Secure::Connection)
+    #c2.disconnect
+    c2.send(:smoerebroed)
+    
+    
+    2.times do
+      sleep  0.1
+    end
+    puts s.messages
+    puts o.messages
+    s.stop
+  end
+end
+if false
+
+describe "Simple server" do
+  class MyException<Exception
+    
+  end 
+  class MyServer<Secure::SimpleServer
+    allow :hi, :ho, :throwing, :echo
+    remote :hi
+    remote_sync :ho, :throwing, :echo
+    
+    def hi
+      $HI=true
+      puts "HI"
+    end
+    def ho
+      "HO"
+    end
+    def echo(s)
+      s
+    end
+    
+    def throwing
+      raise MyException.new
+    end
+  end
+  it "should be possible to call a remote procedure thus" do
+    puts "-----"
+    a=MyServer.new(8888)
+    b=MyServer.new(8889)
+    a.connect("127.0.0.1",8889)
+    a.connections[0].hi
+    sleep 0.5 # give time to let procedure set $HI
+    $HI.should be_true
+    a.stop
+    b.stop
+  end
+  
+  it "should be possible to call a remote function" do
+    a=MyServer.new(8884)
+    b=MyServer.new(8885)
+    a.connect("127.0.0.1",8885)
+    a.connections[0].ho.should == "HO"
+    #pp a.connections,b.connections
+    a.connections.length.should == 1
+    b.connections.length.should == 1
+    a.stop
+    b.stop
+  end
+
+  if false
+  it "should pass exceptions through network" do
+    a=MyServer.new(8883)
+    b=MyServer.new(8882)
+    c=a.connect("127.0.0.1",8882)
+    lambda {c.throwing}.should raise_error(Secure::RemoteException)
+    a.stop
+    b.stop
+  end
+  end
+  
+  it "should be possible to pass any string" do
+    s=(0..255).to_a.map{|i|i.chr}.join("")
+    s=s*2
+    a=MyServer.new(8883)
+    b=MyServer.new(8882)
+    c=a.connect("127.0.0.1",8882)
+    c.echo(s).should == s
+  end
+end
+
+end

data/lib/appswarm/spec/secure_marshal_spec.rb

@@ -0,0 +1,93 @@
+require 'secure_marshal.rb'
+
+describe "secure marshaling", :shared=>true do
+  it "should encode/decode integers" do
+    check(20)
+    check(-30)
+    check(123874)
+    checkAdd(3874,"crap")
+  end
+  
+  it "should en/dec nil/true/false" do
+    check(nil)
+    check(true)
+    check(false)
+  end
+  
+  it "should encode/decode floats" do
+    checkAdd(347374.34,"lsdf")
+  end 
+  
+  it "should encode/decode strings" do
+    checkAdd("HI","lsdf")
+    checkAdd("HI:HI","lsdf")
+    checkAdd("123:HIdff","lsdf:sdfjhd")
+  end
+  
+  it "should decode's:i:3:muh'correctly" do
+    Secure::Marshal::load('s:i:3:muh').should == "muh"
+  end
+  it "should encode/decode arrays" do
+    check([1,2,3,"muh"])
+    check([])
+    check(nil)
+    check([nil])
+  end
+  
+  it "should encode/decode hashes" do
+    check({1=>2,"asd"=>5.6,[1]=>"kjsdf"})
+  end
+  
+  it "should encode symbols" do
+    check(:symbol)
+  end 
+  
+  it "should encode simple structs" do
+    S=Struct.new(:hupe,:bla)
+    s=S.new("123",348)
+    pp "S:",s
+    check(s)
+  end
+
+  it "should support dissected strings" do
+    s="abcdefghijkl"
+    check(s)
+    m=Secure::Marshal::dump(s)
+    pp s,m
+    split=m.length/2
+    a=m[0...split]
+    b=m[split..-1]
+    puts "---1"
+    (a+b).should == m
+    d=Secure::Data.new(a)
+    lambda{Secure::Marshal::load(d)}.should raise_error(Secure::Marshal::OutOfData)
+    Secure::Marshal::load(m).should == s
+    Secure::Marshal::load(a+b).should == s
+  end
+  
+    
+  it "should support any character in strings" do
+    (0..255).each{|i|
+      s=i.to_s+" "+i.chr
+      check(s)
+    }
+
+    s=(0..255).to_a.map{|i|i.chr}.join("")
+    #s=s*2
+    s=s[(s.length/2)..(s.length*17/32)]
+    check(s)
+  end
+
+
+private
+  
+  def checkAdd(input,add)
+    data=Secure::Marshal::dump(input)+add
+    Secure::Marshal::load(data).should == input
+  end
+  
+  def check(input)
+    data=Secure::Marshal::dump(input)
+    Secure::Marshal::load(data).should == input
+  end
+end