appswarm 0.0.1

data/Rakefile

@@ -0,0 +1,153 @@
+require 'rubygems'
+require 'hoe'
+require 'spec/rake/spectask'
+require 'rake/rdoctask.rb'
+require File.expand_path('../lib/appswarm/dir_tool.rb',__FILE__)
+
+
+
+
+# -*- ruby -*-
+
+require './lib/appswarm.rb'
+
+Hoe.new('appswarm', Appswarm::VERSION) do |p|
+  p.rubyforge_name = 'appswarm' # if different than lowercase project name
+  p.developer('David Kamphausen', 'david.kamphausen@web.de')
+end
+
+# vim: syntax=Ruby
+
+
+Spec::Rake::SpecTask.new(:spec=>:build) do |t|
+    t.spec_files = FileList['**/spec/*_spec.rb'].map{|f|File.expand_path(f)}.select{|f|not (f=~/disabled/)}
+    t.warning = true
+    t.rcov = false
+    path="spec_output.html"
+    if ENV['CC_BUILD_ARTIFACTS']
+      path=File.join(ENV['CC_BUILD_ARTIFACTS'],path)
+    end
+    t.spec_opts=["-rlib/appswarm/spec_helper.rb --format html:"+File.expand_path(path)]
+#    t.spec_opts=["--format html:"+File.expand_path(path)]
+end
+
+def tt(ttFile)
+  sh "/usr/bin/tt #{ttFile}"
+end
+
+task :build=>:generate do
+  
+end
+
+task :generate do
+  Dir["**/*.tt"].each{|ttFile|
+    tt(ttFile)
+  }
+end
+
+
+namespace :spec do
+  spec_cmd=`which spec`.chomp
+  #spec_cmd+=" -rdebug"
+  task :showall do
+    puts Dir["**/spec/*_spec.rb"].select{|f|not f=~/spec_helper.rb/}.join("\n")
+  end
+  ttFiles=lambda {
+    Dir["**/*.tt"].map{|f|f.gsub(/\.tt/,"_parser.rb")}
+  }
+
+  rule /^spec:/ do |t|
+    arguments = t.name.split(':')
+    
+    file_name = arguments[1]
+    spec_name = arguments[2..-1]
+
+    spec_filename = "#{file_name}_spec.rb"
+    specs = Dir["**/#{spec_filename}"]
+    #pp specs
+    
+    if path = specs.detect { |f| spec_filename == File.basename(f) }
+      run_file_name = path
+    else
+      puts "No specs found for #{t.name.inspect}"
+      exit
+    end
+
+    example = " -e '#{spec_name}'" unless spec_name.empty?
+    opts=""
+    #opts="-rubygems -rdebug"
+    opts="-rlib/appswarm/spec_helper.rb"
+    call="#{spec_cmd} #{opts} #{run_file_name} --format html:spec_output.html --colour #{example}"
+    puts call
+    sh call
+  end
+end
+
+task :create_manifest do
+  PKG_FILES=dir(".") do
+    files "README.txt","Rakefile","main.rb"
+    dirs("apps","lib") do
+      files("**/*")
+    end
+  end
+  File.open("Manifest.txt") do |f|
+    f.puts PKG_FILES
+  end
+end
+
+
+if false
+PKG_VERSION="0.1"
+PKG_FILES=dir(".") do
+  files "README.txt","Rakefile","main.rb"
+  dirs("apps","lib") do
+    files("**/*")
+  end
+end
+
+
+spec = Gem::Specification.new do |s|
+    s.platform = Gem::Platform::RUBY
+    s.summary = "A framework for building global application swarms."
+    s.name = 'appswarm'
+    s.author='David Kamphausen'
+    s.email='david.kamphausen@web.de'
+    s.homepage='http://rubyforge.org/projects/appswarm/'
+    s.version = PKG_VERSION
+    s.requirements << 'treetop' << 'mediacloth'
+    s.require_path = 'lib'
+    s.rubyforge_project='appswarm'
+    #s.autorequire = 'rake'
+    s.files = PKG_FILES
+    s.has_rdoc=true
+    s.description = <<EOF
+  AppSwarm is/will be an application framework for developing distributed
+  applications across a p2p network. It will be possible to develop very
+  different types of services, like database-services, object-brokers,
+  app-services, or name-services.
+EOF
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+end
+
+Rake::RDocTask.new do |rd|
+   rd.main = "README.txt"
+   rd.title="Appswarm"
+   rd.options << "--diagram" << "--image-format" << "png"
+   rd.rdoc_dir="docs/rdoc"
+   a=Dir["**/README.txt"]+Dir["**/*.rb"]
+   a=a.select{|f|not (f=~/_test/ or f=~/spec/)}
+   rd.rdoc_files.include(a)
+end
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.profile = "default"
+end
+
+

data/TODO

@@ -0,0 +1,7 @@
+* put parser-generation into rakefile
+
+* implement configuration of app-instances (as an app, that starts others) - make it loadable/savable
+* add rights management
+* add signatures for packages (=apps)
+* add monitor (cpu, bandwidth, memory, diskspace)
+* add profiler (analyse slow responses within apps)

data/apps/README.txt

@@ -0,0 +1,17 @@
+The directory "app" includes all local applications, that are NOT sandboxed and should thus be pretty strongly checked!!
+
+== Applications
+Every application has its name, that is CamelCasedApp. It's placed in lower-case underscored named directory (camel_cased) and without the App-postfix.
+It's main class is defined within a file, that's named like containing directory.
+
+apps/camel_case/camel_case.rb:
+ class CamelCaseApp<Application
+ end
+
+There are different types of applications:
+* Application (basic class)
+* Service - a local service, that can be addressed by cluster.getApp(:serviceName)
+* PortService (former NetService) - a Service listening on a special port, for external usage
+* GlobalService - a Service, that's run locally but can be accessed by other nodes
+* NetService - a Service, that runs on many nodes (like a directory service)
+* NetApplication - an application that runs distributed on several nodes (like some special application)

data/apps/admin/admin.rb

@@ -0,0 +1,79 @@
+require 'http.rb'
+
+class AdminApp<HTTPApp
+
+  provides :adminApp
+  requires :localWebServer
+
+  AppDef=Struct.new(:klass,:name,:appId)
+
+  def startup
+    log "STARTUP"
+    startConfiguredApps
+    begin
+      getApp(:localWebServer).mount("/admin",createInstance("default")) #self,getControllers[0],"/")
+    rescue
+    end
+
+    super
+  end
+
+  def run
+    provides :admin
+    super
+    
+  end
+
+  def quit
+    saveRunningApps
+    super
+  end
+
+  def instancesFor(provider,appName)
+    if provider.class.ancestors.map{|a|a.to_s}.member?("LocalWebServerApp")
+      [["defaultInstance","/"+appName+"/"]]
+    else
+      []
+    end
+  end
+
+
+  private
+  def startConfiguredApps
+    log "startConfiguredApps"
+    config=retrieveConfig
+    log "config got"
+    capps=config["configuredApps"]
+    apps=capps.content
+    log "APPS to load ",apps
+    apps||=[]
+    apps.each{|appDef|
+      begin
+
+        if cluster.getLocalApplications.select{|app|app.getAppId==appDef.appId}.length==0
+          log "RUN #{appDef.klass}"
+          cluster.run(appDef.klass.gsub(/App$/,''),{:appId=>appDef.appId,:appName=>appDef.name})
+        else
+          log "RUN #{appDef.klass} - is already running"
+        end
+      rescue Object=>e
+        log e,e.backtrace
+      end
+    }
+
+    unless getApp("Home")
+      cluster.run("Home")
+    end
+
+  end
+  
+  def saveRunningApps
+    log "SAVE"
+    config=retrieveConfig
+    apps=cluster.getLocalApplications.map{|app|app}
+    apps=apps.select{|app|!Appswarm::BASIC_APPS.member?(app.class)}
+    as=apps.map{|app|AppDef.new(app.class.to_s,app.getAppName,app.getAppId)}
+    config["configuredApps"]=as
+  end
+
+end

data/apps/admin/controllers/admin.rb

@@ -0,0 +1,81 @@
+class Admin<HTTPController
+  layout :main
+
+  def index
+    @apps=@app.cluster.getLocalApplications
+    @appTypes=@app.cluster.getApplicationTypes
+
+    begin
+      @servers=@app.cluster.getApp(:networkLookup).getServers
+    rescue
+      @servers=[]
+    end
+    @options=@app.cluster.options
+  end
+
+  def settings(req)
+    @apps=@app.cluster.getLocalApplications
+    id=req.path[0]
+    app=@apps.select{|capp|capp.object_id.to_s==id}[0]
+    @appSettings=app.settings
+  end
+
+  def start(req)
+    appType=req.path[0]
+    @app.cluster.runAndWait(appType.gsub(/App$/,""))
+    redirect_to(url(:action=>:index))
+  end
+  def info(req)
+    appName=req.path[0]
+    @infoVar=@app.cluster.getAppByName(appName).info
+  end
+  
+  def shutdown
+    @app.cluster.shutdown
+    redirect_to(url(:action=>:index))
+  end
+  
+  def stop(req)
+    @apps=@app.cluster.getLocalApplications
+    id=req.path[0]
+    app=@apps.select{|capp|capp.object_id.to_s==id}[0]
+    @app.cluster.stopApp(app)
+    redirect_to(url(:action=>:index))
+  end
+  def clone(id)
+    @apps=@app.cluster.getLocalApplications
+    app=@apps.select{|capp|capp.object_id.to_s==id}[0]
+    @app.cluster.cloneApp(app)
+    redirect_to(url(:action=>:index))
+  end
+  
+  def _log
+    logger=@app.getApp(:logger)
+    if logger
+      @loglist=logger.read(10000)
+    end
+    @loglist||=[]
+  end
+
+  def _settings_httpapp_instance
+  end
+  def _settings_string
+  end
+  
+  # dummy
+  
+  def xy
+    render_html "xy"
+  end
+  def blub
+    render_html "xasdy"    
+  end
+  def helloasd
+    "<html><body>MUH asd"+
+    @app.cluster.getLocalApplications.map{|s|s.to_s}.join("<br>").to_h+
+    @app.getService(:permaspace).load("../README.txt").to_h+
+    "</body></html>"
+    
+    redirect_to(url(:action=>:index))
+  end
+end

data/apps/admin/controllers/settings.rb

@@ -0,0 +1,63 @@
+class Settings<HTTPController
+  layout :main
+
+  def index(req)
+    getTargetApp(req)
+  end
+  
+  def _editApp(req)
+    getTargetApp(req)
+    case @targetApp
+    when HTTPApp
+      @instances=@targetApp.instances
+      viewInstead :_http_app
+    else
+      viewInstead :_web_server
+    end
+  end
+
+  def add(req)
+    getTargetApp(req)
+    case @targetApp
+      when HTTPApp
+        instName=params["NewInstanceName"]
+        @targetApp.createInstance(instName) if instName
+    end
+
+    redirect_to(url(:action=>:index,:appId=>@targetApp.object_id))
+  end
+
+  def del(req)
+    getTargetApp(req)
+    case @targetApp
+      when HTTPApp
+        @targetApp.deleteInstance(params["instanceName"])
+      when LocalWebServerApp
+        @targetApp.deleteMount(params["mount"])
+    end
+    redirect_to(url(:action=>:index,:appId=>@targetApp.object_id))
+  end
+
+
+  def addMount(req)
+    getTargetApp(req)
+    httpApp=@app.cluster.getAppByName(params["httpApp"])
+    instance=httpApp.getInstanceByName(params["httpAppInstance"])
+    @targetApp.mount(params["mountPath"],instance)
+    redirect_to(url(:action=>:index,:appId=>@targetApp.object_id))
+  end
+
+private
+  def getTargetApp(req)
+    @apps=@app.cluster.getLocalApplications
+    id=req.path[0]
+    id||=params["appId"]
+    apps=@apps.select{|capp|capp.object_id.to_s==id}
+    app=apps[0]
+
+    if app
+      @appSettings=app.settings
+      @targetApp=app
+    end
+  end
+end

data/apps/admin/controllers/users.rb

@@ -0,0 +1,3 @@
+class Users<HTTPController
+  
+end

data/apps/admin/features/access.feature

@@ -0,0 +1,21 @@
+Feature: Access restriction
+  In order to prevent others from accessing your node,
+  the admin console will only be available through a local-web-server.
+
+  Scenario: Access from local browser through local web server
+    Given a testbed with an "LocalWebServer" application
+    And a "Admin" application in it
+    And the default instance of the "Admin" application is offered on "LocalWebServer" under "/"
+    When the browser accesses the "LocalWebServer" application on "/"
+    Then it is given a valid html page
+
+
+  Scenario: Access from local browser through global web server
+    Given a testbed with a "GlobalWebServer" application
+    And a "Admin" application in it
+    And a "NameService" application in it
+    And a "GlobalWebProxy" application in it
+    When the "default" instance of "Admin" is offered on the "GlobalWebServer" application
+    And the "default" instance of "Admin" is globally mounted on "test.appswarm/my/path"
+    And a client accesses "http://test.appswarm/my/path" through "GlobalWebProxy"
+    Then the access is restricted

data/apps/admin/features/mountLocal.feature

@@ -0,0 +1,12 @@
+Feature: Mounting local web applications
+
+  @mountLocal
+  Scenario:
+    Given a testbed with a "LocalWebServer" application
+    And a "Admin" application in it
+    When a client accesses the "LocalWebServer" application on "/admin"
+    And I click on "Start WikiApp"
+    Then a "Wiki" application is running
+    And the resulting html page contains "WikiApp"
+    When I click on "Settings WikiApp"
+    #And I click on "