appswarm 0.0.1

data/features/step_definitions/appstart_steps.rb

@@ -0,0 +1,28 @@
+After do
+  @testbed.stop if @testbed
+  @testbed.stop! if @testbed
+  @testbed=nil
+end
+
+Given /^an empty "([^\"]*)" directory$/ do |dir|
+  if dir==".appswarm"
+    p=File.join(ENV["HOME"],dir)
+    `rm -rf #{p}`
+  end
+  #pending
+end
+
+Given /^a testbed$/ do
+  @testbed=TestBed.new
+end
+
+When /^the cluster is running$/ do
+  @testbed.runCluster
+  sleep 1
+end
+
+Then /^the appId of "(.*)" is different from the appId of "(.*)"$/ do |app0,app1|
+  app0=testbed.getApp(app0)
+  app1=testbed.getApp(app1)
+  app0.getAppId.should_not == app1.getAppId
+end

data/features/step_definitions/cluster_steps.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+After do
+  if @testbeds
+    @testbeds.p_each{|t|t.stop}
+    @testbeds.p_each{|t|t.stop!}
+    #@testbeds.clear
+  end
+end
+
+
+
+
+
+
+def testbed
+  @testbed || @testbeds[-1]
+end

data/features/step_definitions/testbed_steps.rb

@@ -0,0 +1,64 @@
+
+Before do
+#  TestBed.finishTesting
+end
+
+After do
+  TestBed.finishTesting
+end
+
+Given /^a testbed with an? "([^\"]*)" application$/ do |appName|
+  @testbed=TestBed.new
+  @testbed.run(appName)
+end
+
+Given /^a "([^\"]*)" application in it$/ do |name|
+  @testbed.runAndWait(name)
+end
+
+When /^I store a string "([^\"]*)" for "([^\"]*)" within the "([^\"]*)"$/ do |str, app, store|
+  store=@testbed.getApp(store)
+  app=@testbed.getApp(app)
+  app.should_not be_nil
+  store.config(app)["exampleString"]=str
+end
+
+Then /^the restored string from the "([^\"]*)" for "([^\"]*)" is "([^\"]*)"$/ do |store,app,str|
+  store=@testbed.getApp(store)
+  app=@testbed.getApp(app)
+  store.config(app)["exampleString"].content.should ==str
+end
+
+When /^the testbed is stopped$/ do
+  @testbed.stop
+  @testbed=nil
+end
+
+When /^a new testbed with a "([^\"]*)" application is started$/ do |app|
+  @testbed=TestBed.new
+  @testbed.run(app)
+end
+
+Then /^the restored string from the "([^\"]*)" for "([^\"]*)" is not existing$/ do |store,app|
+  store=@testbed.getApp(store)
+  app=@testbed.getApp(app)
+  app.should_not be_nil
+  store.config(app)["exampleString"].content.should be_nil
+  
+end
+
+When /^the scenario is started$/ do
+  
+end
+
+Then /^the "([^\"]*)" directory should be empty$/ do |dir|
+  #p=
+  Dir[File.join(ENV["HOME"],dir,"*")].should == []
+end
+
+
+
+Then /^a "([^\"]*)" application is running$/ do |appName|
+  testbed.getLocalApplications.map{|a|a.class.to_s.gsub(/App$/,'')}.member?(appName).should be_true
+end
+

data/features/step_definitions/webapp_steps.rb

@@ -0,0 +1,257 @@
+require 'webrat'
+require 'webrat/mechanize'
+
+
+After do
+  @testbed.stop if @testbed
+  @testbed.stop! if @testbed
+  @testbed=nil
+end
+
+Given /^I create a "([^\"]*)" instance on the "([^\"]*)" http\-application$/ do |instance,app|
+  app=@testbed.getApp(app)
+  app.createInstance(instance)
+end
+
+When /^the "([^\"]*)" instance of "([^\"]*)" is offered on path "([^\"]*)" on the "([^\"]*)" application$/ do |instance,webApp,url,server|
+  webApp=@testbed.getApp(webApp)
+  server=@testbed.getApp(server)
+  inst=webApp.getInstanceByName(instance)
+  server.mount(url,inst)
+end
+
+def visit(app,url)
+  app=@testbed.getApp(app)
+  url=app.url+url
+  @webrat=Webrat::MechanizeSession.new
+  begin
+    @webrat.visit(url)
+    #res=@webrat.get(url,nil)
+    @result=@webrat.page
+    @result.should_not be_nil
+    @error=nil
+  rescue WWW::Mechanize::ResponseCodeError=>e
+    @result=nil
+    @error=e
+  rescue Object=>e
+    raise e
+  end
+end
+
+When /^I visit "([^\"]*)" on the "([^\"]*)"$/ do |url, app|
+  visit(app,url)
+end
+
+
+When /^a client accesses the "([^\"]*)" (application )?on "([^\"]*)"$/ do |app,dummy,url|
+  visit(app,url)
+end
+
+
+Then /^the resulting (html )?page contains "([^\"]*)"$/ do |html,str|
+  @result.should be_a_kind_of(WWW::Mechanize::Page)
+  @result.content.should=~/#{str}/
+end
+
+Then /^the resulting html page doesn't contain \/(.*)\/$/ do |pattern|
+  pattern=/#{pattern}/
+  @result.should be_a_kind_of(WWW::Mechanize::Page)
+  @result.content.should_not=~pattern
+end
+
+
+Then /^the resulting (html )?page contains a field "([^\"]*)"$/ do |html,str|
+  @result.body.should be_valid_html
+  str="//input[@name='#{str}']" if str=~/^[a-zA-Z]*$/
+  field=@webrat.field_by_xpath(str)
+  field.should_not be_nil
+end
+
+
+
+Then /^it is given an error$/ do
+  @result.should be_nil
+  @error.should_not be_nil
+end
+
+When /^the "([^\"]*)" instance of "([^\"]*)" is offered on the "([^\"]*)" application$/ do |instance, app, provider|
+  app=@testbed.getApp(app)
+  provider=@testbed.getApp(provider)
+  instance=app.getInstanceByName(instance)
+  provider.offerInstance(instance)
+
+end
+
+When /^the "([^\"]*)" instance of "([^\"]*)" is globally mounted on "([^\"]*)"$/ do |instanceName, webApp, url|
+  webApp=@testbed.getApp(webApp)
+  instance=webApp.getInstanceByName(instanceName)
+  nameService=@testbed.getApp(:nameService)
+  nameService.export(url,instance)
+end
+
+When /^a client accesses "([^\"]*)" through "([^\"]*)"$/ do |url, proxy|
+  proxy=@testbed.getApp(proxy)
+  
+  @webrat=Webrat::MechanizeSession.new
+  @webrat.mechanize.set_proxy("localhost",proxy.port)
+  begin
+    @webrat.visit(url)
+    res=@webrat.get(url,nil)
+    @result=res
+    @error=nil
+  rescue WWW::Mechanize::ResponseCodeError=>e
+    @result=nil
+    @error=e
+  end
+end
+
+
+When /^the browser accesses the "(.*)" application on "(.*)"$/ do |app,url|
+  app=testbed.getApp(app)
+  lws=testbed.getApp("LocalWebServer")
+
+  @wehrat=Webrat::MechanizeSession.new
+  if lws
+    url=lws.url+url
+  else
+    proxy=testbed.getApp("GlobalWebProxy")
+    unless proxy
+      proxy=testbed.run("GlobalWebProxy")
+    end
+    s.mechanize.set_proxy("localhost",proxy.port)
+    url="my.appswarm"
+    ns=testbed.getOrCreate("NameService")
+    ns.export(url,app.defaultInstance)
+    url="http://#{url}"
+      sleep 2
+  end
+    #url=app.url+url
+  begin
+    res=@wehrat.get(url,nil)
+    @result=res
+    @error=nil
+  rescue WWW::Mechanize::ResponseCodeError=>e
+    pp e
+    pp url
+    @result=nil
+    @error=e
+  rescue Object=>e
+    pp e
+  end
+  #pending
+end
+
+Then /^one "([^\"]*)" application should be running$/ do |app|
+  testbed.getApp(app).should_not be_nil
+end
+
+When /^it is restarted$/ do
+  id=testbed.testbedId
+  testbed.log testbed.getLocalApplications
+  testbed.log testbed
+  testbed.log "RESTART - stop"
+  testbed.stop
+  @testbed=TestBed.new({:testbedId=>id})
+  @testbed.log "RESTART - start"
+  @testbed.runCluster
+  @testbed.waitUntilAllUpAndRunning
+  @testbed.log "ALL RUNNING ?"
+end
+
+
+Given /^the default instance of the "([^\"]*)" application is offered on "([^\"]*)" under "([^\"]*)"$/ do |app, ws, url|
+  app=testbed.getApp(app)
+  ws=testbed.getApp(ws)
+  ws.mount(url,app.defaultInstance)
+end
+
+
+When /^I enter (text )?"([^\"]*)" into "([^\"]*)"$/ do |dummy,text, field|
+  @webrat
+  @webrat.fill_in field, :with => text
+end
+
+When /^(I )?click (on)? "([^\"]*)"$/ do |i,on,button|
+  page=@result
+  l=page.links.select{|l|
+    l.text==button}[0]
+  if l
+    begin
+      @webrat.click_link button
+    rescue Object=>e
+      begin
+        @webrat.click_button button
+      rescue Object=>e
+        pp e,e.backtrace
+        raise e
+      end
+    end
+  else
+    clicked=false
+    ["//button[@name='#{button}']","//input[@value='#{button}']","//button[text()='#{button}']"].each{|xpath|
+      field=@webrat.field_by_xpath(xpath)
+      if field
+        field.click
+        clicked=true
+        break
+      end
+    }
+    unless clicked
+      pp page.body
+      raise "Button #{button} not found"
+    end
+  end
+  @result=@webrat.page
+end
+
+Then /it is given a valid html page/ do
+  @result.body.should be_valid_html
+end
+
+Then /it is given nothing/ do
+  @result.should be_nil
+end
+
+
+Then /^the access is restricted$/ do
+  begin
+  @webrat.response_code.should == 403
+  rescue Object=>e
+    pp e,e.backtrace
+    raise e
+  end
+end
+
+Then /^the "([^\"]*)" application has a "([^\"]*)" instance$/ do |appName, instanceName|
+  app=testbed.getApp(appName)
+  app.getInstanceByName(instanceName).should_not be_nil
+end
+
+
+When /^I click on "([^\"]*)" within the "([^\"]*)" form$/ do |buttonName, formName|
+  xpath="//form[@name='#{formName}']/button[text()='#{buttonName}']"
+  field=@webrat.field_by_xpath(xpath)
+  field.click
+  @result=@webrat.page
+end
+
+Then /^the resulting html page doesn't contain "([^\"]*)"$/ do |str|
+  @result.body.should_not =~/#{str}/
+end
+
+Then /^the "([^\"]*)" application has no "([^\"]*)" instance$/ do |appName, instanceName|
+  app=testbed.getApp(appName)
+  app.getInstanceByName(instanceName).should be_nil
+end
+
+
+When /^I select "([^\"]*)" from "([^\"]*)"$/ do |option, select|
+  @webrat.select option, :from => select
+end
+
+Then /^the "([^\"]*)" has "([^\"]*)" mounts$/ do |app, mountCount|
+  app=testbed.getApp(app)
+  app.mounts.length.should == mountCount.to_i
+end
+
+

data/features/support/env.rb

@@ -0,0 +1,7 @@
+require 'spec/expectations'
+require 'cucumber/formatter/unicode'
+require 'pp'
+$:<<File.expand_path('../../../lib',__FILE__)
+$:<<File.expand_path('../../../lib/appswarm',__FILE__)
+
+require 'features_helper.rb'

data/lib/appswarm.rb

@@ -0,0 +1,127 @@
+$:<<File.join(File.expand_path('../appswarm',__FILE__))
+Dir["apps/*"].each{|d|$: << d if File.directory?(d)}
+require 'package.rb'
+require 'optparse'
+require 'cluster_funcs.rb'
+require 'ubygems'
+
+$DEBUGGING=true
+
+class Appswarm
+  VERSION = '0.0.1'
+
+  include ClusterFuncs
+
+  BASIC_APPS=[
+#    "LocalFileStore",
+#    "LocalWebServer",
+    "Admin",
+#    "Permaspace",
+#    "Home"
+  ]
+
+  attr_reader :running, :options, :apps
+
+  def initialize(options={})
+    @apps=[]
+    @allApps=loadApps(self)
+
+    if options[:trace]
+      enableTracing
+    end
+
+    @options=options
+    @appid=0
+    @running=true
+    @stopping=false
+
+    @stopMutex=Mutex.new
+    trap("INT"){ Tracer::enable ; stop }
+  end
+
+  def start
+    @appClasses=@allApps
+
+    BASIC_APPS.each{|appClass|
+      log "STart #{appClass}"
+      run(appClass)
+    }
+    log "All Apps started"
+  end
+
+  def stopApp(app)
+    log "Stopping #{app}"
+    if @apps.member?(app)
+      app.stop
+      @apps.delete(app)
+    end
+  end
+  def cloneApp(app)
+    if @apps.member?(app)
+      Thread.new {
+        log "Starting new app from #{app}"
+        options={:appName=>app.class.to_s+@appid.to_s}
+        inst=app.class.new(self,options)
+        @appid+=1
+        #inst.setAppName(app.getAppName.gsub(/[0-9]*$/,"")+@appid.to_s)
+        #raise 1
+        getApp(:logger).log(self,inst.getAppName)
+        @apps << inst
+        inst.run
+      }
+    end
+  end
+
+  def stop
+    puts "STOPPP"
+    puts @apps.length
+    [:quit,:stop,:stop!].each{|f|
+      puts "Calling #{f}"
+      @apps.p_each{|app|
+
+        if app.respond_to?(f)
+          app.send(f)
+        else
+          puts "#{app} does not support #{f}"
+        end
+
+        }
+      sleep 0.2
+    }
+    #@apps.p_each{|app|app.stop if app.respond_to?(:stop)}
+  end
+  def getApp(type)
+    getApps(type)[0]
+  end
+  def getAppByName(name)
+    @apps.select{|app|app.getAppName==name}[0]
+  end
+
+
+  def log(*s)
+    pp s
+    loggers=getApps(:logger)
+    if loggers.length>0
+      loggers.each{|app|app.log(self,"",*s)}
+    else
+      a=s.inspect.to_s
+      log_direct(caller[0],nil,a)
+    end
+  end
+
+  def getGlobalServices
+    @apps.select{|a|a.is_a?(GlobalService)}.map{|a|a.serviceID}
+  end
+
+
+  def shutdown
+    @running=false
+    stop
+  end
+
+  def appswarmBaseDir
+    File.join(ENV["HOME"],".appswarm")
+  end
+
+end
+