hprevalence 0.1.1 → 0.2.0

data/lib/hprevalence.rb

@@ -1,29 +1,29 @@
 
 require 'thread'
-require 'guid'
-require 'transparent'
 require 'internal/command_logger'
 require 'internal/iomanager'
 require 'internal/serializer'
 require 'internal/store_manager'
+require 'internal/marshallers/default'
 
 module HPrevalence
   
   #  
   class EngineBuilder
     
-    def self.build( target_dir, &system_init )
-      ensure_dir( target_dir )
-      system = system_init.call
-      SimpleEngine.new( target_dir, system )
-    end
-    
-    def self.build_transparent( target_dir, &system_init )
+    def self.build( 
+        target_dir, 
+        marshaller = DefaultMarshaller.new(), 
+        iomanager = FileIOManager.new(target_dir),
+        model_serializer = DefaultModelSerializer.new(iomanager, marshaller), 
+        &system_init )
+      
       ensure_dir( target_dir )
       system = system_init.call
-      TransparentEngine.new( target_dir, system )
+      raise 'System nil ?' if system.nil?
+      SimpleEngine.new( target_dir, system, iomanager, marshaller, model_serializer )
     end
-    
+
     private
     
     def self.ensure_dir( dir )
@@ -34,12 +34,18 @@ module HPrevalence
     
   end
   
-  #   
+  # 
   class SimpleEngine
-    
     attr_reader :system, :target_dir
     
-    def initialize( target_dir, system, store_manager = StorageManager.new(target_dir) )
+    def initialize( 
+          target_dir, 
+          system, 
+          iomanager = FileIOManager.new(target_dir),
+          marshaller = DefaultMarshaller.new(), 
+          model_serializer = DefaultModelSerializer.new(iomanager, marshaller), 
+          store_manager = StorageManager.new(target_dir, iomanager, marshaller, model_serializer) )
+          
       @lock = Mutex.new
       @target_dir, @system, @store_manager = target_dir, system, store_manager
       @system = @store_manager.restore( system() )
@@ -48,8 +54,10 @@ module HPrevalence
     def execute_command( command )
       raise 'Invalid command' unless command.respond_to?( :execute )
       @lock.synchronize {
+        set_time_if_requested(command)
+        result = command.execute( @system )
         @store_manager.store( command )
-        return command.execute( @system )
+        result
       }
     end
     
@@ -63,174 +71,12 @@ module HPrevalence
       }
     end
     
-  end
-  
-  #
-  #
-  class TransparentEngine < SimpleEngine
-    @@engines = Hash.new()
-    @@class_lock = Mutex.new
-    
-    attr_reader :engine_id
-    
-    def initialize( target_dir, system )
-      @proxies_lock = Mutex.new
-      @engine_id = Guid.new()
-      
-      TransparentEngine.register_engine( self )
-      
-      @proxies = Hash.new
-      add_engine_id_method( system )
-      store_manager = TransparentStorageManager.new(self, target_dir)
-      within_engine {
-        @proxied_system = HPrevalence::Transparent::TransparentProxy.new( system, Guid.from_s('00000000-0000-0000-0000-000000000000') )
-      }
-      
-      super( target_dir, system, store_manager )
-    end
-    
-    def system
-      @proxied_system
-    end
-    
-    def close
-      super
-      TransparentEngine.unregister_engine( self )
-    end
-    
-    def take_snapshot
-      @lock.synchronize {
-        begin
-          Thread.current[:references] = Hash.new
-          within_engine {
-            @store_manager.take_snapshot @proxied_system
-          }
-        ensure
-          Thread.current[:references] = nil
-        end
-      }
-    end
-    
-    def execute_command(command)
-      begin
-        Thread.current[:references] = Hash.new
-        super(command)
-      ensure
-        Thread.current[:references] = nil
-      end
-    end
-    
-    def register_proxy(proxy)
-      @proxies[ proxy.proxy_id.to_s ] = proxy
-    end
-    
-    def proxy_by_id( id, related_symbol = nil, parent_proxy_id = nil )
-      p = @proxies[ id.to_s ]
-      return p unless p.nil?
-      if !related_symbol.nil? && !parent_proxy_id.nil?
-        return create_nested_proxy( parent_proxy_id, related_symbol )
-      end
-      nil
-    end
-    
-    def create_nested_proxy( parent_proxy_id, related_symbol )
-      @proxies_lock.synchronize {
-        parent_proxy = proxy_by_id( parent_proxy_id )
-        target = parent_proxy.target
-        nested_target = target.send( related_symbol )
-        new_proxy = HPrevalence::Transparent::NestedTransparentProxy.new( 
-          nested_target, related_symbol, parent_proxy_id )
-        target._set_proxy( related_symbol, new_proxy )
-        return new_proxy
-      }
-    end
-    
-    def create_result_proxy( target )
-      @proxies_lock.synchronize {
-#        parent_proxy = proxy_by_id( parent_proxy_id )
-#        target = parent_proxy.target
-#        result = target.send( related_symbol, *args )
-        new_proxy = HPrevalence::Transparent::TransparentProxy.new( target )
-        return new_proxy
-      }
-    end
-    
-    def within_engine()
-      begin
-        Thread.current[:engine] = self
-        yield
-      ensure
-        Thread.current[:engine] = nil
-      end
-    end
-    
-    def restore(proxy)
-      proxy.engine_id = @engine_id 
-      p = proxy_by_id( proxy.proxy_id )
-      if (p.nil?)
-        register_proxy(proxy)
-        p = proxy
-      end
-      p
-    end
-    
-    def self.create_nested_proxy( parent_proxy_id, symbol, engine_id )
-      within_engine( engine_id ) { |engine|
-        engine.create_nested_proxy( parent_proxy_id, symbol )
-      }
-    end
-    
-    def self.create_result_proxy( target, engine_id )
-      within_engine( engine_id ) { |engine|
-        engine.create_result_proxy( target )
-      }
-    end 
-    
-    def self.within_engine( engine_id )
-      engine = @@engines[ engine_id ]
-      raise 'Engine not found' if engine.nil?
-      begin
-        # puts 'engine>'
-        Thread.current[:engine] = engine
-        yield(engine)
-      ensure
-        Thread.current[:engine] = nil
-        # puts 'engine<'
-      end
-    end
-    
-    def self.current()
-      engine = Thread.current[:engine]
-      
-      if block_given?
-        # puts 'engine.current'
-        raise 'Engine not found' if engine.nil?
-        yield( engine )
-        # puts 'end.current'
-      else
-        return engine
-      end
-    end
-    
     protected
     
-    def self.register_engine( engine )
-      @@class_lock.synchronize { 
-        @@engines[engine.engine_id] = engine
-      }
-    end
-    
-    def self.unregister_engine( engine )
-      @@class_lock.synchronize { 
-        @@engines.delete(engine.engine_id)
-      }
-    end
-    
-    def add_engine_id_method( system )
-      temp_id = @engine_id
-      system.instance_eval { 
-        @engine_id = temp_id
-      }
+    def set_time_if_requested(command)
+      if command.respond_to?( :now= )
+        command.now = Time.now()
+      end
     end
   end
   
@@ -253,6 +99,7 @@ module HPrevalence
     def initialize( engine, snapshot_interval )
       @engine = engine
       @snapshot_interval = snapshot_interval
+      start_snapshot_thread
     end
     
     def start_snapshot_thread

data/lib/internal/command_logger.rb

@@ -1,65 +1,47 @@
 
-class BinaryCommandSerializer
-  
-  def initialize( io )
+class CommandSerializer
+  def initialize( io, marshaler )
     raise 'Invalid stream' if io.nil? 
-    @io = io
+    @io, @marshaler = io, marshaler
     @io.binmode
-#    register_finalize()
   end
   
   def <<(command)
     raise 'Invalid command' if command.nil? 
-    Marshal.dump( command, @io )
+    @marshaler.serialize_to_stream( command, @io )
     @io.flush
     @io.fsync
   end
   
-  def self.restore_from_io( io, system )
-    # Theorically this should work and its more elegant than the current version
+  def self.restore_from_io( io, system, marshaler )
+#    Theorically this should work and its more elegant than the current version
 #    Marshal.load( io ) { |command|
 #      command.execute( system )
 #    }
     while( !io.eof? ) 
-      command = Marshal.load( io )
+      command = marshaler.restore( io )
       command.execute( system )
     end
   end
   
   def close
     @io.close
-#    unregister_finalize
   end
-#
-#  protected
-#  
-#  def register_finalize
-#    ObjectSpace.define_finalizer( self ) {
-#      |logger|
-#      logger.close
-#    }
-#  end
-#
-#  def unregister_finalize
-#    ObjectSpace.undefine_finalizer( self )
-#  end
-  
 end
 
 class CommandLogger
-  
   Logger_Extension = 'commandlog' 
   
   attr_reader :current_file_name
   
-  def initialize( iomanager )
-    @iomanager = iomanager
+  def initialize( iomanager, marshaler )
+    @iomanager, @marshaler = iomanager, marshaler
   end
   
   def create_command_store()
     stream = @iomanager.create_new_stream( Logger_Extension )
     @current_file_name = stream.full_name
-    BinaryCommandSerializer.new( stream )
+    CommandSerializer.new( stream, @marshaler )
   end
   
   def log_files
@@ -69,29 +51,24 @@ class CommandLogger
   # removes all command_logs as a snapshot has been taken
   def reset_commands()
     streams = @iomanager.obtain_ordered_read_streams( Logger_Extension )
-
     streams.each do |stream|
         stream.close
         File.delete stream.full_name
     end
-
   end
   
   def restore( system )
     streams = @iomanager.obtain_ordered_read_streams( Logger_Extension )
     
     begin
-
       streams.each do |stream|
-        BinaryCommandSerializer.restore_from_io( stream, system )
+        CommandSerializer.restore_from_io( stream, system, @marshaler )
       end
-      
     ensure
       streams.each do |stream|
         stream.close
       end
     end
-    
   end
   
 end

data/lib/internal/marshallers/default.rb

@@ -0,0 +1,17 @@
+
+class DefaultMarshaller
+
+  def serialize(graph)
+    Marshal.dump(graph)
+  end
+
+  def serialize_to_stream(graph, stream)
+    Marshal.dump(graph, stream)
+  end
+  
+  def restore(stream)
+    Marshal.restore(stream)
+  end
+
+end
+

data/lib/internal/marshallers/soap_marshaller.rb

@@ -0,0 +1,26 @@
+
+require 'soap/marshal'
+
+#
+# Probably the most inneficient 
+# marshaller implementation
+#
+class SoapMarshaller
+
+  def serialize(graph)
+    content = SOAP::Marshal.dump(graph)
+    Marshal.dump( content )
+  end
+  
+  def serialize_to_stream(graph, stream)
+    content = SOAP::Marshal.dump(graph)
+    Marshal.dump( content, stream )
+  end
+  
+  def restore(stream)
+    content = Marshal.load( stream )
+    SOAP::Marshal.load(content)
+  end
+
+end
+

data/lib/internal/marshallers/yaml_marshaller.rb

@@ -0,0 +1,22 @@
+
+require 'yaml'
+
+class YamlMarshaller
+
+  def serialize(graph)
+    content = YAML.dump(graph)
+    Marshal.dump( content )
+  end
+  
+  def serialize_to_stream(graph, stream)
+    content = YAML.dump(graph)
+    Marshal.dump( content, stream )
+  end
+  
+  def restore(stream)
+    content = Marshal.load( stream )
+    YAML.load(content)
+  end
+
+end
+

data/lib/internal/serializer.rb

@@ -1,16 +1,15 @@
 
 class DefaultModelSerializer
-
   Snapshot_Extension = 'snapshot'
 
-  def initialize( iomanager )
-    @iomanager = iomanager
+  def initialize( iomanager, marshaller )
+    @iomanager, @marshaller = iomanager, marshaller
   end
   
   def dump( object_model )
     begin
       stream = @iomanager.create_new_stream( Snapshot_Extension )
-      Marshal.dump( object_model, stream )
+      @marshaller.serialize_to_stream( object_model, stream )
     ensure
       stream.close
     end
@@ -22,7 +21,7 @@ class DefaultModelSerializer
     return nil if stream.nil?
     
     begin
-      object_model = Marshal.load( stream )
+      object_model = @marshaller.restore( stream )
     ensure
       stream.close
     end
@@ -32,52 +31,39 @@ class DefaultModelSerializer
 
 end
 
-#class SmartModelSerializer
-#
-#  Snapshot_Extension = 'ssnapshot'
+# 
+# TODO: VersionIndependentSerializer is intended to handle
+# small modifications in the object model, like new fields or 
+# even excluded fields, without breaking the existing snapshots
 #
-#  def initialize( iomanager )
-#    @iomanager = iomanager
-#  end
-#  
-#  def dump( object_model )
-#    
-#    begin
-#      stream = @iomanager.create_new_stream( Snapshot_Extension )
-#      graph = ObjectGraph.build( object_model )
-#      write_object_tree( stream, graph )
-#    ensure
-#      stream.close
-#    end
-#      
-#  end
-#  
-#  def load()
-#    
-#    object_model = nil
-#    
-#    begin
-#      stream = @iomanager.obtain_latest_read_stream( Snapshot_Extension )
-#      graph = read_object_tree( stream )
-#      object_model = graph.root
-#    ensure
-#      stream.close
-#    end
-#    
-#    object_model
-#    
-#  end
-#  
-#  protected
-#  
-#  def write_object_tree( stream, object )
-#    Marshal.dump( object, stream )
-#  end
-#
-#  def read_object_tree( stream )
-#    Marshal.load( stream )
-#  end
-#  
-#end
-
+class VersionIndependentSerializer
+  Snapshot_Extension = 'version-ind-snapshot'
 
+  def initialize( iomanager, marshaller )
+    @iomanager, @marshaller = iomanager, marshaller
+  end
+  
+  def dump( object_model )
+    begin
+      stream = @iomanager.create_new_stream( Snapshot_Extension )
+      @marshaller.serialize_to_stream( object_model, stream )
+    ensure
+      stream.close
+    end
+  end
+  
+  def load()
+    object_model = nil
+    stream = @iomanager.obtain_latest_read_stream( Snapshot_Extension )
+    return nil if stream.nil?
+    
+    begin
+      object_model = @marshaller.restore( stream )
+    ensure
+      stream.close
+    end
+    
+    object_model
+  end
+  
+end