appswarm 0.0.1

data/apps/local_file_store/cached_file_store.rb

@@ -0,0 +1,94 @@
+class LocalFileStoreApp
+  class CachedFileStore
+    CACHE_SIZE=30000
+    DEFAULT_WRITE_DELAY=30
+
+    def initialize(store,writeDelay=nil,cacheSize=nil)
+      @writeDelay=writeDelay
+      @writeDelay||=DEFAULT_WRITE_DELAY
+      
+      @cacheSize=cacheSize
+      @cacheSize||=CACHE_SIZE
+      
+      @store=store
+      
+      @dataCache={}
+      @dataAccessTime={}
+      @dataWriteTime={}
+      @lastWrite=nil
+      
+      @mutex=Mutex.new
+    end
+    def []=(name,value)
+      @mutex.synchronize {
+        @dataCache[name]=value
+        @dataAccessTime[name]=Time.now
+        @dataWriteTime[name]=Time.now
+        checkWriteCache
+      }
+    end
+    def [](name)
+      @mutex.synchronize {
+        unless @dataCache.key?(name)
+          @dataCache[name]=@store[name]
+          @dataAccessTime[name]=Time.now
+        end
+        d=@dataCache[name]
+        checkWriteCache
+        d
+      }
+    end
+    
+    def rm(name)
+      @store.rm(name)
+    end
+    
+    def flush
+      @mutex.synchronize {
+        oldDelay=@writeDela
+        @writeDelay=-10000
+        checkWriteCache
+        @writeDelay=oldDelay
+        assert { @dataWriteTime.length==0}
+      }
+    end
+    
+    private
+    def checkWriteCache
+      @dataWriteTime.each{|k,v|
+        if v<Time.now-@writeDelay
+          # write
+          @store[k]=@dataCache[k]
+          @dataWriteTime.delete(k)
+        end
+      }
+      
+      checkHoldCache
+    end
+    
+    def currentCacheSize
+      @dataCache.values.map{|s|s.length}.inject(0){|a,b|a+b}
+    end
+    
+    # should only be called when 
+    def checkHoldCache
+      while currentCacheSize>@cacheSize
+        # remove least recently accessed
+        leastTime=@dataAccessTime.values.min
+        
+        keys=@dataAccessTime.keys.select{|k|@dataAccessTime[k]<=leastTime}
+        keys.each{|key|
+          unless @dataWriteTime.key?(key)
+            removeFromCache(key)
+          end
+        }
+      end
+    end
+    def removeFromCache(key)
+      @dataCache.delete(key)
+      @dataAccessTime.delete(key)
+      @dataWriteTime.delete(key)
+    end
+  end
+end
+

data/apps/local_file_store/features/testbed_handling_of_directories.feature

@@ -0,0 +1,20 @@
+Feature: Testbeds have separate storing directories and thus don't disturb eachothers.
+
+  Scenario: Serial running of testbeds
+    Given a testbed with a "LocalFileStore" application
+    And a "HelloWorld" application in it
+    When I store a string "hi123" for "HelloWorld" within the "LocalFileStore"
+    Then the restored string from the "LocalFileStore" for "HelloWorld" is "hi123"
+    When the testbed is stopped
+    And a new testbed with a "LocalFileStore" application is started
+    And a "HelloWorld" application in it
+    Then the restored string from the "LocalFileStore" for "HelloWorld" is not existing
+    When the testbed is stopped
+  
+  Scenario: Nothing started
+    When the scenario is started
+    Then the ".appswarm_testing" directory should be empty
+
+  Scenario: Parallel running of testbeds
+
+  Scenario: No running of testbeds

data/apps/local_file_store/local_file_store.rb

@@ -0,0 +1,47 @@
+class LocalFileStoreApp<Service
+  requires :permaspace
+  provides :localFileStore
+  
+  def initialize(cluster,ops)
+    super(cluster,ops,:localFileStore)
+    @api={}
+    @cached={}
+    @configs={}
+  end
+  
+  def stop
+    super
+    @cached.each{|k,v|v.flush}
+    @configs.each{|k,v|v.flush}
+  end
+  
+  def config(app)
+    key=[app.class,app.getAppName]
+    unless @configs.key?(key)
+      @configs[key]=AppConfiguration.new(self,key)
+    end
+    c=@configs[key]
+    assert{c}
+    c
+  end
+  
+  def cached(app,instance,time=nil,chacheSize=nil)
+    key=[app,instance]
+    unless @cached[key]
+      @cached[key]=CachedFileStore.new(api(app,instance),time,chacheSize)
+    end
+  end
+  
+  def api(app,instance)
+    key=[app,instance]
+    unless @api[key]
+      @api[key]=AppFileStore.new(self,app,instance)
+    end
+    @api[key]
+  end
+end
+
+require 'app_file_store.rb'
+require 'cached_file_store.rb'
+require 'app_configuration.rb'
+

data/apps/local_file_store/spec/app_configuration_spec.rb

@@ -0,0 +1,30 @@
+require 'application.rb'
+
+describe "App Configuration" do
+  it_should_behave_like "AppSwarm Test"
+  class TestClass<Application
+    
+  end
+  it "should save and restore app configs" do
+    
+    b=TestBed.new
+    fs=b.run("LocalFileStore")
+    test=TestClass.new(b,{})
+    c=fs.config(test)
+    c.reset
+    ns=c[:nameSpace]
+    ns["myName"]="someAddress"
+    b.stop
+    
+    b=TestBed.new(:testbedId=>b.testbedId)
+    fs=b.run("LocalFileStore")
+    sleep 0.4
+    test=TestClass.new(b,{})
+    c=AppConfiguration.config(test)
+    #c=fs.config(test)
+    c.elements.should == {:nameSpace=>{"myName"=>"someAddress"}}
+
+    b.stop
+  end
+  
+end

data/apps/local_file_store/spec/local_file_store_spec.rb

@@ -0,0 +1,54 @@
+describe "Local File Store" do
+  it_should_behave_like "AppSwarm Test"
+  it "should store data permanently" do
+    b=TestBed.new
+    lfs=b.run("LocalFileStore")
+    lfsapi=lfs.api("myApp","myInstance")
+    lfsapi.rm("testFile")
+    lfsapi["testFile"]="testContent"
+    b.stop!
+    checkThreads("inBetween")
+
+    b=TestBed.new(:testbedId=>b.testbedId)
+    lfs=b.run("LocalFileStore")
+    lfsapi=lfs.api("myApp","myInstance")
+    lfsapi["testFile"].should == "testContent"
+    lfsapi.rm("testFile")
+    b.stop!
+    sleep 2
+  end
+  it "should cache data before writing" do
+    b=TestBed.new
+    lfs=b.run("LocalFileStore")
+    lfsapi=lfs.cached("myApp","myInstance")
+    lfsapi.rm("testFile")
+    lfsapi["testFile"]="testContent"
+    lfs.api("myApp","myInstance")["testFile"].should be_nil
+    lfsapi["testFile"].should == "testContent"
+    b.stop!
+    checkThreads("inBetween")
+    b=TestBed.new(:testbedId=>b.testbedId)
+    lfs=b.run("LocalFileStore")
+    lfsapi=lfs.api("myApp","myInstance")
+    lfsapi["testFile"].should == "testContent"
+    b.stop
+    sleep 2
+  end
+  
+  it "should cache data in read cache" do
+    b=TestBed.new
+    lfs=b.run("LocalFileStore")
+    lfsapi=lfs.cached("myApp","myInstance")
+    lfsapi.rm("testFile")
+    lfsapi["testFile"]="testContent"
+    lfs.api("myApp","myInstance")["testFile"].should be_nil
+    lfsapi.flush
+    lfs.api("myApp","myInstance")["testFile"].should == "testContent"
+    lfs.api("myApp","myInstance").rm("testFile")
+    lfs.api("myApp","myInstance")["testFile"].should be_nil
+    lfsapi["testFile"].should == "testContent" # still there
+    b.stop
+  end
+  
+
+end

data/apps/local_object_storage/lib/cell.rb

@@ -0,0 +1,29 @@
+class Cell
+  attr_reader :cellId, :objectId
+  def initialize(app,cellId)
+    @cellId=cellId
+    @app=app
+    @data=nil
+    @objectId=nil
+    tryRead
+  end
+
+  def save(object)
+    @objectId=object.objectId
+    @data=LocalObjectStorage::Marshal::dump(object)
+    saveIntern
+    self
+  end
+
+  def load
+    LocalObjectStorage::Marshal::load(@data,@app)
+  end
+
+  private
+  def saveIntern
+    @app.store[@cellId]=@data
+  end
+  def tryRead
+    @data=@app.store[@cellId]
+  end
+end

data/apps/local_object_storage/lib/cellmgr.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../cell.rb',__FILE__)
+
+class CellMgr
+  def initialize(app)
+    @app=app
+    @cells=[]
+    @cellIds=0
+
+    readCells
+  end
+  def save(object)
+    p=getFreeCell
+    p.save(object)
+    p.cellId
+  end
+
+  def load(cellId)
+    pp "cellID",cellId
+    cell=@cells.select{|p|p.cellId==cellId}[0]
+
+    unless cell
+      pp "CELLID",cellId,@cellIds
+      if cellId<=@cellIds
+        cell=Cell.new(@app,cellId)
+      end
+    end
+    return cell.load if cell
+    raise "Cell with id #{cellId} not found!"
+  end
+
+  def saveIntern(cell)
+    
+  end
+
+  def saveAll
+    
+  end
+
+private
+  def getFreeCell
+    p=Cell.new(@app,getNewCellId)
+    @cells << p
+    p
+  end
+
+  def readCells
+    config=@app.retrieveConfig
+    a=config["los"].content
+
+    @cellIds=a.keys.max if a
+    @cellIds||=0
+  end
+
+  def getNewCellId
+    @cellIds+=1
+  end
+end

data/apps/local_object_storage/lib/index.rb

@@ -0,0 +1,43 @@
+module LocalObjectStorage
+
+  
+  class Index
+    def initialize(store,key)
+      @key=key
+      @store=store
+      @store||={}
+
+      @index={}
+    end
+
+    def [](id)
+      @index[id]
+    end
+    def []=(id,value)
+      @index[id]=value
+    end
+
+    def dump
+      Simple::Marshal::dump(@index)
+    end
+    def load(data)
+      @index=Simple::Marshal::load(data)
+    end
+
+    def deleteValue(id)
+      @index.each{|n,v|
+        if @index[n].is_a?(Array)
+          @index[n].delete(id)
+        else
+          @index.delete(n)
+        end
+      }
+    end
+    def delete(key)
+      @index.delete(key)
+    end
+
+  end
+
+
+end

data/apps/local_object_storage/lib/marshal.rb

@@ -0,0 +1,96 @@
+
+module LocalObjectStorage
+  
+  module Marshal
+  
+    MarshaledObject=Struct.new(:objectId)
+  
+    def self.dump(object)
+
+      vars=getVarsFromObject(object)
+      vars=filterVars(vars)
+
+      a=[object.class.to_s,object.objectId,vars]
+      Simple::Marshal::dump(a)
+    end
+    def self.load(data,store)
+      raise "LocalObjectStorage::load data is nil!" if data.nil?
+      a=Simple::Marshal::load(data)
+      className,objectId,vars=a
+      
+      if objectId.nil?
+        raise "ObjectID is nil"
+      end
+      
+      klass=getClass(className)
+      object=klass.new(store)
+
+# FIXME: unfilter is complex !!!
+
+      vars.each{|name,value|
+        if value.is_a?(MarshaledObject)
+          value=IncompleteObject.new(store,value.objectId,object,name)
+        else
+          value=unfilter(store,object,value,name)
+        end
+
+        object.instance_variable_set(name,value)
+      }
+      object
+    end
+
+    private
+
+    def self.unfilter(store,parent,var,name)
+      return IncompleteObject.new(store,var.objectId,parent,name) if var.is_a?(MarshaledObject)
+      if var.is_a?(Array)
+        a=[]
+        var.each{|v|a<<unfilter(store,a,v,nil)}
+        a
+      elsif var.is_a?(Hash)
+        nvar={}
+        var.each{|k,v|
+          nvar[k]=unfilter(store,nvar,v,k)
+        }
+        nvar
+      else
+        var
+      end
+    end
+
+    def self.filterVars(var)
+      return MarshaledObject.new(var.objectId) if var.is_a?(PersistentObject)
+
+
+      # FIXME: Filter IcompleteObject !!!!
+      return MarshaledObject.new(var.objectId) if var.is_a?(IncompleteObject)
+
+
+      if var.is_a?(Array)
+        var.map{|v|filterVars(v)}
+      elsif var.is_a?(Hash)
+        nvar={}
+
+        # NOTE: Persistent-Objects as keys in hashes are not supported !!!
+        var.each{|k,v|
+          nvar[k]=filterVars(v)
+        }
+        nvar
+      else
+        var
+      end
+    end
+
+
+    def self.getVarsFromObject(object)
+      vars={}
+      object.instance_variables.each{|var|
+        unless object.instance_variable_get(var).is_a?(LocalObjectStorageApp)
+          value=object.instance_variable_get(var)
+          vars[var]=value
+        end
+      }
+      vars
+    end
+  end
+end