appswarm 0.0.1

data/apps/crypto/crypto.rb

@@ -0,0 +1,47 @@
+require 'application.rb'
+require 'crypto_rsa.rb'
+
+class CryptoApp<Application
+  def initialize(cluster,options)
+    super
+    @keys={}
+    @myKey=options[:myKey]
+    @myKey||=:my
+    
+    getMyKey # prefetch (generate)
+  end
+  
+  def getKey(name)
+    @keys[name]||=getKeyInternal(name)
+  end
+  
+  def getMyKey
+    getKey(@myKey)
+  end
+  
+  private
+  def getKeyInternal(name)
+    # FIXME: add a layer inbetween ??
+    name=name.to_s
+    name.gsub!(/[^0-9A-Za-z_]*/,"")
+    return nil if name.length==0
+    filename="pk_#{name}"
+    path=File.join(getAppDataPath,filename)
+    if File.exists?(path)
+      Crypto::Key.new(loadFile(path))
+    elsif File.exists?(path+".pub")
+      Crypto::Key.new(loadFile(path+".pub"))
+    else
+      createKey(name,path)
+    end
+  end
+  def createKey(name,path)
+    k=Crypto.create_keys
+    k=Crypto::Key.new(k.to_s)
+    k.save(path)
+    k
+  end
+  def loadFile(f)
+    File.open(f){|f|f.read}
+  end
+end

data/apps/crypto/crypto_rsa.rb

@@ -0,0 +1,102 @@
+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
+    
+    # saves private key under *filename* and the public key under *filename*.pub 
+    def save(filename)
+      priv=filename
+      pub=filename+".pub"
+      if @key.respond_to?(:public_key)
+        File.open(priv, "w+") { |fp| fp << @key.to_s }
+        File.open(pub,  "w+") { |fp| fp << @key.public_key.to_s }    
+      else
+        File.open(pub, "w+") { |fp| fp << @key.to_s }
+      end
+    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/apps/crypto/spec/crypto_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper.rb'
+
+describe "Crypto" do
+  it "should generate a private/public key pair" do
+    b=TestBed.new
+    c=b.run("Crypto")
+    c.getKey(:my).should be_an_instance_of(Crypto::Key)
+    b.stop
+  end
+end

data/apps/directory_service/directory_service.rb

@@ -0,0 +1,107 @@
+require 'crypt.rb'
+require File.expand_path('../net_application.rb',__FILE__)
+
+class DirectoryServiceApp<NetApplication
+
+  requires :fullNetworkNode
+  provides :directoryService
+  
+  # this must be defined for the whole network in the same manner in order for the directory to work
+  # it defines on how many servers the information will be stored
+  REDUNDANCY=2
+  
+  MAX_HOPS=5
+  
+  def initialize(cluster,options)
+    super
+    
+    @storage={}
+  end
+  def run
+     
+    defApi :lookup, :registerRemote
+    provides :directoryService
+    super
+  end
+  
+  # get the locally stored data
+  def locallyStored
+    @storage
+  end
+  
+  def info
+    locallyStored
+  end
+  
+  # store remote - don't use this function in your programs 
+  def registerRemote(key,value)
+    ns=nodes(key)
+    log "registerRemote #{key} - #{value}"
+    
+    if ns.member?(node.me)
+      @storage[key]=value
+      log "MATCHEESSSS!"
+    else
+      log "NOOOOO"
+      raise "NOOOOOOOOOOOOOOOOOOOO"
+    end
+  end
+  protected :registerRemote
+  
+  def register(key,value)
+    #assert{nodeCount>0}
+    ns=nodes(key)
+    log ns
+    assert{ns.length>0}
+    ns.each{|curNode|
+      log "curNode:#{curNode} #{node.me}"
+      n=node(curNode)
+      log n
+      n.registerRemote(key,value)
+    }
+  end
+  
+  def lookup(key,hops=nil)
+    hops||=0
+    hops+=1
+    
+    return nil if hops>MAX_HOPS
+    return @storage[key].dup if @storage[key]
+    ns=nodes(key)
+    if ns.member?(node.me)
+      @storage[key]
+    else
+      nodes(key).each{|nodeId|
+        result=node(nodeId).lookup(key)
+        return result.dup if result
+      }
+    end
+  end
+  
+  alias :get :lookup
+  alias :set :register
+  
+  private
+  
+  def myHash
+    hash(node.myNodeId)
+  end
+  
+  def nodeCount
+    node.nodeList.length
+  end
+  
+  def nodes(key,count=REDUNDANCY)
+    h=hash(key)
+    log "HASH #{key.inspect} - #{h.inspect}"
+    log node.knownNodes
+    ([node.me]+node.knownNodes).uniq.sort{|a,b|
+      hexDist(h,hash(a))<=>hexDist(h,hash(b))
+    }[0...count]
+  end
+  
+  def hash(pNode)
+    [Crypt::digest(pNode.to_s)].pack("m")
+  end
+end
+

data/apps/directory_service/net_application.rb

@@ -0,0 +1,92 @@
+ServiceId=Struct.new(:name)
+class ServiceId
+  def hash
+    Crypt::digest(@name.to_s)
+  end
+end
+
+class ServiceDescriptor
+  attr_accessor :redundancy, :serviceId
+end
+
+# NetApplication is an application that runs on *every* node and provides some
+# basic functionality like a directory service
+class NetApplication<Application
+  
+  class NotInitialized<Exception
+    
+  end
+  
+  class CouldNotInitialize<Exception
+    
+  end
+  
+  class RemoteNode
+    def initialize(myNode,remoteNode,app)
+      @myNode=myNode
+      @remoteNode=remoteNode
+      @app=app
+      assert{myNode}
+      assert{remoteNode}
+    end
+    def method_missing(*args)
+      @app.log "Trying to call"
+      @app.log "Trying to call #{@remoteNode} #{args.inspect}"
+      result=@myNode.send(@remoteNode,*args).wait
+      @app.log "Trying to called RESULT ",result
+      result
+    end
+  end
+  
+  def initialize(cluster,options)
+    super
+  end
+  
+  def waitForNodeCount(count)
+    while node.nodeList.length<count
+      sleep 1
+    end
+  end
+  
+  def defApi(*array)
+    wait=10
+    wait.times{
+      break if node?
+      sleep 1
+    }
+    raise CouldNotInitialize unless node?
+    #return unless node?
+    this=self
+    log "setting hook #{getAppName}"
+    @service=node.api.hook(getAppName) do |*args|
+    log "PAPI:"
+    log args
+      name=args[0]
+      args=args[1..-1]
+      if array.member?(name)
+        this.send(name,*args)
+      end
+    end
+  end
+  
+  def node?
+    if cluster
+      @node||=getApp(:fullNetworkNode)
+    end
+    @node
+  end
+  
+  def node(nodeId=nil)
+   # log nodeId
+    node?
+    if nodeId.nil?
+      raise NotInitialized.new unless @node
+      return @node
+    end
+    RemoteNode.new(@service,nodeId,self)
+  end
+  
+  def stop
+    @node.removeReceiver(getAppName) if @node
+  end
+end

data/apps/directory_service/spec/directory_service_spec.rb

@@ -0,0 +1,36 @@
+
+describe "ServiceDirectory" do
+  it_should_behave_like "AppSwarm Test"
+
+  it "should register a service" do
+    t=NetworkTestBed.new(10)
+    t.runOnOne("Master")
+    sleepDebug 0.2
+    t.run("UdpNetwork","DirectoryService")
+    loop do
+      incomplete=false
+      t.eachApp(:fullNetworkNode){|app|
+        incomplete=true if app.knownNodes.length<t.length
+      }
+      sleepDebug 2
+      break unless incomplete==true
+    end
+
+
+    pp "REGISTER","_________________________"
+    measureTime {
+      t.first(:directoryService).register(:hello,"HI")
+    }
+    pp "DONE REGISTERING"
+
+    found=false
+    t.eachApp(:directoryService){|app|
+      found=true if app.locallyStored.length > 0
+    }
+    found.should==true
+    t.stop
+
+  end
+  
+
+end

data/apps/directory_service/spec/net_application_spec.rb

@@ -0,0 +1,3 @@
+describe 'NetApplication' do
+  
+end

data/apps/global_application_interface/global_application.rb

@@ -0,0 +1,52 @@
+class GlobalApplication<Application
+  requires :fullNetworkNode
+  requires :directoryService
+  
+  def initialize(cluster,options,name=nil)
+    super(cluster,options)
+    
+    # register
+    @api=[]
+    @name=name
+    @offers=[]
+    
+    
+  end
+  
+  def offer(atName)
+    @offers<<atName
+    getApp(:directoryService).set([:appNodes,atName],[@networkNode.me])
+  end
+  protected :offer
+  
+  def run
+    log "SETTING APPNODES"
+    @networkNode=getApp(:fullNetworkNode)
+    assert { @networkNode }
+    
+    # FIXME: 1) add only and 2) use secure (restricted storage)
+    assert { getApp(:directoryService) }
+    @networkNode.api.hook(:globalApp){|*call|
+      dispatch(call)
+    }
+    offer(@name) if @name
+    super
+  end
+  
+  def dispatch(call)
+    return unless call.is_a?(Array)
+    log "DISPATCH",call,@name,@offers
+    if @offers.member?(call[0])
+      # FIXME: check api
+      log "CALLING #{call[1]} withs params #{((call[2..-1])).inspect}"
+      return self.send(call[1],*call[2])
+    end
+    puts "NO APP FOUND"
+    nil
+  end
+  
+  protected
+  def api(funcName,description,args)
+    
+  end
+end