appswarm 0.0.1

data/apps/global_application_interface/global_application_interface.rb

@@ -0,0 +1,84 @@
+class GlobalApplicationInterfaceApp<Service
+  provides :globalApp
+
+  class ApplicationNotFoundException<Exception
+    
+  end
+    
+  class Application
+    attr_reader :name, :instance
+    def initialize(name,instance,interface)
+      @interface=interface
+      @name=name
+      @instance=instance
+      
+      @mutex=Mutex.new
+      
+      getApi
+    end
+    
+    def info
+      [name,instance]
+    end
+    
+    def method_missing(name,*args)
+      @interface.callRemote(self,name,args)
+    end
+    
+    private
+    def getApi
+      # FIXME: get api from somewhere
+    end
+  end
+  
+  
+  def initialize(cluster,options)
+    super(cluster,options,:globalApp)
+    
+    @appNodes={}
+    @mutex=Mutex.new
+  end
+    
+  def get(name,instance=nil)
+    Application.new(name,instance,self)
+  end
+  
+  
+  def callRemote(app,funcName,args)
+    serviceName=[app.name,app.instance]
+    nodes=getNodes(serviceName)
+    #pp "SERVICE ",serviceName
+    #pp nodes
+    raise ApplicationNotFoundException.new(app) if nodes.nil? or nodes.length==0
+    # take one node
+    nodes.shuffle!
+    loop do
+      node=nodes.shift
+      
+      begin
+        result=getApp(:fullNetworkNode).api.send(node,:globalApp,app.info,funcName,args)
+        result=result.wait
+        return result
+      #rescue RemoteException=>e
+        # simply take next node
+      end
+    end
+    # FIXME - raise Exception
+  end
+  
+  def getNodes(appName)
+    @mutex.synchronize {
+      return @appNodes[appName].dup if @appNodes[appName]
+    }
+
+    key=[:appNodes,appName]
+    result=getApp(:directoryService).lookup(key)
+    
+    #result=getApp(:directoryService).get(k)
+    
+    #result=@appNodes[appName].dup
+    
+    result
+  end
+  
+end

data/apps/global_application_interface/spec/app_api_spec.rb

@@ -0,0 +1,5 @@
+describe "GLobal Application API" do
+  it "should provide an interface for calling apps from remote" do
+    
+  end
+end

data/apps/global_tuple_space/global_tuple_space.rb

@@ -0,0 +1,27 @@
+require 'service.rb'
+
+class GlobalTupleSpaceApp<Service
+  def initialize(cluster,options)
+    super(cluster,options,:globalTupleSpace)
+  end
+  
+  def put(name,value)
+    
+  end
+  def get(name)
+    
+  end
+  
+  private
+  def allSpaces
+    
+  end
+  
+  def getAllServers
+    master.getAllServers
+  end
+  
+  def master
+    cluster.getApp(:networkLookup).getMaster
+  end
+end

data/apps/global_web_proxy/features/session_handling.feature

@@ -0,0 +1,7 @@
+Feature: Session handling on global web
+
+  Scenario: A user should is identified through browser cookie
+    Given a testbed with a "LocalWebServer" application
+
+  Scenario: The session is signed by the proxy
+  

data/apps/global_web_proxy/global_web_proxy.rb

@@ -0,0 +1,221 @@
+require 'webrick/httpproxy'
+require 'application.rb'
+
+# FIXME: compress this
+
+RequestArgs=Struct.new(:args,:getArgs,:postArgs)
+class RequestArgs
+  alias :orig_init :initialize
+  def initialize(*args)
+    if args.length==0
+      self.args={}
+      self.getArgs=[]
+      self.postArgs=[]
+    else
+      orig_init(*args)
+    end
+  end
+  
+  def addGet(name,value)
+    self.args[name]=value
+    self.getArgs<<[name,value]
+  end
+  def addPost(name,value)
+    self.args[name]=value
+    self.postArgs<<[name,value]
+  end
+end
+
+GlobalWebRequest=Struct.new(:instance,:host,:path,:query_string,:path_info,:query,:args,:sessionId)
+class GlobalWebRequest
+  def initialize(*args)
+    
+    if args.length==2 and args[1].is_a?(WEBrick::HTTPRequest)
+      instance=args[0]
+      req=args[1]
+      
+      
+      #if path
+      #  if path.length>0 and path[-1..-1]!='/' and req.path_info[0..0]!='/'
+      #    path+='/'
+      #  end
+      #else
+      #  path=''
+      #end
+      args=RequestArgs.new
+      if req.query
+        
+        req.query.each{|k,v|
+          if req.request_method=="POST"
+            args.addPost(k,v)
+          else
+            args.addGet(k,v)
+          end
+        }
+      end
+      if req.query_string and req.request_method=="POST"
+        req.query_string.split("&").each{|p|
+          n,v=p.split("=")
+          args.addGet(n,v)
+        }
+      end
+      super(instance,req.host,req.path,req.query_string,req.path_info,req.query,args)
+      
+      
+      #self.path.gsub!(/\/*$/,"")
+    else
+      super
+    end
+    
+  end
+  
+end
+
+class GlobalWebProxyApp<Application
+  requires :nameService
+  requires :globalApp
+  
+  class MProxy< WEBrick::HTTPProxyServer
+    def initialize(port,web,app)
+      @web=web
+      @app=app
+      mbind= "127.0.0.1"
+      mport=port
+      super(:BindAddress => mbind,
+          :Port => mport,
+          :AccessLog=>[],
+          :Logger=>WebrickLogger.new(app)
+      )
+      trap("INT"){ shutdown }
+
+    end
+    def proxy_service(req, res)
+      begin
+        host,path=@web[req.request_uri]
+
+
+        # FIXME !!!!!
+        sessionId=43
+
+        if host
+          result=host.get(req,sessionId)
+          #pp "CRESULT:",result
+          if result
+            ctype=result.content_type
+            text=result.body
+            res.body=text
+
+            #FIXME  header,etc
+
+            if text
+              res.content_length=res.body.length # somehow content-length is set to zero ???
+            end
+          end
+          #pp "RES:",res
+          res["content-type"]=ctype
+          return
+        end
+        begin
+          super
+        rescue Object=>e
+          @app.log e,e.backtrace
+        end
+      rescue Object=>e
+        @app.log e,e.backtrace
+      end
+
+    end
+    
+    def marshalRequest(req,path)
+      mr=GlobalWebRequest.new(req,path)
+      @app.log "MARSHAL:",mr
+      mr
+    end
+    
+  end
+
+  
+  GlobalWebHost=Struct.new(:app,:path,:instance)
+  class GlobalWebHost
+    def method_missing(name,req,sessionId)
+      begin
+      gr=GlobalWebRequest.new(instance,req)
+      gr.sessionId=sessionId
+
+      gr.path=gr.path.gsub(/^#{path}/,'')
+      gr.path_info=gr.path_info.gsub(/^#{path}/,'')
+      gr.instance=instance
+      self.app.send(name,gr)
+      rescue Object=>e
+        pp e
+        pp e.backtrace
+        raise
+      end
+    end
+  end
+  
+  attr_reader :port
+
+  def initialize(cluster,ops)
+    super
+    @port=7890
+  end
+  
+  def run
+    web=self
+    @proxy=MProxy.new(@port,web,self)
+    Thread.new {@proxy.start }
+    super
+  end
+  
+  def stop
+    @proxy.shutdown
+    super
+  end
+  
+  def get(req,res)
+    
+  end
+  
+  def [](uri)
+
+
+    if uri.host=~/\.appswarm/
+
+      cur=""
+      all=[]
+      uri.path.split("/").each{|p|
+        a=(cur+"/"+p).gsub(/^\/\//,'/')
+        cur=cur+"/"+p
+        all<<a
+      }
+      all.reverse!
+      host=uri.host
+      all.each{|path|
+        url=host+path
+
+        ns=getApp(:nameService)
+        serviceAddress=ns.get(url)
+        if serviceAddress
+
+          instance,*xy=serviceAddress
+
+          globalApps=getApp(:globalApp)
+          found=globalApps.get(:global_web,[instance])
+          unless found
+            pp "NOT FOUND:",[:global_web,[instance]]
+          end
+          return nil unless found
+          pa=uri.path.gsub(/^#{path}/,'')
+          ho=GlobalWebHost.new(found,path,instance)
+          
+          return [ho,pa]
+        end
+      }
+      nil
+    else
+      nil
+    end
+  end
+  
+end

data/apps/global_web_proxy/proxy/HTTPProxyServer-Dateien/rdoc-style.css

@@ -0,0 +1,208 @@
+
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+
+/* === Structural elements =================================== */
+
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+
+
+div#index a {
+    margin-left: 0.7em;
+}
+
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+
+
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+
+
+div#fileHeader {
+    background: #057;
+}
+
+div#classHeader {
+    background: #048;
+}
+
+
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+
+
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+
+
+/* === Classes =================================== */
+
+table.header-table {
+    color: white;
+    font-size: small;
+}
+
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+
+
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+
+/* --- Context section classes ----------------------- */
+
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+
+/* --- Source code sections -------------------- */
+
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+
+/* --- Ruby keyword styles --------------------- */
+
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }