appswarm 0.0.1

data/lib/appswarm/spec/simple_marshal_spec.rb

@@ -0,0 +1,87 @@
+require 'pp'
+require 'simple_marshal.rb'
+require 'lib/appswarm/spec/secure_marshal_spec.rb'
+require 'treetop'
+
+describe "Simple marshaling" do
+  it_should_behave_like "secure marshaling"
+
+
+  it "should be possible to double backslashes" do
+    data="92 \\"
+    x=data.gsub("\\","\\\\\\")
+    pp data,x
+    x.should_not == data
+    x.should == "92 \\\\"
+  end
+
+  it "should map arrays correcty" do
+    a=[1,2,3,"abc",345.45,true,false]
+    s=Simple::Marshal::dump(a)
+    s.should== "[\n  1,\n  2,\n  3,\n  \"abc\",\n  345.45,\n  true,\n  false\n]"
+    #sd
+  end
+  it "should map strings correctly" do
+    Simple::Marshal::dump("abc\"").should =="\"abc\\\"\""
+  end
+  it "should map hashes correctly" do
+    Simple::Marshal::dump({1=>2,3=>4}).should == "{\n  1 => 2,\n  3 => 4\n}"
+  end
+  it "should map structs correctly" do
+    MyStruct=Struct.new(:a,:b)
+    a=MyStruct.new(1,2)
+   ["(MyStruct\n  :a => 1,\n  :b => 2\n)","(MyStruct\n  :b => 2,\n  :a => 1\n)"].should be_member(Simple::Marshal::dump(a))
+  end
+  #if false
+  it "should restore numbers" do
+    check(123)
+    check(123.123)
+    check(-123)
+  end
+
+  it "should restore Time" do
+    a=Time.now
+    d=Simple::Marshal::dump(a)
+    b=Simple::Marshal::load(d)
+    pp "A:",a,b,d,a.class,b.class,a==b,a===b
+    a.to_s.should ==b.to_s
+    #check(Time.now)
+  end
+  
+  it "should ignore newlines" do
+    Simple::Marshal::load("[\n123]").should == [123]
+  end
+  
+  it "should restore arrays" do
+    a=[1,2,3,"abc",345.45,true,false]
+    check(a)
+  end
+
+  it "should parse structs" do
+    MyStruct=Struct.new(:a,:b)
+    a=MyStruct.new(1,2)
+    str=Simple::Marshal::dump(a).gsub("\n","")
+    pp str
+    #str="(MyStruct :a=>:b)"
+    Simple::Marshal::load(str).should == a
+  end
+
+    
+  def check(a)
+    pp "A:",a
+    #0.upto(a.length-1) { |i|
+    #  pp a[i]
+    #}
+    str=Simple::Marshal::dump(a)
+    pp "DUMPED:",str
+    #0.upto(str.length-1) { |i|
+    #  pp str[i]
+    #}
+    #pp a.length,str.length
+    #puts str
+   # str.gsub!("\n","")
+  #  pp str
+    Simple::Marshal::load(str).should == a
+
+  end
+end

data/lib/appswarm/spec/tools_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper.rb'
+require 'tools.rb'
+
+describe "Tools" do
+  describe "- getClass" do
+    it "should not call eval" do
+      lambda{getClass("String")}.should_not cross(:instance_eval)
+    end
+    it "should find the correct class" do
+      getClass("Mutex").should == Mutex
+    end
+  end
+end

data/lib/appswarm/spec/whiteboard_spec.rb

@@ -0,0 +1,20 @@
+require 'whiteboard.rb'
+
+describe "Whiteboard" do
+  it "should work at all" do
+    w=Whiteboard.new
+    
+    t=Thread.new(w){|x|
+    begin
+      puts "A: #{w.get(:a).inspect}"
+      w.put(:b,2)
+      rescue Object=>e
+      pp e
+      end
+    }
+    sleep(0.1)
+    w.put(:a,1)
+    pp w.get(:b)
+    t.join
+  end
+end

data/lib/appswarm/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'spec/expectations'
+require 'spec/example'
+require 'spec/dsl'
+require 'spec'
+
+require File.expand_path('../features_helper.rb',__FILE__)
+
+share_examples_for "AppSwarm Test" do
+  before(:each) do
+    (Thread.list-[Thread.main]).each{|t|t.kill!}
+    checkThreads("before")
+  end
+  
+  after(:each) do
+    checkThreads("after")
+  end
+end
+

data/lib/appswarm/test_bed.rb

@@ -0,0 +1,207 @@
+class TestBed
+  include ClusterFuncs
+
+  attr_reader :apps,:options,:testbedId
+
+  def initialize(ops={})
+    @@testbeds||=[]
+
+    @@testbeds<<self
+    @appClasses=loadApps(self)
+    @apps=[]
+    @options={:cronTime=>100000}
+    @tbedThreads={}
+    ops.each{|k,v|@options[k]=v}
+    @stopped=false
+    @stopping=false
+    @stopMutex=Mutex.new
+
+    @testbedId=ops[:testbedId]
+
+    @testbedId||=Crypt::hexdigest(rand.to_s)
+
+    trap("INT"){ stop! }
+  end
+
+  def appswarmBaseDir
+    File.join(ENV["HOME"],".appswarm")
+  end
+
+
+  def runCluster
+    Appswarm::BASIC_APPS.each{|app|run(app,{})}
+  end
+
+  def log(*s)
+    TestLogger::log(*s)
+  end
+
+  def log_line(line)
+    TestLogger::log(line)
+  end
+
+  def getThread(app)
+    @tbedThreads[app.object_id]
+  end
+
+  def getApp(type)
+    getApps(type)[0]
+  end
+  def getAppByName(name)
+    @apps.select{|app|app.getAppName==name}[0]
+  end
+
+  def closeApp(app)
+    if @apps.member?(app)
+      app.stop
+      @apps.delete(app)
+    end
+  end
+  def getGlobalServices
+    @apps.select{|a|a.is_a?(GlobalService)}.map{|a|a.serviceID}
+  end
+
+  def stop!
+    stop
+    killOtherThreads!
+  end
+  def stop
+    @stopping=true
+    @stopMutex.synchronize {
+      @apps.p_each{|app|
+        log "APP: #{app}"
+        app.quit
+      }
+      log "QUITED"
+      @apps.each{|app|
+        log "Stopping #{app}"
+        begin
+          measureTime {
+            app.stop
+          }
+        rescue Object=>e
+          log"Failed to stop #{app} with error #{e}"
+          log e.backtrace
+        end
+        log "Stopped #{app}"
+      }
+      log "Waiting to shut down"
+      tries=10
+      while tries>0 and @tbedThreads.select{|k,t|t.alive?}.length>0
+        sleep 0.2
+        tries-=1
+      end
+
+      log "Joining threads of #{self}"
+      @tbedThreads.each{|k,v|
+        log v.stacktrace
+      }
+
+      @tbedThreads.each{|k,v|
+        v.kill if v.alive?
+      }
+      @tbedThreads.each{|k,v|
+        v.kill! if v.alive?
+      }
+      @tbedThreads.each{|k,v|
+        log "CRASH:",v.crashtrace if v.crashtrace?
+      }
+      @@testbeds.delete(self)
+
+
+
+
+      log "Stopped Testbed #{self}"
+      @stopped=true
+    }
+  end
+
+  def appswarmBaseDir
+    File.join(TestBed.appswarmTestingDir,@testbedId)
+  end
+
+  def self.appswarmTestingDir
+    File.join(ENV["HOME"],".appswarm_testing")
+  end
+
+  def self.testbeds
+    @@testbeds||=[]
+  end
+
+  def self.finishTesting
+    Dir.rmdir_f(appswarmTestingDir)
+  end
+
+end
+
+
+FRAG=0.1
+def sleepDebug(time)
+  t=0
+  while t<time
+    puts "Waiting in #{caller[0]} #{t} of #{time}"
+    sleep FRAG
+    t+=FRAG
+  end
+end
+
+
+def killOtherThreads!
+  # kill eveything that's aroudn
+  if Thread.list.length>1
+    (Thread.list-[Thread.current]).select{|x|x.alive?}.each{|t|
+      log "KILLING #{t} #{t.stacktrace}"
+      t.kill!
+      log "KILLED #{t} #{t.crashtrace}"
+
+    }
+  end
+end
+
+
+class NetworkTestBed
+  def initialize(count=10)
+    @testbeds=(1..count).to_a.map{|i|TestBed.new}
+  end
+
+  def run(*klasses)
+    klasses.each{|klass|
+      @testbeds.p_each{|b|b.run(klass)}
+    }
+  end
+
+  def runOnOne(*klasses)
+    klasses.each{|klass|
+      @testbeds[0].run(klass)
+    }
+  end
+
+  def length
+    @testbeds.length
+  end
+
+  def app(appName,i)
+    @testbeds[i].getApp(appName)
+  end
+
+  def log(*x)
+    pp x
+  end
+
+
+  def eachApp(appName,&block)
+    @testbeds.each{|b|block.call(b.getApp(appName))}
+  end
+  def p_eachApp(appName,&block)
+    @testbeds.p_each{|b|block.call(b.getApp(appName))}
+  end
+
+  def first(appName)
+    @testbeds[0].getApp(appName)
+  end
+  def stop
+    @testbeds.p_each{|b|b.stop}
+
+    killOtherThreads!
+  end
+end

data/lib/appswarm/tools.rb

@@ -0,0 +1,284 @@
+require 'thread'
+require 'ftools'
+
+require 'parallel_each.rb'
+require 'tools/thread_tool.rb'
+
+def asBaseDir
+  File.expand_path('../..',__FILE__)
+end
+
+class File
+  def self.load(filename)
+    return nil unless File.file?(filename)
+    File.open(filename) {|f|f.read}
+  end
+end
+
+class Class
+  def deprecated(*funcs)
+    #puts "WARNING: #{funcs} are deprecated!!!"
+  end
+end
+
+class Dir
+  def self.mkdir_save(*args)
+      return if File.directory?(*args)
+    begin
+      self.mkdir(*args)
+    rescue Object=>e
+      d=*args
+      p=File.split(d)[0]
+      self.mkdir_save(p) if p!=d
+      self.mkdir(*args)
+    end
+  end
+
+  def self.rmdir_f(dir)
+    if File.directory?(dir)
+      files=Dir[File.join(dir,"*")]
+      files.each{|f|rmdir_f(f)}
+      Dir.delete(dir)
+    elsif File.file?(dir)
+      File.delete(dir)
+    end
+  end
+end
+
+class String
+  # convert lowercase underscored strings to camelcase
+  def camelCase
+    return self if length<2
+    (self[0..0].upcase+self[1..-1]).gsub(/(_.)/){|s|s[1..-1].upcase}
+  end
+
+  def underscored
+    (self[0..0].downcase+self[1..-1]).gsub(/([A-Z])/){|s|"_"+s.downcase}
+  end
+  
+  # convert camelcase to lowercase underscored
+  def dirName
+    underscored
+  end
+  
+  # convvert (some) html-entities
+  def to_hents
+    self.gsub("&","&amp;").gsub("<","&lt;").gsub(">","&gt;")
+  end
+  
+  # convert plaintext to html (entities and newlines)
+  def to_h
+    self.to_hents.gsub("\n","<br>\n")
+  end
+
+  def to_base64
+    [self].pack("m")
+  end
+end
+
+class AssertionFailed<Exception
+  
+end
+
+def assert(&b)
+  unless b.call
+    dcaller=caller[0]
+    file,line,func=dcaller.split(":")
+    content=assertReadLine(file,line.to_i)
+    s="Assertion failed #{content} in #{file}:#{line}"
+    body=caller.join("\n")
+    glog(s+"\n"+body)
+    puts s
+    raise AssertionFailed.new   
+  end
+end
+
+
+def assertReadLine(file,line)
+  f=File.open(file,"r")
+  all=f.read
+  lines=all.split("\n")
+  l=lines[line-1]
+  f.close
+  l
+end
+
+class Array
+  
+  class Groups<Hash
+    def max_by_value(&block)
+      r={}
+      each{|k,vs|
+        value=nil
+        vs.each{|e|
+          curValue=block.call(e)
+          value||=curValue
+          value=[curValue,value].max
+        }
+        r[k]=value
+      }
+      r
+    end
+  end
+  
+  alias :oldUniq :uniq 
+  def uniq(&block)
+    if block.nil?
+      return oldUniq
+    else
+      a=[]
+      ks=[]
+      each{|v|
+        k=block.call(v)
+        unless ks.member?(k)
+          ks<<k
+          a<<v
+        end
+      }
+      a
+    end
+  end
+  
+  def shuffle!
+    sort_by {|a,b|rand}
+  end
+  def shuffle
+    dup.sort_by {|a,b|rand}
+  end
+  def map2hash(&b)
+    h={}
+    each{|e|
+      res=b.call(e)
+      h[e]=res
+    }
+    h
+  end
+  
+  def uniq_count(&b)
+    h={}
+    each{|e|
+      v=b.call(e)
+      h[v]||=0
+      h[v]+=1
+    }
+    h
+  end
+  
+  def group_by(&block)
+    groups=Groups.new
+    
+    each{|e|
+      g=block.call(e)
+      groups[g]||=[]
+      groups[g] << e
+    }
+    groups
+  end
+end
+
+class Hash
+  def map_to_h(&b)
+    h={}
+    self.each{|k,v|
+      h[k]=b.call(k,v)
+    }
+    h
+  end
+  def map_to_a(&b)
+    h=[]
+    self.each{|k,v|
+      h << b.call(k,v)
+    }
+    h
+  end
+  alias :select_to_a :select
+  def select(&b)
+    h={}
+    self.each{|k,v|
+      if b.call(k,v)
+        h[k]=v
+      end
+    }
+    h
+  end
+end
+
+class Symbol
+  def <=>(o)
+    self.to_s<=>o.to_s
+  end
+end
+
+def getClass(name)
+  #pp "TRY GETCLASS #{name}"
+  $CLASS_CACHE||={}
+
+  unless $CLASS_CACHE.key?(name)
+    c=nil
+    begin
+      ObjectSpace.each_object{|o|
+        c=o if o.to_s==name and o.is_a?(Class)
+      }
+    rescue
+      c=instance_eval(name)
+    end
+
+    $CLASS_CACHE[name]=c
+  end
+  $CLASS_CACHE[name]  
+end
+
+class FalseClass
+  # make booleans sortable
+  def <=>(o)
+    case o
+      when FalseClass
+        0
+      when TrueClass
+        1
+      else
+        0
+    end
+  end
+end
+
+
+class TrueClass
+  def <=>(o)
+    case o
+      when FalseClass
+        -1
+      when TrueClass
+        0
+      else
+        0
+    end
+  end
+end
+
+def hexDist(hash1,hash2)
+  assert{hash1.length==hash2.length}
+  dist=0
+  (0...hash1.length).each{|i|
+     current=(hash1[i]^hash2[i])
+     dist*=256
+     dist+=current
+     #r+=c
+  }
+  dist
+  
+end
+
+
+def glog(*s)
+  #puts "GLOBAL LOG #{caller[0]} #{Time.now} "+(s.map{|x|x.to_s}.join("; "))
+end
+
+def measureTime(depth=1,&block)
+  startTime=Time.now
+  r=block.call
+  endTime=Time.now
+  glog caller[0...depth],"TIME:",(endTime-startTime)
+  r
+end
+