appswarm 0.0.1

data/apps/local_object_storage/lib/pagefile.rb

@@ -0,0 +1,6 @@
+class PageFile
+  def initialize(app,name)
+    @app=app
+    @name=name
+  end
+end

data/apps/local_object_storage/lib/persistent_object.rb

@@ -0,0 +1,126 @@
+class PersistentObject
+  attr_reader :objectId,:myStore
+
+  # load PersistentObject, objectId is nil, otherwise create one
+  def initialize(myStore,objectId=nil)
+    @myStore=myStore
+    if objectId
+      loadFromStore(objectId)
+    end
+
+    objectId||=myStore.createObjectId
+    @objectId=objectId
+  end
+
+  def save
+    @myStore.save(self)
+  end
+
+  def ==(other)
+    return false if other.class!=self.class
+    instance_variables.each{|var|
+      o=other.instance_variable_get(var)
+      m=instance_variable_get(var)
+      if m.is_a?(LocalObjectStorage)
+        # ignore
+      elsif m.is_a?(PersistentObject) || m.is_a?(IncompleteObject)
+        return false if m.objectId!=o.objectId
+      else
+        return false if m!=o
+      end
+    }
+    true
+  end
+
+  def delete
+    @myStore.delete(self)
+  end
+
+  def self.getAll(store)
+    pp "GETTING ALL #{self}"
+    store.findByClass(self)
+  end
+
+  def self.getById(store,id)
+    store.findByObjectId(id)
+  end
+
+  def self.findAll(store,&block)
+    store.findByClass(self).select{|element|
+      block.call(element)
+    }
+  end
+
+  private
+  def loadFromStore(objectId)
+    data=@myStore.getData(objectId)
+  end
+end
+
+class IncompleteObject
+  attr_reader :objectId
+  def initialize(myStore,objectId,owner,name)
+    @owner=owner
+    @objectId=objectId
+    @myStore=myStore
+    @name=name
+  end
+  def method_missing(*s)
+    read.send(*s)
+  end
+
+  def read
+    object=@myStore.restore(@objectId)
+    if @owner.is_a?(Hash)
+      @owner[@name]=object
+    elsif @owner.is_a?(Array)
+      @owner.each_index {|i|
+        @owner[i]=object if @owner[i]==self
+      }
+    else
+      @owner.instance_variable_set(@name,object)
+    end
+    object
+  end
+end
+
+
+class Transaction
+  @@transaction={}
+
+  def initialize
+    @modifiedObjects=[]
+    @readObjects=[]
+  end
+
+  def modify(object)
+    @modifiedObjects << object
+  end
+  def read(object)
+    @readObjects << object
+  end
+
+  def finish
+    # FIXME
+    # check readObjects for modifications
+    # if not modified, then save
+    # otherwise through exception
+    @modifiedObjects.uniq.each{|o|o.save}
+  end
+
+  def self.run(&block)
+    @@transaction[Thread.current]||=[]
+    clist=@@transaction[Thread.current]
+    tx=Transaction.new
+    clist<<tx
+    block.call
+    clist.delete(tx)
+    tx.finish
+  end
+end
+
+def transaction(&block)
+  Transaction.run(block)
+end
+
+

data/apps/local_object_storage/local_object_storage.rb

@@ -0,0 +1,148 @@
+require 'service.rb'
+require File.expand_path('../lib/index.rb',__FILE__)
+require File.expand_path('../lib/persistent_object.rb',__FILE__)
+require File.expand_path('../lib/marshal.rb',__FILE__)
+require File.expand_path('../lib/cellmgr.rb',__FILE__)
+
+class LocalObjectStorageApp<Service
+
+  class Store
+    def initialize(app)
+      @app=app
+    end
+    def [](key)
+      config=@app.retrieveConfig
+      config["los"][key].content
+    end
+    def []=(key,value)
+      config=@app.retrieveConfig
+      config["los"][key]=value
+    end
+  end
+
+
+  provides :localObjectStorage
+  requires :localFileStore
+
+  include LocalObjectStorage
+
+  attr_reader :store
+  
+  def initialize(cluster,ops)
+    super(cluster,ops,:localObjectStorage)
+
+    @mgr=CellMgr.new(self)
+    @store=Store.new(self)
+    @indexes={}
+    @maxObjectId=0
+
+    createIndexes
+    readIndexes
+  end
+
+  def outputIndexes
+    #pp @indexes
+    #pp "MGW:",@mgr
+  end
+
+  def findByObjectId(objectId)
+    restore(objectId)
+  end
+
+  def findByClass(klass)
+    findIdByClass(klass).map{|objectId|restore(objectId)}
+  end
+  def findIdByClass(klass)
+    find(:class=>klass.to_s)
+  end
+
+  def createObjectId
+    @maxObjectId+=1
+  end
+  
+  def save(object)
+    cellId=@mgr.save(object)
+
+    @indexes[:objectId][object.objectId]=cellId
+
+    klass=object.class.to_s
+    @indexes[:class][klass]||=[]
+    @indexes[:class][klass] << object.objectId
+    @indexes[:class][klass].uniq!
+  end
+
+  def delete(object)
+    deleteId(object.objectId)
+  end
+
+  def deleteId(objectId)
+    @indexes.each{|name,index|
+      index.deleteValue(objectId) unless name==:objectId
+    }
+    @indexes[:objectId].delete(objectId)
+  end
+
+  def restore(objectId)
+    objectId=objectId.to_i
+    cellId=@indexes[:objectId][objectId]
+    raise "Object #{objectId} not found!" unless cellId
+    @mgr.load(cellId)
+  end
+
+  def stop
+    super
+    saveIndexes
+    @mgr.saveAll
+  end
+
+  def deleteAll(klass)
+    findIdByClass(klass).each{|o|deleteId(o)}
+    pp "DELALL",@indexes
+  end
+
+  private
+
+  def find(hash)
+    set=nil
+    hash.each{|k,v|
+      v=[v].flatten
+      res=v.map{|a|@indexes[k][a]}.flatten.select{|i|i}
+      if set.nil?
+        set=res
+      else
+        set&=res
+      end
+    }
+    set.flatten.select{|s|not s.nil?}
+  end
+
+  def readIndexes
+    config=retrieveConfig
+    indexes=config["indexes"].content
+    if indexes
+      indexes.each{|name,index|
+        @indexes[name.to_sym]=LocalObjectStorage::Index.new(self,name)
+        @indexes[name.to_sym].load(index)
+      }
+    end
+    
+  end
+
+  def saveIndexes
+    config=retrieveConfig
+    @indexes.each{|name,index|
+      config["indexes"][name]=index.dump
+    }
+  end
+
+  def storeIndex(which,what)
+    i=@indexes[which]
+    what.each{|n,v|i[n]=v}
+  end
+
+  def createIndexes
+    [:objectId,:class].each{|key|
+      @indexes[key]= LocalObjectStorage::Index.new(self,key)
+    }
+  end
+end

data/apps/local_object_storage/spec/local_object_storage_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path('../../local_object_storage.rb',__FILE__)
+
+class ExampleObject<PersistentObject
+  attr_accessor :a
+
+  def initialize(store)
+    super
+  end
+end
+
+describe "Local Object Storage marshaling" do
+  it "should only marshal simple types" do
+    b=TestBed.new
+    store=b.run("LocalObjectStorage")
+    o=ExampleObject.new(store)
+    o.a=10
+    data=LocalObjectStorage::Marshal::dump(o)
+    o2=LocalObjectStorage::Marshal::load(data,store)
+    o2.class.should == ExampleObject
+    o2.a.should == 10
+    b.stop
+  end
+  it "should store ids for persistent objects" do
+    b=TestBed.new
+    store=b.run("LocalObjectStorage")
+    a=ExampleObject.new(store)
+    x=ExampleObject.new(store)
+    a.a=x
+    data=LocalObjectStorage::Marshal::dump(a)
+    a2=LocalObjectStorage::Marshal::load(data,store)
+    a2.a.should be_a_kind_of(IncompleteObject)
+    b.stop
+  end
+  it "should resolve persistent objects on use" do
+    b=TestBed.new
+    store=b.run("LocalObjectStorage")
+    a=ExampleObject.new(store)
+    x=ExampleObject.new(store)
+    a.a=x
+    a.save
+    x.save
+    data=LocalObjectStorage::Marshal::dump(a)
+    a2=LocalObjectStorage::Marshal::load(data,store)
+    a2.a.a
+    a2.a.should be_a_kind_of(ExampleObject)
+    a2.a.should == x
+    b.stop
+  end
+
+  it "should store arrays of po's correctly" do
+    b=TestBed.new
+    store=b.run("LocalObjectStorage")
+    a=ExampleObject.new(store)
+    x=ExampleObject.new(store)
+    z=ExampleObject.new(store)
+    a.a=[x,z]
+    a.save
+    x.save
+    z.save
+    data=LocalObjectStorage::Marshal::dump(a)
+    a2=LocalObjectStorage::Marshal::load(data,store)
+    #a2.a.read
+    a2.a.should be_a_kind_of(Array)
+    a2.a.each{|y|y.read if y.is_a?(IncompleteObject)}
+    a2.a.should == [x,z]
+    b.stop
+  end
+end
+
+describe "Local Object Storage" do
+  it "should store persistent objects within pages" do
+    t=TestBed.new
+    store=t.run("LocalObjectStorage")
+    store.deleteAll(ExampleObject)
+    
+    a=ExampleObject.new(store)
+    a.a=99
+    a.save
+    t.stop
+    t=TestBed.new(:testbedId=>t.testbedId)
+    store=t.run("LocalObjectStorage")
+    #store.outputIndexes
+    xs=store.findByClass(ExampleObject)
+    xs.should == [a]
+    t.stop
+  end
+  it "indexes keep track of object's positions" do
+    b=TestBed.new
+    store=b.run("LocalObjectStorage")
+    a=ExampleObject.new(store)
+    a.a=99
+    a.save
+    objectId=a.objectId
+    x=store.findByObjectId(objectId)
+    x.should == a
+    xs=store.findByClass(ExampleObject)
+    xs.should == [a]
+    xs=ExampleObject.getAll(store)
+    xs.should == [a]
+
+    store.findByClass(String).should == []
+    b.stop
+  end
+  it "deleting objects should keep track of indexes" do
+    b=TestBed.new
+    store=b.run("LocalObjectStorage")
+    store.deleteAll(ExampleObject)
+    a=ExampleObject.new(store)
+    a.a=99
+    a.save
+    objectId=a.objectId
+    a=ExampleObject.new(store)
+    a.a=70
+    a.save
+    store.findByClass(ExampleObject).length.should == 2
+    a.delete
+    store.findByClass(ExampleObject).length.should == 1
+    as=store.findByClass(ExampleObject)
+    as[0].objectId.should == objectId
+    b.stop
+  end
+  it "should differentiate between owning and owned objects for garbage collection"
+end

data/apps/local_secure_file_store/local_secure_file_store.rb

@@ -0,0 +1,64 @@
+require 'service.rb'
+
+class LocalSecureFileStoreApp<Service
+  
+  class MyFile
+    
+  end
+  
+  class FileDoesNotExist<Exception
+    
+  end
+  
+  def initialize(cluster,options)
+    super(cluster,options,:localSecureFileStore)
+  end
+  
+  def load(name,key)
+    key=hash(key)
+    name=check(name)
+    filename=name+"_"+key
+    p=path(filename)
+    raise FileDoesNotExist unless File.exists?(p)
+    read(p)
+  end
+  
+  def files(key)
+    key=hash(key)
+    filename="*_"+key
+    Dir[path(filename)].map{|f|File.split(f)[1].gsub("_"+key,"")}
+  end
+  
+  def store(name,key,content)
+    key=hash(key)
+    name=check(name)
+    if name.length>0
+      p=path(name+"_"+key)
+      f=File.open(p,"w")
+      f.print content
+      f.close
+      true
+    else
+      false
+    end
+  end
+  
+  private
+  
+  def hash(value)
+    Crypt::hexdigest(value.to_s)
+  end
+  
+  def path(file)
+    File.join(getAppDataPath,file)
+  end
+  def read(file)
+    f=File.open(file)
+    c=f.read
+    f.close
+    c
+  end
+  def check(name)
+    name.gsub(/[^a-zA-Z0-9_]/,"")
+  end
+end