appswarm 0.0.1

data/lib/appswarm/http/webrick_logger.rb

@@ -0,0 +1,12 @@
+class WebrickLogger
+  def initialize(app)
+    @app=app
+  end
+  def method_missing(*args)
+    @app.log(args)
+  end
+  def error(*args)
+    @app.log(args.inspect)
+    @app.log(caller.join("\n"))
+  end
+end

data/lib/appswarm/net_service.rb

@@ -0,0 +1,69 @@
+require 'application.rb'
+
+require 'drb/drb'
+
+class NetService<Application
+  include DRbUndumped
+  attr_reader :valid
+  
+  def initialize(cluster,options)
+    super
+    @port=options[:port]
+    @uri="druby://127.0.0.1:#{@port}"
+    @drb=nil
+    @valid=false
+  end
+  def shutdown
+    assert{@valid}
+    log "NetServer Shutting down service #{@uri}"
+    @drb.stop_service if @drb
+    @thread.kill if @thread
+    log "NetServer Shut down service #{@uri}"
+    assert { NetService::checkPort(@port) }
+  end
+  def stop
+    shutdown
+  end
+  def run
+    assert{@drb.nil?}
+    @thread=Thread.new {
+      begin
+        loop do
+         begin
+            this=self
+            log "NetServer starting #{@uri}"
+            @drb=DRb.start_service(@uri,this)
+            log "NetServer started"
+            @valid=true
+            break
+          rescue Errno::EADDRINUSE=>e
+            log "#{self.class} could not be started - port blocked"
+            sleep(20)
+          end
+        end
+      
+        loop do
+          cron
+          sleep(10)
+        end
+      rescue Exception=>e
+        pp e.backtrace
+        #pp caller
+      end
+    } 
+  end
+  
+  def cron
+  end
+  
+  def self.checkPort(port)
+    begin
+      p=TCPServer.new('127.0.0.1',port)
+      p.close
+      return true
+    rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR, Errno::EAFNOSUPPORT,Errno::EADDRINUSE
+      return false
+    end
+  end
+  
+end

data/lib/appswarm/package.rb

@@ -0,0 +1,88 @@
+require 'tools.rb'
+require 'pp'
+
+class Certificate
+  attr_accessor :description
+  attr_accessor :publicKey
+end
+
+class MyCertificate<Certificate
+  attr_accessor :privateKey
+  
+  def initialize
+  end
+end
+
+class Permissions<Hash
+  PERMISSIONS=[:access_net,:access_temp,:run_cron,:run_continously]
+  def initialize
+    super
+    PERMISSIONS.each{|perm|self[perm]=false}
+  end
+end
+
+class Information
+  attr_accessor :author
+  attr_accessor :description
+end
+
+class Package
+  attr_accessor :source
+  attr_reader :permissions
+  attr_accessor :information
+
+  attr_accessor :sign
+end
+
+class Configuration
+  attr_accessor :acceptedCertificates
+  
+  def packagePermitted?(package)
+  end
+end
+
+class NetworkNode
+end
+
+class AbstractNetwork
+  def getNodesProviding(what,many)
+    []
+  end
+end
+
+class OpenNetwork<AbstractNetwork
+end
+
+class CertificateGetter
+end
+
+def applicationDir
+  File.expand_path("../../../apps",__FILE__)
+end
+
+def loadApp(cluster,name)
+  filename=File.join(applicationDir,name,name+".rb")
+  cluster.log "LOADING #{filename}"
+  require filename
+end
+
+
+def loadApps(cluster)
+  allApps=[]
+  Dir[File.join(applicationDir,'*')].each{|dir|
+    if File.directory?(dir)
+      $:<<dir
+      name=File.split(dir)[1]
+      loadApp(cluster,name)
+      app=nil
+      begin
+        app=eval(name.camelCase+"App")
+      rescue
+      end
+      allApps<<app
+    end
+  }
+  allApps.select{|a|a}
+end
+
+

data/lib/appswarm/parallel_each.rb

@@ -0,0 +1,46 @@
+require 'tools.rb'
+
+class Array
+  # run each in parallel (WARNING: creates infinite threads !!!)
+  def p_each(&block)
+    threads=[]
+    self.each{|element|
+      thread = Thread.new(element,block){|element,block|
+        block.call(element)
+      }
+      threads << thread
+    }
+    (threads.uniq-[Thread.current]).each{|t|
+      assert{Thread.current!=t}
+      t.join
+    }
+    threads.each{|t|t.kill!}
+  end
+  
+  # run map in parallel (WARNING: creates infinite threads !!!)
+  def p_map(&block)
+    threads=[]
+    results=[nil]*length
+    mutex=Mutex.new
+    i=0
+    self.each{|element|
+      t=Thread.start(element,block,results,mutex,i){|element,block,results,mutex,mi|
+        j=mi
+        begin
+          res=block.call(element)
+          mutex.synchronize {
+            results[j]=res
+          }
+        rescue Object=>e
+          pp e,e.stacktrace
+        end
+      }
+      threads<<t
+      i+=1
+    }
+    assert{threads.uniq.length==length}
+    threads.each{|t|t.join}
+    assert{results.length==length}
+    results
+  end
+end

data/lib/appswarm/protocols/protocol_dice.rb

@@ -0,0 +1,25 @@
+module Protocol
+  ProtocolInfo=Struct.new(:parties, :pkAlg)
+  
+  class Base
+    def initialize(parties)
+      @otherParties=parties
+    end
+  end
+  
+  class Dice
+    def initialize(parties,maximum)
+      super(parties)
+      @maximum=maximum
+      myValue=(rand*maximum*5).to_i
+    end
+    
+    
+  end
+  
+  
+  def initiateProtocol(type,parties,*args)
+    
+  end
+  
+end

data/lib/appswarm/proxy_testing.rb

@@ -0,0 +1,48 @@
+require 'uri'
+
+def getFromGlobalProxy(proxy,url,post=nil)
+
+  proxy_addr = '127.0.0.1'
+  proxy_port = proxy.port
+  result=nil
+  puts "TRYING PROXY #{proxy_addr} #{proxy_port}"
+  origurl=url.dup
+  url=URI.parse(url)
+   
+  origurl.gsub!(/http:\/\/[^\/]*/,'')
+   
+  Net::HTTP::Proxy(proxy_addr, proxy_port).start(url.host,url.port) {|http|
+    puts "HTTP OPENED"
+    begin
+      #pp url.path.
+      #path=url
+      if post
+        req = Net::HTTP::Post.new(origurl)
+        #     req.basic_auth 'jack', 'pass'
+        #     req.set_form_data({'from'=>'2005-01-01', 'to'=>'2005-03-31'}, ';')
+        pp "POST",post
+        req.set_form_data(post,";")
+        #req.set_form_data({'from'=>'2005-01-01', 'to'=>'2005-03-31'}, ';')
+        pp "POSTREQ",req.body
+        #pp req
+        #result=http.requestpost(req)
+        result=http.request_post(origurl,post.map{|k,v|k+"="+v}.join(";"))
+
+      else
+        result=http.get(origurl)
+      end
+      pp "RESULT:",result,result.body
+    rescue Object=>e
+      pp e,e.backtrace
+    end
+    #     pp "PROXY_RESULT:",result
+    #     pp result.body
+  }
+  result
+end
+
+class String
+  def valid_html?
+    self=~/html/i # FIXME
+  end
+end

data/lib/appswarm/public_api.rb

@@ -0,0 +1,35 @@
+class AccessViolationException<Exception
+end
+
+class PublicAPI
+  def initialize(target)
+    @@api||={}
+    @target=target
+    this=self
+    @target.class_eval{
+      @@_api=this
+      def self.api(*s)
+        @@_api.addAPI(self,*s)
+      end
+      def api(*s)
+        @@_api.api(self,*s)
+      end
+    }
+  end
+  def addAPI(this,*s)
+    @@api[this]||=[]
+    @@api[this]+=s
+  end
+  def api(object,*s)
+    if @@api[object.class].member?(s[0])
+      object.send(*s)
+    else
+      raise AccessViolationException.new      
+    end
+  end
+end
+
+def publicAPI
+  PublicAPI.new(self)
+end
+

data/lib/appswarm/routing/matrix_math.rb

@@ -0,0 +1,57 @@
+require 'linalg'
+
+
+module Linalg
+   class DMatrix
+      #
+      # Pseudo-inverse.
+      #
+      # For matrix +m+, find +x+ which minimizes
+      #   (m*x - DMatrix.identity(m.vsize)).norm
+      #
+      def pseudo_inverse(epsilon = nil)
+         DMatrix.fit(self, DMatrix.identity(vsize))
+      end
+      
+       def middle_row
+         startA=([0]*columns.entries.length)
+         start=DMatrix[startA]
+         
+         rows.entries.inject(start){|old,new|
+           old+new
+         }/rows.entries.length
+       end
+       def middle_col
+         startA=([[0]]*rows.entries.length)
+         start=DMatrix[*startA]
+         
+         columns.entries.inject(start){|old,new|
+           old+new
+         }/columns.entries.length
+       end
+      
+      def covariance
+        m=middle_row
+        colCount=self.columns.entries.length
+        rowCount=self.rows.entries.length
+        r=(0...colCount).to_a.map{|y|
+            (0...colCount).to_a.map{|x|
+              (0...rowCount).inject(0) {|old,c|
+                old+(self[c,y]-m[0,y])*(self[c,x]-m[0,x])
+              }/rowCount
+            }
+        }
+        DMatrix[*r]
+      end
+      
+      def cut(w,h)
+        r=(0...h).to_a.map{|y|
+          (0...w).to_a.map{|x|
+            self[y,x]
+          }
+        }
+        DMatrix[*r]
+      end
+      
+   end
+end

data/lib/appswarm/routing/pca.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+require 'pp'
+
+$:<<".."
+
+require 'tools.rb'
+require 'matrix_math.rb'
+
+
+module PCA
+  class Input
+    def initialize(i=nil)
+      @vecs=[]
+      if i
+        if i.is_a?(Array)
+          i.each{|k|self<<k}
+        end
+      end
+    end
+    def <<(v)
+      assert {v.is_a?(Array)}
+      if @vecs.length==0
+        @vecs<<v
+      else
+        assert {@vecs[0].length == v.length }
+        @vecs<<v
+      end
+    end
+    
+    def trainCount
+      @vecs.length
+    end
+    
+    def featureCount
+      @vecs[0].length
+    end
+    
+    def dmatrix
+      Linalg::DMatrix[*@vecs]
+    end
+  end
+  
+  class Base
+    attr_reader :eigenvalues
+    def initialize(input)
+      assert { input.is_a?(Input) }
+      @input=input
+      
+      computePCA
+      @input=nil
+    end
+    
+    def dimension
+      @base.hsize
+    end
+    
+    def reduce(size)
+      assert{size<=@eigenvalues.length}
+      return if size==@eigenvalues.length
+      @eigenvalues=@eigenvalues[0...size]
+      
+      @base=@base.cut(size,@base.vsize)
+      @baseInv=@base.pseudo_inverse
+    end
+    
+    def compress(v)
+      v=Linalg::DMatrix[v]
+      v2=v-@middle
+      #pp "---",v2,@baseInv,"---"
+      @baseInv*v2.transpose
+      
+      #pp v2
+    end
+    
+    def decompress(v)
+      #pp "---",v,@base,"---"
+      (@base*v).transpose+@middle
+    end
+    
+    def measureErrors(input)
+      errs=input.map{|i|measureSingleError(i)}
+      
+      mean=errs.inject(0){|old,new|
+       # pp "#{old} #{new}"
+        old+new
+      }/input.length
+      [errs.max,errs.min,mean]
+    end
+    
+    def measureSingleError(input)
+      inter=compress(input)
+      output=decompress(inter)
+        pp inter
+      input=Linalg::DMatrix[input]
+      diff=input-output
+      (diff*diff.transpose)[0,0]
+    end
+
+    
+    private
+    def computePCA
+      #return doOrthoPCA if @input.trainCount<@input.FeatureCount
+      
+      dm=@input.dmatrix
+      @middle=dm.middle_row
+      puts "COV..."
+      cov=dm.covariance
+      puts "SVD..."
+      u, s, vt = cov.singular_value_decomposition
+      @eigenvalues=(0...s.vsize).map{|x|s[x,x]}
+      @base=u
+      
+      #sort
+      puts "INV"
+      @baseInv=@base.pseudo_inverse
+      puts "READY"
+    end
+    def sort
+      pp self
+      a=@base.to_a
+      x=
+      (0...a.length).to_a.map{|i|
+        [a[i],@eigenvalues[i]]
+      }
+      y=x.sort{|a,b| a[1]<=>b[1]}.reverse
+      
+      z=y.map{|a|a[0]}
+      #pp x,y,z
+      
+      @base=Linalg::DMatrix[*@base]
+      @eigenvalues.sort!.reverse!
+      pp self
+      exit
+    end
+  end
+  
+  def doOrthoPCA
+
+  trainCount=@input.trainCount
+  featureCount=@input.featureCount
+  
+  #middle=@input.middle
+  d=@input.dmatrix
+  @middle=d.middle_row
+  dt=d.transpose
+  
+  t=d*dt
+  
+  t=t*(1.0/trainCount)
+  
+  eigenValues=eigenVectors=nil
+  t.eigensystem {|_eigenVectors,_eigenValues,img|
+    eigenValues=_eigenValues
+    eigenVectors=_eigenVectors
+  }
+  
+  nvr=dT*eigenVectors
+
+  #Tools::Math::Matrix nvr(trainCount,featureCount);
+
+  #nvr=dT*vr;
+
+
+#  PCAOutput o;
+
+  
+  
+#  for(size_t y=0;y<ev.size();y++)
+#    {
+#      PCAVector v;
+#      double scale;
+
+#      if(ev[y]>0)
+#  scale=sqrt(ev[y]*trainCount);
+#      else
+#  scale=0;
+
+#      if(scale<=0.0f)
+#  scale=0;
+#      else
+#  scale=1.0/scale;
+
+
+#      for(size_t x=0;x<nvr.nrows();x++)
+#  v.push_back(nvr(x,y)*scale);
+#      o.vectors.push_back(v);
+#      o.values.push_back(ev[y]>0?ev[y]:0);
+#    }
+  end
+  
+end
+
+if false
+i=PCA::Input.new
+i<<[1,1,0]
+i<<[0,1,1]
+i<<[0,1,2]
+i<<[9,1,1]
+i<<[0,1,0]
+
+base=PCA::Base.new(i)
+
+#pp base
+
+c=base.compress([5,1,0])
+#pp c
+r=base.decompress(c)
+pp r
+
+    
+end