appswarm 0.0.1

data/lib/appswarm/cross_spectool.rb

@@ -0,0 +1,153 @@
+
+require 'pp'
+  
+  
+$MY_KERNEL=self
+def kernel
+  $MY_KERNEL
+end
+module Spec
+module Matchers
+class Cross
+  @@called={}
+  @@backtrace={}
+  @@raiseException={}
+  def initialize(target,function,raiseException=false)
+    @target=target
+    @function=function
+    @expected="#{target}.#{function}(.)"
+    @@raiseException[@expected]=raiseException
+  end
+  def matches?(proc)      
+    @proc = proc
+    callName=@expected
+    @@called[callName]=0
+    
+    if @target.is_a?(Class) and @target.singleton_methods.member?(@function.to_s)
+      mclass=@target
+      
+      function=@function
+      oldFunction=@target.method(@function)
+      mclass.define_cmethod(@function) do 
+        Cross.symCall(callName)
+      end
+      
+      @proc.call
+      mclass.define_cmethod(@function,oldFunction)
+      
+      return @@called[callName]>0
+
+    end
+    @callName=callName
+    mclass=@target
+    mclass=@target.class unless @target.is_a?(Class)
+
+    oldFunction=mclass.instance_method(@function)
+    mclass.send(:define_method,@function) do 
+      Cross.symCall(callName) 
+    end
+    @proc.call
+    mclass.send(:define_method,@function,oldFunction)
+    @@called[callName]>0
+  end
+  def failure_message
+    "expected #{@proc.inspect} to call #{@expected}"
+  end
+  def negative_failure_message
+    bt=""
+    bt=@@backtrace[@callName].join("\n") if @@backtrace[@callName] 
+    #printStacktrace
+    "expected #{@proc.inspect} not to call #{@expected} BT:#{bt}"
+  end
+  def Cross.symCall(name)
+    @@called[name]+=1
+    @@backtrace[name]=caller
+    raise "Should never cross this" if @@raiseException[name]
+    nil
+  end
+end
+
+# :call-seq:
+#   should cross()
+def cross(target,function=nil,raiseException=false)
+    if function.nil? and target.is_a?(Symbol)
+      function=target
+      target=kernel
+    end
+
+  Cross.new(target,function,raiseException)
+end
+  
+  
+class Observer
+  #attr_accessor :ok
+  attr_accessor :count
+  def initialize(object,methodName)
+    @methodName=methodName
+    @object=object
+    #@ok=false
+    @count=0
+  end
+  def run
+    method=@object.method(@methodName)
+    this=self
+    object=@object
+    @object.class.send(:define_method,@methodName) {|*s|
+      if self==object
+        #this.ok=true
+        this.count+=1
+        puts "MUH"
+      end
+      method.call(*s)
+    } 
+    yield
+    @object.class.send(:define_method,@methodName,method)
+    #@ok
+    called?
+  end
+  def isNotCalled
+    @count==0
+    # @ok==false
+  end
+  def isCalled
+    @count>0
+    #@ok==true
+  end
+  def called?(count=0,sym=:times)
+    case sym
+      when :times
+        @count>count
+      else
+        raise "Unknown symbol"
+    end
+  end
+end  
+
+def observe(object,method,&block)
+  observer=Observer.new(object,method)
+  
+  observer.run {block.call(observer)}
+  observer
+end
+
+end
+end
+
+if false
+class Object
+  def method_missing(name,*s)
+    alt=name.to_s.gsub(/\?$/,"")
+    puts alt
+    if respond_to?(alt) and alt!=name
+      self.send(alt,*s)
+    elsif respond_to?(alt.camelCase) and alt!=name and alt.camelCase!=alt 
+      self.send(alt.camelCase,*s)
+    else
+      super
+    end
+    
+  end
+end
+
+    
+  end

data/lib/appswarm/crypt.rb

@@ -0,0 +1,10 @@
+require 'rubygems/digest/sha2.rb'
+
+module Crypt
+  def self.digest(input)
+    Digest::SHA2::digest(input.to_s)
+  end
+  def self.hexdigest(input)
+    Digest::SHA2::hexdigest(input.to_s)
+  end
+end

data/lib/appswarm/crypt/crypto.rb

@@ -0,0 +1,90 @@
+require 'openssl' 
+require 'base64'
+
+# Documentation at http://net-ssh.rubyforge.org/api/classes/OpenSSL/PKey/RSA.html
+module Crypto
+  
+  def self.create_keys(priv = "rsa_key", pub = "#{priv}.pub", bits = 1024)
+    private_key = OpenSSL::PKey::RSA.new(bits)
+    File.open(priv, "w+") { |fp| fp << private_key.to_s }
+    File.open(pub,  "w+") { |fp| fp << private_key.public_key.to_s }    
+    private_key
+  end
+ 
+  def self.generate_secret_with_openssl
+    if !File.exist?("/dev/urandom")
+       # OpenSSL transparently seeds the random number generator with
+       # data from /dev/urandom. On platforms where that is not
+       # available, such as Windows, we have to provide OpenSSL with
+       # our own seed. Unfortunately there's no way to provide a
+       # secure seed without OS support, so we'll have to do with
+       # rand() and Time.now.usec().
+       OpenSSL::Random.seed(rand(0).to_s + Time.now.usec.to_s)
+    end
+    data = OpenSSL::BN.rand(2048, -1, false).to_s
+    return Base64.encode64(OpenSSL::Digest::SHA1.digest(data)).chomp
+  end
+  
+  def self.doHmac(secret, payload)
+    key = Base64.decode64(secret)
+    hashmac = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new(key), key, payload)
+    Base64.encode64(hashmac).chomp
+  end
+  
+  def self.doSha1(text)
+    Base64.encode64(OpenSSL::Digest::SHA1.digest(text)).chomp
+  end
+    
+  class Key
+    def initialize(data)
+      #@public = (data =~ /^-----BEGIN (RSA|DSA) PRIVATE KEY-----$/).nil?
+      @public = false
+      @key = OpenSSL::PKey::RSA.new(data)
+      end
+    
+    def self.from_file(filename)
+      self.new File.read( filename )
+      end
+    
+    def encrypt(text)
+      Base64.encode64(@key.send("#{key_type}_encrypt", text))
+    end
+    
+    def sign(text)
+      Base64.encode64(@key.send("sign", OpenSSL::Digest::SHA1.new, text))
+    end
+
+    def sign_other(text)
+      digest = OpenSSL::Digest::SHA1.new(text).to_s
+      encrypt(digest)
+    end
+
+    def sign_other1(text)
+      digest = OpenSSL::Digest::SHA1.new
+      text.each_byte{ |c| digest.update(c.to_s) }
+      digest = digest.hexdigest
+      encrypt(digest)
+    end
+
+    def verify(sig, text)
+      @key.send("verify", OpenSSL::Digest::SHA1.new, Base64.decode64(sig), text)
+    end
+
+    def decrypt(text)
+      @key.send("#{key_type}_decrypt", Base64.decode64(text))
+    end
+    
+    def private?
+      !@public  
+      end
+    
+    def public?
+      @public   
+      end
+    
+    def key_type
+      @public ? :public : :private
+      end
+    end
+    
+end

data/lib/appswarm/crypt/rsa_key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQDiJtGg3LZwMRx9XlS59o8zLIvutLBxhp8KpVz3AogR7QteYlT7
+3S7tzDa/FirSmxeEWySa9ekoVMYbrYfg4SWohcqWfdOnMWvROQlsTm19WCDbyaQE
+bsg0y/o6Q196VSA/4HirIEeaH+5dueKiBm7fW9odVyfuNO9Q3B5h5uTIFwIDAQAB
+AoGALu4fUmJ6+Y03fEy3CGBCFzyHTWHxu51UI8FtKVU9J3spgMynFh0wP+jA86aF
+/G5y0uSXFBEz8UqmUdgQ+nm+dnZAct72vy4AhdCbztZS9/+Tk7zLc2N7OxNSCb+R
+O3WsQSjG7i9aMgwC8IydMlZbwYUGgoRrkuZRsVKjM3WYnwECQQD/v3ENqAv3GXc7
+/hfm4KIM10K0WlE5GmOBL4RlnbdgzcesW75I9K69AmZ4stW/C0DVUqYEaZoBKaj8
+dMf+3YFDAkEA4l/oAlxukHa41naPGAFxiIJ1PHTDy2PBW2kvNct+J/qy1piT4DOS
+HxAr+AsS/QjRG8L1Al2Dc4j5tlDwx+BWnQJBAKUgq9NAfLFIHQd8UVx+D8OwvV4L
+rsPq+PJxhs/BnKSBWXo9Jkiey7A4O4eVGJOopWzXV2Aj+w7jIjwW/wbdaFcCQBov
+l+n2AUAqy5TbYBAZ0qVE2gTlSOTVJD/Lug9R+8TqJhfWzHxJ2uRG/Z8SwN6OT4oT
+kj30zUjnFmO1lzS3ya0CQGA8MTZza+pKiIf2/M0+p2tW0yQ+wzDlFhf0y8MgwvoS
+Mc1AZx7HiPhWV0V64TKA72FvqlLHYRKlppJ/ubxRcZc=
+-----END RSA PRIVATE KEY-----

data/lib/appswarm/crypt/rsa_key.pub

@@ -0,0 +1,5 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIGJAoGBAOIm0aDctnAxHH1eVLn2jzMsi+60sHGGnwqlXPcCiBHtC15iVPvdLu3M
+Nr8WKtKbF4RbJJr16ShUxhuth+DhJaiFypZ906cxa9E5CWxObX1YINvJpARuyDTL
++jpDX3pVID/geKsgR5of7l254qIGbt9b2h1XJ+4071DcHmHm5MgXAgMBAAE=
+-----END RSA PUBLIC KEY-----

data/lib/appswarm/crypt/test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'crypto.rb'
+
+require 'pp'
+
+ok=Crypto.create_keys
+pp ok
+
+k=Crypto::Key.new(ok.to_s)
+
+meinText="ksdfsdfsfsdfsdfsdfsdfsdfh sdhkdf dfuoh dfoudfh dfouh dfoudfh dfoh"
+puts meinText
+sig=k.sign(meinText)
+
+
+pp k.verify(sig,meinText)
+
+pk=Crypto::Key.new(ok.public_key.to_s)
+
+
+pp pk.verify(sig,meinText)
+
+pp pk.respond_to?(:private_key)
+
+#pk.sign(meinText)
+

data/lib/appswarm/dir_tool.rb

@@ -0,0 +1,41 @@
+class MDir
+  def initialize(path)
+    @path=path
+    @files=[]
+    @dirs=[]
+  end
+  def file(f)
+    @files << f
+  end
+  def files(*f)
+    @files += f
+  end
+  def dir(name,&p)
+    dir = MDir.new(name)
+    dir.instance_eval(&p)
+    @dirs << dir
+  end
+  def dirs(*names,&p)
+    names.each{|name|
+      dir=MDir.new(name)
+      dir.instance_eval(&p)
+      @dirs << dir
+    }
+  end
+  def gather(base="")
+    a=[]
+    @files.each{|f|
+      a+=Dir[File.join(@path,f)]
+    }
+    @dirs.each{|dir|
+      a+=dir.gather(@path)
+    }
+    a
+  end
+end
+
+def dir(path,&p)
+  d=MDir.new(path)
+  d.instance_eval(&p)
+  d.gather
+end

data/lib/appswarm/event_api.rb

@@ -0,0 +1,7 @@
+module EventAPI
+  def self.event(name)
+    onName=name[0..0].upper+name[1..-1]
+    pp self
+    exit
+  end
+end

data/lib/appswarm/features_helper.rb

@@ -0,0 +1,44 @@
+require 'pp'
+require 'ftools.rb'
+$: << File.expand_path("../..",__FILE__)
+$: << File.expand_path("..",__FILE__)
+Dir[File.expand_path("../../../apps/*",__FILE__)].each{|d|$: << d if File.directory?(d)}
+
+require 'cluster_funcs.rb'
+require 'tools.rb'
+require 'package.rb'
+
+require 'cross_spectool.rb'
+require 'proxy_testing.rb'
+require 'appswarm.rb'
+
+
+
+
+
+
+# checks if there are still some threads running in between test cases
+def checkThreads(time)
+  if Thread.list.select{|t|t.stacktrace?}.length>1
+    puts "checkThreads may fail"
+    Thread.current.printOthers
+  end
+
+  "#{Thread.list.select{|t|t.alive?}.select{|t|t.stacktrace?}.length} #{time}".should == "1 #{time}"
+  TestBed.testbeds.length.should == 0
+end
+
+class TestLogger
+  @@file=nil
+  def self.log(*x)
+    unless @@file
+      path=File.expand_path('../../test.log',__FILE__)
+      @@file=File.open(path,"w+")
+    end
+    @@file.puts x.inspect
+    @@file.flush
+  end
+end
+
+
+require 'appswarm/test_bed.rb'

data/lib/appswarm/global_service.rb

@@ -0,0 +1,38 @@
+require 'application.rb'
+
+GlobalServiceID=Struct.new(:name,:type,:provides)
+
+class GlobalService<Application
+  
+  def initialize(cluster,options,name)
+    super(cluster,options)
+    @name=name
+    provides(name)
+  end
+  def cronTime
+    @options[:cronTime]||10
+  end
+  
+  def serviceID
+    GlobalServiceID.new(@name,self.class.to_s,providingAPIs)
+  end
+  
+  def run
+    loop do
+      begin
+        cron
+      rescue Object=>e
+        log e
+        log e.backtrace if e.is_a?(Exception)
+      end
+      sleep(cronTime)
+    end
+  end
+  def stop
+    
+  end
+  def cron
+    
+  end
+
+end