hprevalence 0.1.0

data/README

@@ -0,0 +1,18 @@
+
+Thanks for using HPrevalence!
+
+Don't forget:
+
+- You'll need RubyGems to install it:
+  Grab it http://rubygems.rubyforge.org
+
+And HPrevalence depends on
+
+- Guid
+  http://guid.rubyforge.org
+
+- Rake (if you want to execute the test cases)
+  http://rake.rubyforge.org
+
+
+Enjoy!

data/lib/hprevalence.rb

@@ -0,0 +1,243 @@
+
+require 'thread'
+require 'guid'
+require 'transparent'
+require 'internal/command_logger'
+require 'internal/iomanager'
+require 'internal/serializer'
+require 'internal/store_manager'
+
+module HPrevalence
+  
+  #  
+  class EngineBuilder
+    
+    def self.build( target_dir, &system_init )
+      system = system_init.call
+      SimpleEngine.new( target_dir, system )
+    end
+    
+    def self.build_transparent( target_dir, &system_init )
+      system = system_init.call
+      TransparentEngine.new( target_dir, system )
+    end
+    
+  end
+  
+  #   
+  class SimpleEngine
+    
+    attr_reader :system, :target_dir
+    
+    def initialize( target_dir, system, store_manager = StorageManager.new(target_dir) )
+      @lock = Mutex.new
+      @target_dir, @system, @store_manager = target_dir, system, store_manager
+      @system = @store_manager.restore( system() )
+    end
+    
+    def execute_command( command )
+      raise 'Invalid command' unless command.respond_to?( :execute )
+      @lock.synchronize {
+        @store_manager.store( command )
+        return command.execute( @system )
+      }
+    end
+    
+    def close
+      @store_manager.close
+    end
+    
+    def take_snapshot
+      @lock.synchronize {
+        @store_manager.take_snapshot @system
+      }
+    end
+    
+  end
+  
+  #
+  # Holds only one system
+  #
+  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 = []
+      add_engine_id_method( system )
+      store_manager = TransparentStorageManager.new(self, target_dir)
+      within_engine {
+        @proxied_system = HPrevalence::Transparent::TransparentProxy.new( system )
+      }
+      
+      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)
+      super(command)
+    end
+    
+    def register_proxy(proxy)
+      # TODO: Synchronization here?
+      @proxies << proxy
+      @proxies.length - 1
+    end
+    
+    def proxy_by_id( id, related_symbol = nil, parent_proxy_id = nil )
+      p = @proxies[ id ]
+      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 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?)
+        proxy.proxy_id = 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.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
+      }
+      #      (class << system; self;end).class_eval do
+      #        define_method(:_engine_id) { @engine_id }
+      #      end
+    end
+    
+  end
+  
+  class PrevalenceService
+    attr_reader :engine
+    
+    def self.create_service( snapshot_interval = 60 * 60 * 1000, &engine_init )
+      engine = engine_init.call
+      raise 'Engine not created' if engine.nil?
+      PrevalenceService.new( engine, snapshot_interval )
+    end
+    
+    def system
+      @engine.system
+    end
+    
+    protected
+    
+    def initialize( engine, snapshot_interval )
+      @engine = engine
+      @snapshot_interval = snapshot_interval
+    end
+    
+    def start_snapshot_thread
+      Thread.new(self) {
+        while true
+          sleep(@snapshot_interval)
+          engine.take_snapshot
+        end
+      }
+    end
+    
+  end
+  
+end

data/lib/internal/command_logger.rb

@@ -0,0 +1,98 @@
+
+class BinaryCommandSerializer
+  
+  def initialize( io )
+    raise 'Invalid stream' if io.nil? 
+    @io = io
+    @io.binmode
+#    register_finalize()
+  end
+  
+  def <<(command)
+    raise 'Invalid command' if command.nil? 
+    Marshal.dump( 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
+#    Marshal.load( io ) { |command|
+#      command.execute( system )
+#    }
+    while( !io.eof? ) 
+      command = Marshal.load( 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
+  end
+  
+  def create_command_store()
+    stream = @iomanager.create_new_stream( Logger_Extension )
+    @current_file_name = stream.full_name
+    BinaryCommandSerializer.new( stream )
+  end
+  
+  def log_files
+    @iomanager.list( Logger_Extension )
+  end
+  
+  # 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 )
+      end
+      
+    ensure
+      streams.each do |stream|
+        stream.close
+      end
+    end
+    
+  end
+  
+end
+

data/lib/internal/iomanager.rb

@@ -0,0 +1,83 @@
+
+
+class FileIOManager
+
+  attr_reader :positions, :target_dir
+  
+  def initialize( target_dir, positions = 12 )
+    @target_dir, @positions = target_dir, positions
+  end
+  
+  def create_new_stream( extension )
+    file_name = obtain_next_available( extension )
+    create_write_stream( file_name )
+  end
+  
+  def list( extension )
+    unless File.exist?( @target_dir )
+      return []
+    end
+    dir = File.join( @target_dir, "*.#{extension}" )
+    valid_entries = Dir.entries( @target_dir ).select do |entry|
+      entry =~ /^\d{#{positions}}\.#{extension}$/ 
+    end
+    valid_entries.sort
+  end
+  
+  def obtain_ordered_read_streams( extension )
+    streams = []
+    
+    list( extension ).each do |file|
+      file_name = File.join( @target_dir, file )
+      streams << create_read_stream( file_name )
+    end
+    
+    streams
+  end
+  
+  def obtain_latest_read_stream( extension )
+    files = list( extension )
+    return nil if files.length == 0
+    
+    file_name = File.join( @target_dir, files.max )
+    create_read_stream( file_name )
+  end
+  
+  protected
+  
+  def create_read_stream( file_name )
+    file = File.new( file_name, "rb" )
+    add_helper_methods( file, file_name )
+  end
+
+  def create_write_stream( file_name )
+    file = File.new( file_name, "wb" )
+    add_helper_methods( file, file_name )
+  end
+  
+  def add_helper_methods( stream, file_name )
+    (class << stream; self; end).class_eval do
+      define_method(:full_name) { file_name }
+      define_method(:basename) { File.basename(file_name) }
+    end
+    stream
+  end
+
+  def obtain_hightest_num( extension )
+    val = 0
+    list( extension ).each do |file|
+      new_val = file.slice( 0, positions ).to_i
+      if new_val > val
+        val = new_val
+      end
+    end
+    val
+  end
+  
+  def obtain_next_available( extension )
+    val = obtain_hightest_num( extension )
+    sprintf("%s/%0#{positions}d.%s", @target_dir, val + 1, extension)
+  end
+  
+end
+

data/lib/internal/object_graph.rb

@@ -0,0 +1,68 @@
+
+class ObjectGraph
+  
+  def initialize()
+    @root = nil
+    @registry = Hash.new()
+  end
+  
+  def self.build( node )
+    graph = ObjectGraph.new()
+    graph.root = node
+    graph
+  end
+  
+  def root=( node )
+    @root = GraphItem.new( self, node )
+  end
+  
+  def root
+    @root.object
+  end
+  
+  def object_reference( var )
+    graph_item = @registry[ var ]
+    if (graph_item.nil?)
+      graph_item = GraphItem.new( self, var )
+      @registry[ var ] = graph_item
+    end
+    graph_item
+  end
+  
+end
+
+class GraphItem
+  
+  def initialize( graph, node )
+    @instance_vars = Hash.new
+    @node_type = node.class
+    
+    node.instance_variables.each do |var|
+      name = var.slice(1, var.length - 1)
+      @instance_vars[ name ] = graph.object_reference( node.instance_eval(var) )
+    end
+  end
+  
+  def object
+    obj = @node_type.allocate
+    restore_instance_vars obj
+    obj
+  end
+  
+  protected
+  
+  def restore_instance_vars(obj)
+    @instance_vars.each do |name, value|
+      
+      var = value.object
+      
+      setter = name + "="
+      if obj.respond_to?(setter)
+        obj.__send__(setter, var)
+      else
+        obj.instance_eval("@#{ name } = var")
+      end
+    end
+  end
+  
+end

data/lib/internal/serializer.rb

@@ -0,0 +1,83 @@
+
+class DefaultModelSerializer
+
+  Snapshot_Extension = 'snapshot'
+
+  def initialize( iomanager )
+    @iomanager = iomanager
+  end
+  
+  def dump( object_model )
+    begin
+      stream = @iomanager.create_new_stream( Snapshot_Extension )
+      Marshal.dump( 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 = Marshal.load( stream )
+    ensure
+      stream.close
+    end
+    
+    object_model
+  end
+
+end
+
+#class SmartModelSerializer
+#
+#  Snapshot_Extension = 'ssnapshot'
+#
+#  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
+
+

data/lib/internal/store_manager.rb

@@ -0,0 +1,74 @@
+
+module HPrevalence
+  
+  class StorageManager
+    
+    def initialize( target_dir, iomanager = FileIOManager.new(target_dir), logger = CommandLogger.new(iomanager), model_serializer = DefaultModelSerializer.new(iomanager) )
+      @target_dir, @model_serializer = target_dir, model_serializer
+      @logger = logger
+      @comand_store = nil
+    end
+    
+    def restore( system )
+      system = restore_snapshot( system )
+      restore_commands( system )
+      system
+    end
+    
+    def store( command )
+      ensure_command_store
+      @comand_store << command
+    end
+    
+    def take_snapshot( system )
+      @model_serializer.dump( system )
+      close()
+      @logger.reset_commands
+    end
+    
+    def close
+      @comand_store.close unless @comand_store.nil?
+      @comand_store = nil
+    end
+    
+    protected
+    
+    def ensure_command_store
+      @comand_store ||= @logger.create_command_store()
+    end
+    
+    def restore_commands( system )
+      @logger.restore( system )
+    end
+    
+    def restore_snapshot( system )
+      system_new = @model_serializer.load
+      if !system_new.nil?
+        system = system_new
+      end
+      system
+    end
+    
+  end
+  
+  #
+  #
+  #
+  class TransparentStorageManager < StorageManager
+    
+    def initialize( engine, target_dir, iomanager = FileIOManager.new(target_dir), logger = CommandLogger.new(iomanager), model_serializer = DefaultModelSerializer.new(iomanager) )
+      super( target_dir, iomanager, logger, model_serializer )
+      @engine = engine
+    end
+    
+    def restore( system )
+      @engine.within_engine {
+        system = restore_snapshot( system )
+        restore_commands( system )
+      }
+      system
+    end
+    
+  end
+  
+end