appswarm 0.0.1

data/lib/appswarm/README.txt

@@ -0,0 +1,67 @@
+== Gettin started
+First run
+ > rake rdoc
+and get reading 
+
+== What this project is
+* it's a proof-of-concept for a framework for distributed applications 
+
+== What is will/can be
+
+Possible Applications:
+* Wiki (that cannot be shut down)
+* XSLT
+* DB-Server
+* Searchengine
+* DNS
+* Forum
+* computation credits
+* different network-systems (Network gateways: make gnutella available where it can't be reached, e.g. a firewall )
+* appsharer
+* temp-space
+* perma-space
+
+"bittorrent" for applications
+* the faster your pc - the faster your internet
+
+== How Appswarm works
+
+
+== Running the main app
+ > ruby main.rb
+Will start a single appswarm-node with all applications within app/*
+You'll find a simple admin-interface on http://localhost:2000/admin and a *very simplified* blog on http://localhost:2000/blog
+
+== Running a small swarm
+ >ruby nettest.rb --count 4
+This will start a small swarm of nodes on your localhost. You can access them via http on ports 2000 to 2003.
+
+== Running specs
+ >rake spec
+Runs all the specs defined.
+
+ >rake spec:network_node
+Searches for **/spec_network_node.rb and runs it, if it exists
+
+ >rake "spec:network_node:should process routes correctly"
+Will run this example only.
+
+== Plain Overview of current state
+Directories:
+* apps - hold all the applications currently installed
+* data - holds the data of the applications
+* lib - basic classes and functions to be used within applications
+
+== Where appswarm should go
+
+=== Data
+there are several forms of data:
+* 1) data that's used frequently and needed all over the net for basic functionality
+* 2) app-dependent data, that's used strongly by single applications
+* 3) data that's used infrequently and may be very large (mp3,movies, etc)
+
+Then there are different levels of high-availability needed for this data
+
+For these different kinds of data, we need different data-stores:
+* 1) these should be spread as wide as possible over the net, maybe in a built-in directory-service.
+* 2) may be stored in distributed databases (or tuplespaces)

data/lib/appswarm/app_config.rb

@@ -0,0 +1,19 @@
+class AppConfig
+  def initialize()
+  @values={}
+    file=File.open("config.properties","r")
+    file.each_line{|line|
+      line.gsub!(/#.*/,"")
+      k,v=line.split("=")
+      if k and v
+        @values[k]=v
+      end
+    }
+    file.close
+  end
+  
+  def [](name)
+    @values[name]
+  end
+end
+

data/lib/appswarm/application.rb

@@ -0,0 +1,267 @@
+require 'drb/drb'
+require 'public_api.rb'
+
+#
+# application.rb contains the definition of Application
+
+
+# Application is the basic class for all applications and services within appswarm.
+class Application
+  include DRbUndumped
+  publicAPI
+  
+  attr_reader :cluster
+  attr_accessor :running
+  def initialize(cluster,options)
+    @running=false
+    @threads=[]
+    @cluster=cluster
+    @options=options
+    @provides={}
+    @appName=shortName.downcase
+
+    @appId=@options[:appId]
+    @appId||=createAppId
+    if @options[:appName]
+      @appName=@options[:appName]
+    elsif @options[@appName]
+      @appName=@options[@appName]
+    end
+    
+    
+    @quit=false
+    @quitMutex=Mutex.new
+  end
+  
+  def quit?
+    @quit
+  end
+  
+  def quit
+    @quitMutex.synchronize {
+      @quit=true
+    }
+  end
+  
+  def provides?(xy)
+    return true if self.class.providing.member?(xy)
+
+    @provides[xy]
+  end
+  
+  def getService(name)
+    @cluster.getApp(name)
+  end
+
+  def startup
+    
+  end
+  
+  def run
+    
+  end
+  
+  def config
+    
+  end
+
+  def quit
+    
+  end
+  
+  def stop
+    @threads.each{|thread|thread.kill}
+    @threads.each{|thread|
+      log "KILL THREAD #{thread}"
+      thread.kill!
+
+    }
+    @threads=[]
+  end
+  
+  # get a shorter name for the current application.
+  # 
+  def shortName
+    self.class.to_s.gsub(/App$/,"")
+  end
+  
+  # instanceName
+  def getAppName
+    @appName
+  end
+
+  def getAppId
+    @appId
+  end
+  
+  def info
+    {}
+  end
+
+  def appswarmBaseDir
+    cluster.appswarmBaseDir
+  end
+
+  def getAppDataWritePath
+    path=File.join(appswarmBaseDir,getAppName)
+    Dir.mkdir_save(path)
+    path
+  end
+
+  def getAppDataPaths
+    [getAppDataWritePath,getAppDataPath].flatten
+  end
+    
+  def getAppDataPath
+    dir=File.expand_path("../../data/#{self.class.to_s}",__FILE__)
+    
+    unless File.exist?(dir)
+      return []
+    end
+    dir
+  end
+  
+  def withApp(name,&block)
+    app=@cluster.getApp(name)
+    if app
+      app.instance_eval{block.call}
+    end
+  end
+  def withAppFork(name,&block)
+    @threads << Thread.new(name){|name|
+      loop do
+        a=@cluster.getApp(name)
+        if a
+          puts name,a
+          #exit
+          a.instance_eval(&block)
+          break
+        end
+        sleep 5
+      end
+    }
+  end
+  
+  
+  def getAppDir
+    Application.getAppDir(self.class.to_s)
+  end
+  
+  # gets the (absolute) application-directory for the given class(-name)
+  def self.getAppDir(name)
+    File.expand_path("../../../apps/#{name.to_s.gsub(/App$/,'').dirName}",__FILE__)
+  end
+
+  def warning(*x)
+    log "WARNING",*x
+  end
+  
+  # logs any objects to the logger-app or if such does not exist to the console
+  def log(*s)
+    logger=getApp(:logger)
+    if logger
+      #      puts "[#{Time.new}][#{self}][#{place}] "+s.map{|v|v.to_s}.join(" ")
+      logger.log(self.class,getAppName,*s) if logger
+    else
+      place=caller[0]
+      if cluster
+        cluster.log_direct(place,nil,s.to_s)
+      else
+        pp s
+      end
+    end
+  end
+  
+  def getApp(*s)
+    return cluster.getApp(*s) if cluster
+    nil
+  end
+  
+  def monitor(&b)
+    log "start monitor"
+    begin
+      b.call
+    rescue Object=>e
+      log "Monitor error #{e}"
+      log e.to_s+"\n"+e.backtrace.join("\n")
+      #rescue  Error=>e
+      #  log e.toString+"\n"+e.backtrace.join("\n")
+    end
+  end
+  
+  def retrieveConfig
+    app=nil
+    trials=0
+    loop do
+      app=getApp(:localFileStore)
+      if app.nil?
+        cluster.run("LocalFileStore")
+      else
+        break
+      end
+      trials+=1
+      log "First trial failed to get LocalFileStore"
+      if trials>2
+        puts "ERROR:  NO LocalFileStore found!"
+        log "ERROR:  NO LocalFileStore found!"
+        return nil
+      end
+    end 
+    app.config(self)
+  end
+  
+  def providingAPIs
+    @provides.keys
+  end
+  
+  def self.requires(*x)
+    @@requires||={}
+    @@requires[self]||=[]
+    @@requires[self]<<x
+  end
+  def self.requirements
+    @@requires||={}
+    rs=ancestors.map{|a|@@requires[a]}.flatten.select{|x|x}
+
+    #pp "RS",rs
+    return rs
+    a=ancestors[1]
+    if a.ancestors.member?(Application)
+      p=a.requirements
+    else
+      p=[]
+    end
+    
+    ((@@requires[self]||[])+p).flatten
+  end
+  def self.providing
+    @@providings[self]||[]
+  end
+  
+  def self.provides(*x)
+    @@providings||={}
+    @@providings[self]||=[]
+    @@providings[self]+=x
+  end
+  
+  def self.protect(funcName)
+    newName="_"+funcName.to_s
+    self.send(:alias_method,newName,funcName)
+    self.send(:define_method,funcName){|*args|
+      @quitMutex.synchronize {
+        raise "#{self} has quit!" if quit?
+        self.send(newName,*args)
+      }
+    }
+  end
+  
+  protected
+  def provides(xy)
+    @provides[xy]=true  
+  end
+
+  private
+  def createAppId
+    Crypt.digest(Time.now.to_s+rand.to_s).to_base64
+  end
+end

data/lib/appswarm/breaking_mutex.rb

@@ -0,0 +1,41 @@
+#BreakingMutex=Mutex
+class BreakingMutex
+  GRANULARITY=20
+  TRIES=10
+  def initialize(timeout=2)
+    @timeout=timeout
+    #@mutex=Mutex.new
+    @mutex=false
+  end
+  def synchronize(&b)
+    done=false
+    start=Time.now
+    while not done and (Time.now-start)<@timeout
+      puts "enter critical"
+      Thread.critical=true
+        ok=false
+        if @mutex==false
+          @mutex=true
+          ok=true
+        end
+      puts "leaving critical"
+      Thread.critical=false
+        if ok==true
+          puts "running"
+          b.call
+          done=true
+        end
+      if ok==true
+        puts "enter critical"
+        Thread.critical=true
+          @mutex=false
+        Thread.critical=false
+        puts "leaving critical"
+      end
+      time=(@timeout/TRIES.to_f)*rand(GRANULARITY)/GRANULARITY.to_f
+      puts "SLEEP #{time}"
+      sleep time unless done
+    end
+    puts "DONE"
+  end
+end

data/lib/appswarm/cluster_funcs.rb

@@ -0,0 +1,157 @@
+module ClusterFuncs
+
+  def getNewInstanceName(klass)
+    @instanceId||=0
+    @instanceId+=1
+    klass.to_s+@instanceId.to_s
+  end
+  def checkRequirements(appClass)
+    reqs=appClass.requirements
+    reqs.each{|req|
+      if getApp(req).nil?
+        f=@appClasses.select{|klass|klass.providing.member?(req)}
+        if f.length==0
+          raise "PROBLEM: #{req} not found!"
+        else
+          debug "STARTING REQUIRED #{f[0]}"
+          run(f[0].to_s.gsub(/App$/,""))
+        end
+        
+      end
+    }
+  end
+
+  def getLocalApplications
+    @apps
+  end
+  def getApps(type)
+    if type.is_a?(Class)
+      return @apps.select{|app|app.is_a?(type)}
+    end
+
+    if type.is_a?(String)
+      type+="App" unless type=~/App$/
+      return @apps.select{|app|app.class.to_s==type}
+    end
+
+    @apps.select{|app|
+      app.provides?(type)
+    }
+  end
+
+  def getApplicationTypes
+    @appClasses
+  end
+
+  def getOrCreate(appName)
+    a=getApp(appName)
+    a=run(appName) unless a
+    a
+  end
+
+  def allUpAndRunning
+    @apps.select{|a|a.running==false}.length==0
+  end
+
+  def waitUntilAllUpAndRunning
+    while not allUpAndRunning
+      sleep 0.1
+    end
+  end
+
+  def runAndWait(appName,*params)
+    app=run(appName,*params)
+    while app.running==false
+      sleep 0.1
+      log "WAIT for #{app} to startup"
+    end
+  end
+  
+  def run(appName,*params)
+    return nil if @stopping
+    log "Starting #{appName}"
+    appClass=@appClasses.select{|appClass|
+      appName.to_s+"App"==appClass.to_s
+    }[0]
+    raise "Class #{appName} not Found" unless appClass
+    checkRequirements(appClass)
+
+
+    log "NAME:",appName,params
+    a=nil
+
+    @stopMutex.synchronize {
+      return if @stopped
+      if params.is_a?(Array)
+        params=params[0]
+      end
+      if params.is_a?(Hash)
+        return if @apps.select{|app|app.getAppId==params[:appId]}.length>0
+
+        # FIXME: support multiple apps of same type running
+        return if @apps.select{|app|
+          app.class==appClass
+        }.length>0
+      end
+
+      #return if getAppById()
+      log "Running Testbed #{self}"
+      options=@options
+      if params
+      if params.length>0
+        if params[-1].is_a?(Hash)
+          options=params[-1]
+        end
+      end
+      end
+      a=appClass.new(self,options)
+      i=a.object_id
+      y=Thread.new(a) {|a|
+        Thread.current[:appName2]=appName
+        begin
+          @apps<<a
+          log "TRYING TO START #{a}"
+
+          a.startup
+          a.running=true
+          a.run
+          debug "FINISHED #{a}"
+        rescue Exception=>e
+          log e,e.backtrace
+        end
+      }
+      loop  do
+        sleep 0.01
+        break if @apps.member?(a)
+      end
+      y[:appName]=appName
+      @tbedThreads||={}
+      @tbedThreads[i]=y
+      a
+    }
+    a
+  end
+
+  def log_line(line)
+    puts line
+  end
+  def debug(*p)
+    log_direct(caller[0],nil,p.map{|x|x.to_s}.join(" "))
+  end
+  def log_direct(place,instance,what)
+    place.gsub!(/\/.*\//,'/..../')
+    i=""
+    i="[#{instance}]" if instance
+
+    t=Time.new.strftime("%Y-%m-%d %H:%M:%S")
+    what.split("\n").each{|line|
+      log_line "[#{t}][#{place}]#{i} "+line
+    }
+
+  end
+
+  def createInstanceId
+    Crypt::hexdigest(rand.to_s+Time.new.to_s)
+  end
+
+end