appswarm 0.0.1

data/apps/local_secure_file_store/spec/local_secure_file_store_spec.rb

@@ -0,0 +1,23 @@
+require 'local_secure_file_store.rb'
+
+describe "Local Secure File Store" do
+  it "should store a file using a specified key" do
+    TestBed::testbeds.should == []
+    bed=TestBed.new
+    store=bed.run("LocalSecureFileStore")
+    me="1234"
+    filename="myfile"
+    content="testcontent"
+    store.store(filename,me,content)
+    
+    fs=store.files(me)
+    fs.should == [filename]
+    
+    store.load(filename,me).should == content
+    
+    
+    bed.stop
+    TestBed::testbeds.should == []
+    
+  end
+end

data/apps/local_tuple_space/local_tuple_space.rb

@@ -0,0 +1,92 @@
+require 'global_service.rb'
+require 'crypt.rb'
+require 'ostruct'
+
+class LocalTupleSpaceApp<GlobalService
+  provides :localTupleSpace
+  MARSHAL=Marshal
+  
+  MAX_LEND_TIME=2
+  
+  Lent=Struct.new(:time, :transaction)
+  
+  def initialize(cluster,options)
+    super(cluster,options,:localTupleSpace)
+    @dataFile=File.open(File.join(getAppDataPath,"data.bin"),"w+")
+    @indexFile=File.open(File.join(getAppDataPath,"index.bin"),"w+")
+    @index={}
+    @lent={}
+    @transactions={}
+    @mutex=Mutex.new
+  end
+  
+  def read(ref)
+    loadInternal(ref)
+  end
+  
+  def lend(ref,timeout=0.3)
+    old=Time.now
+    while Time.now-old<timeout
+      if @lent[ref]
+        @mutex.synchronize do
+          if @lent[ref]
+            if Time.now-@lent[ref].time>MAX_LEND_TIME
+              @transactions.delete(@lent[ref].transaction)
+              @lent.delete(ref)
+            end
+          end  
+        end
+        sleep(timeout/10) 
+      else
+        @mutex.synchronize do
+          unless @lent[ref]
+            thxid=getTransactionID
+            @lent[ref]=Lent.new(Time.now,thxid)
+            @transactions[thxid]=true
+            return loadInternal(ref)
+          end
+        end
+      end
+    end
+    return nil
+  end
+  
+  def store(ref,object)
+    unless @lent.member?(ref)
+      unless @index[ref].nil?
+        raise "object not lent!"
+      end
+    end
+    @mutex.synchronize do
+      storeInternal(ref,object)
+      @lent.delete(ref)
+    end
+    puts "STORED #{ref}:=#{object}"
+    true
+  end
+  
+  private
+  def storeInternal(ref,object)
+    pp "STORING #{ref} #{object}"
+    @index[ref]=MARSHAL.dump(object)
+  end
+  def loadInternal(ref)
+    #pp "GETTING #{ref} #{@index[ref]}"
+    if @index[ref]
+      MARSHAL.load(@index[ref])
+      #@index[ref].dup
+    else
+      nil
+    end
+  end
+  
+  # This function shold be called with synchronized mode only !
+  def getTransactionID
+    begin
+      tx=Crypt::digest(rand)
+    end while @transactions[tx]
+    tx
+  end 
+    
+  
+end

data/apps/local_tuple_space/spec/tuple_space_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper.rb'
+require 'local_tuple_space.rb'
+
+describe "Local Tuple Space" do
+  
  before(:each) do
+    @t=LocalTupleSpaceApp.new(nil,{})
  end
+  
+  it "should not lend twice" do
+    TestBed::testbeds.should == []
+    @t.store(:a,[])
+    a=@t.lend(:a)
+    a<<1  
+    b=@t.lend(:a)
+    a.should_not be_nil  
+    b.should be_nil
+    @t.store(:a,a)
+    b=@t.lend(:a)
+    a<<2
+    b.should_not be_nil
+    @t.store(:a,b)
+    a<<3
+    b.should == [1]
+    TestBed::testbeds.should == []
+
+  end 

data/apps/local_web_server/features/parsing_args.feature

@@ -0,0 +1,18 @@
+Feature: Parsing of paramters
+
+  @parameters
+  Scenario:
+    Given a testbed with a "LocalWebServer" application
+    And a "HelloWorld" application in it
+    And I create a "default" instance on the "HelloWorld" http-application
+    When the "default" instance of "HelloWorld" is offered on path "/" on the "LocalWebServer" application
+    And a client accesses the "LocalWebServer" on "/"
+    And I click on "PostForm"
+    And I enter "Schmuhl%yzt& hupe" into "Text"
+    And click on "Submit"
+    Then the resulting page contains "Schmuhl%yzt& hupe"
+    When a client accesses the "LocalWebServer" on "/"
+    And I click on "GetForm"
+    And I enter "Schmuhl%yzt& hupe" into "Text"
+    And click on "Submit"
+    Then the resulting page contains "Schmuhl%yzt& hupe"

data/apps/local_web_server/local_web_server.rb

@@ -0,0 +1,166 @@
+require 'http/webrick_logger.rb'
+
+require 'lib/settings.rb'
+require 'cgi.rb'
+
+class LocalWebServerSettings<AdminAppSettings
+  data({:path=>String}=>
+      {:instance=>HTTPApp::Instance})
+end
+
+
+class LocalWebServerApp<Service
+  require 'webrick'
+  include WEBrick
+
+  provides :localWebServer
+  provides :webServer
+
+  attr_reader :settings, :mounts
+
+  Mount=Struct.new(:mountPoint,:instance)
+
+  def initialize(cluster,ops)
+    super(cluster,ops,:webServer)
+
+    port=ops[:httpPort]||4000
+    @port=port
+    @s = HTTPServer.new(
+     :Port => port,
+     :DocumentRoot=>File.expand_path("../http/static",__FILE__),
+     :BindAddress=>"127.0.0.1",
+     :Logger=>WebrickLogger.new(self),
+     :AccessLog=>[]
+    )
+    @started=false
+
+    @mutex=Mutex.new
+
+    #@settings=LocalWebServerSettings.new(self)
+    @mounts=[]
+  end
+
+
+  def quit
+    saveMounts
+    super
+  end
+
+  def startup
+    loadMounts
+    super
+  end
+
+
+  def mount(url,instance)
+
+    @mutex.synchronize {
+
+    raise "Url not defined" unless url.is_a?(String)
+    raise "Instance not valid" unless instance.is_a?(HTTPApp::Instance)
+    url="/#{url}" unless url[0..0]=='/'
+
+    @mounts.each{|mnt|
+      if mnt.mountPoint==url
+        if mnt.instance==instance
+          return
+        else
+          raise "URL is already used!"
+        end
+      end
+    }
+    
+    @mounts<<Mount.new(url,instance)
+
+
+    log "MOUNTING #{url} #{instance}"
+    raise "Invalid instance" unless instance and instance.instanceType
+    mount=@s.mount_proc(url){|req,res|
+      begin
+        app=cluster.getApp(instance.instanceType)
+        log "ORIG PATH:",req.path_info
+        log "INSTANCE:",instance
+        args=req.query.dup
+        args.each{|k,v|
+          args[k]= CGI::unescape(v)
+        }
+
+        (req.query_string||'').gsub(/\?/,'').split("&").each{|arg|
+          n,v=arg.split("=")
+          unless args.key?(n)
+            args[n]=v
+          end
+        }
+
+        sessionId=nil
+   #     log "COOKIES:",req.cookies,req.cookies.class
+        req.cookies.each{|cookie|
+          if cookie.name=='_session_id'
+            sessionId=cookie.value
+          end
+        }
+        req.path_info=req.path_info.sub(/^#{url}\//,'')
+        app.handle(req,res,args,sessionId,instance,url)
+        res.header["content-length"]=res.body.length if res.body  # FIX for some webrick bug
+        log "SEEMS ok"
+      rescue Object=>e
+        puts "ERROR:",e
+        log e.backtrace
+      end
+    }
+    }
+    #pp mount,mount.methods.sort
+  end
+
+  def deleteMount(mount)
+    @s.unmount(mount)
+    @mounts.delete_if do |m|
+      m.mountPoint==mount
+    end
+  end
+
+
+
+  def run
+    @thread=Thread.new {
+      trap("INT"){ @s.shutdown }
+      log "Starting Webrick #{@s}"
+      unless @started
+        @started=true
+        begin
+          @s.start
+        rescue WEBrick::HTTPStatus::EOFError=>e
+          log e,e.backtrace
+        rescue WEBrick::HTTPStatus::NotFound=>e
+          log e,e.backtrace
+        end
+      end
+    }
+  end
+  def stop
+    @s.shutdown
+    @thread.kill
+  end
+
+  def url
+    "http://localhost:#{@port}"
+  end
+
+
+  private
+  def saveMounts
+    config=retrieveConfig
+    config["mounts"]=@mounts
+  end
+
+  def loadMounts
+    config=retrieveConfig
+    mounts=config["mounts"].content
+    if mounts.is_a?(Array)
+      mounts.each{|mnt|
+        #@mounts<<mnt
+        mount(mnt.mountPoint,mnt.instance)
+      }
+    end
+  end
+end

data/apps/logger/logger.rb

@@ -0,0 +1,27 @@
+require 'service.rb'
+require 'ostruct.rb'
+
+class LoggerApp<Service
+  
+  Log=Struct.new(:time,:klass,:appname,:what)
+  
+  def initialize(cluster,options)
+    super(cluster,options,:logger)
+    @log=[]
+  end
+  
+  def log(klass,appname,*what)
+    @log<<Log.new(Time.now,klass,appname,what.join("; "))
+  end
+  
+  def read(count=100)
+    return @log[(-count)..-1] if @log.length>count
+    @log
+  end
+
+  def info
+    @log.map{|entry|
+      [entry.time,entry.klass.to_s,entry.appname,entry.what]
+    }
+  end
+end

data/apps/master/master.rb

@@ -0,0 +1,46 @@
+require 'net_service.rb'
+
+
+class MasterApp<NetService
+  MASTER_SERVICE_PORT=9999
+  EXPIRE_SECONDS=180
+  
+  def initialize(cluster,options)
+    options[:port]||=MASTER_SERVICE_PORT
+    super(cluster,options)
+    @clients={}
+    @clMutex=Mutex.new
+  end
+  def clients
+    #log "reading clients #{@clients.length}"
+    @clMutex.synchronize {
+      pp @clients
+      @clients.keys.select{|c|(Time.now-@clients[c])<EXPIRE_SECONDS}
+    }
+  end
+  
+  def info
+    {:clients=>@clients.length}
+  end
+  
+  def register(client)
+    log "#{client} registered"
+    @clMutex.synchronize {
+      @clients[client]=Time.now
+    }
+    # TODO: checkClientExists
+  end
+  
+  def unregister(client)
+    log "#{client} removed"
+    @clMutex.synchronize {
+      @clients.delete(client)
+    }
+    # TODO: check Client wants to leave
+  end
+  
+  def client
+    pp self.class.included_modules
+    pp self.pretty_inspect    
+  end
+end

data/apps/master/spec/master_spec.rb

@@ -0,0 +1,31 @@
+require 'master.rb'
+require 'network_lookup.rb'
+
+describe "Master Server" do
+  it "should timeout clients after <n> seconds" do
+    TestBed::testbeds.should == []
+    m=MasterApp.new(nil,{})
+    m.run
+    sleep 0.3
+    m.valid.should be_true
+    n=NetworkLookupApp.new(nil,{})
+    n.register(:client)
+    m.clients.should == [:client]
+    sleep 1
+    n2=NetworkLookupApp.new(nil,{})
+    n.register(:client2)
+    m.clients.length.should <= 2
+    
+    (m.clients.sort).should == [:client,:client2]
+    class MasterApp
+      EXPIRE_SECONDS=1
+    end
+    m.clients.should == [:client2]
+    sleep 1
+    m.clients.should == []
+    
+    m.stop
+    n.stop
+    n2.stop
+    TestBed::testbeds.should == []
+  end

data/apps/my_spec_spec.rb

@@ -0,0 +1,15 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require 'my_spec'
+
+describe MySpec do
+  before(:each) do
+    @my_spec = MySpec.new
+  end
+
+  it "should desc" do
+    # TODO
+  end
+end
+