madeleine 0.7.3 → 0.8.0.pre

data/{NEWS → CHANGES.txt}

@@ -1,3 +1,9 @@
+    * Ruby 1.9 compatible (requires at least 1.8.7)
+    * Dropped the 'automatic' feature (Madeleine::Automatic etc)
+    * Dropped support for SOAP marshalling
+    * Removed deprecated classes:
+      - ClockedSnapshotMadeleine
+      - TimeOptimizingLogger
 
 Madeleine 0.7.3 (June 11, 2006):
 

data/README

@@ -3,23 +3,11 @@ Madeleine is a Ruby implementation of Object Prevalence: Transparent
 persistence of business objects using command logging and complete
 system snapshots.
 
-<http://madeleine.rubyforge.org/>
+https://github.com/ghostganz/madeleine
 
 Madeleine's design is based on Prevayler, the original Java
 prevalence layer.
 
-Learn more about object prevalence at <http://www.prevayler.org/>.
-
-
-Installation:
-
-    Typical installation procedure is:
-    $ ruby install.rb config
-    $ ruby install.rb setup
-    # ruby install.rb install  (may require root privilege)
-    Try 'ruby install.rb --help' for detailed usage.
-
-    [From the documentation of Minero Aoki's 'install.rb']
 
 Usage:
 
@@ -40,23 +28,12 @@ Usage:
 
 Requirements:
 
-    * Ruby 1.8.1 or later
-
-    Additionaly, some of the sample code also uses ruby/tk.
-
-
-Known problems:
-
-    * Won't run in some Windows-ports of Ruby due to missing
-      fsync() call.
+    * Ruby 1.8.7 or later
 
 Contact:
 
     Homepage:
-    <http://madeleine.rubyforge.org/>
-
-    Questions, bug reports, patches, complaints? Use the mailing list:
-    <http://rubyforge.org/mailman/listinfo/madeleine-devel>
+    https://github.com/ghostganz/madeleine
 
 License:
 
@@ -69,8 +46,8 @@ Credits:
 
     With the help of patches, testing and feedback from:
 
-    Steve Conover, David Heinemeier Hansson, Johan Lind, H�kan R�berg,
-    IIMA Susumu, Martin Tampe and Jon Tirs�n
+    Steve Conover, David Heinemeier Hansson, Johan Lind, Håkan Råberg,
+    IIMA Susumu, Martin Tampe and Jon Tirsén
 
     Thanks to Klaus Wuestefeld and the Prevayler developers for the
     model of this software; to Minero Aoki for the installer; to Matz and

data/contrib/batched.rb

@@ -1,8 +1,9 @@
+# -*- coding: utf-8 -*-
 # Batched writes for Madeleine
 #
-# Copyright(c) H�kan R�berg 2003
+# Copyright(c) Håkan Råberg 2003
+#
 #
-# 
 # This is an experimental implementation of batched log writes to mininize 
 # calls to fsync. It uses a Shared/Exclusive-Lock, implemented in sync.rb, 
 # which is included in Ruby 1.8.

data/contrib/test_batched.rb

@@ -1,6 +1,7 @@
 #!/usr/local/bin/ruby -w
+# -*- coding: utf-8 -*-
 #
-# Copyright(c) 2003 H�kan R�berg
+# Copyright(c) 2003 Håkan Råberg
 #
 # Some components taken from test_persistence.rb
 # Copyright(c) 2003 Anders Bengtsson
@@ -14,7 +15,7 @@ require 'madeleine/clock'
 
 
 module Madeleine::Batch
-  class BatchedSnapshotMadeleineTest < Test::Unit::TestCase
+  class BatchedSnapshotMadeleineTest < MiniTest::Unit::TestCase
 
     class ArraySystem < Array
       include Madeleine::Clock::ClockedSystem
@@ -121,7 +122,7 @@ module Madeleine::Batch
     end
   end
 
-  class BatchedLogTest < Test::Unit::TestCase
+  class BatchedLogTest < MiniTest::Unit::TestCase
 
     class MockMadeleine
       def initialize(logger)
@@ -236,10 +237,10 @@ def add_batched_tests(suite)
 end
 
 if __FILE__ == $0
-  suite = Test::Unit::TestSuite.new("BatchedLogTest")
+  suite = MiniTest::Unit::TestSuite.new("BatchedLogTest")
   add_batched_tests(suite)
 
   require 'test/unit/ui/console/testrunner'
   Thread.abort_on_exception = true
-  Test::Unit::UI::Console::TestRunner.run(suite)
+  MiniTest::Unit::UI::Console::TestRunner.run(suite)
 end

data/lib/madeleine.rb

@@ -9,7 +9,7 @@
 #  require 'madeleine'
 #
 #  madeleine = SnapshotMadeleine.new("my_example_storage") {
-#    SomeExampleApplication.new()
+#    SomeExampleApplication.new
 #  }
 #
 #  madeleine.execute_command(command)
@@ -22,8 +22,9 @@ module Madeleine
   require 'fileutils'
   require 'madeleine/files'
   require 'madeleine/sanity'
+  require 'madeleine/version'
 
-  MADELEINE_VERSION = "0.7.3"
+  MADELEINE_VERSION = Madeleine::VERSION
 
   class SnapshotMadeleine
 
@@ -33,7 +34,7 @@ module Madeleine
     # then be restored from the command logs.
     #
     # You can provide your own snapshot marshaller, for instance using
-    # YAML or SOAP, instead of Ruby's built-in marshaller. The
+    # YAML, instead of Ruby's built-in marshaller. The
     # <tt>snapshot_marshaller</tt> must respond to
     # <tt>load(stream)</tt> and <tt>dump(object, stream)</tt>. You
     # must use the same marshaller every time for a system.
@@ -87,11 +88,11 @@ module Madeleine
     # * <tt>command</tt> - The command to execute on the system.
     def execute_command(command)
       verify_command_sane(command)
-      @lock.synchronize {
+      @lock.synchronize do
         raise MadeleineClosedException if @closed
         @logger.store(command)
         @executer.execute(command)
-      }
+      end
     end
 
     # Execute a query on the prevalent system.
@@ -102,9 +103,9 @@ module Madeleine
     #
     # * <tt>query</tt> - The query command to execute
     def execute_query(query)
-      @lock.synchronize_shared {
+      @lock.synchronize_shared do
         @executer.execute(query)
-      }
+      end
     end
 
     # Take a snapshot of the current system.
@@ -123,11 +124,11 @@ module Madeleine
     #    end
     #  }
     def take_snapshot
-      @lock.synchronize {
+      @lock.synchronize do
         @logger.close
         @snapshotter.take(@system)
         @logger.reset
-      }
+      end
     end
 
     # Close the system.
@@ -135,10 +136,10 @@ module Madeleine
     # The log file is closed and no new commands can be received
     # by this Madeleine.
     def close
-      @lock.synchronize {
+      @lock.synchronize do
         @logger.close
         @closed = true
-      }
+      end
     end
 
     private
@@ -213,9 +214,9 @@ module Madeleine
       id = SnapshotFile.highest_id(@directory_name)
       if id > 0
         snapshot_file = SnapshotFile.new(@directory_name, id).name
-        open(snapshot_file, "rb") {|snapshot|
+        open(snapshot_file, "rb") do |snapshot|
           system = @marshaller.load(snapshot)
-        }
+        end
       else
         system = new_system_block.call
       end
@@ -223,19 +224,19 @@ module Madeleine
     end
 
     def recover_logs(executer)
-      executer.recovery {
-        CommandLog.log_file_names(@directory_name, FileService.new).each {|file_name|
-          open(@directory_name + File::SEPARATOR + file_name, "rb") {|log|
+      executer.recovery do
+        CommandLog.log_file_names(@directory_name, FileService.new).each do |file_name|
+          open(@directory_name + File::SEPARATOR + file_name, "rb") do |log|
             recover_log(executer, log)
-          }
-        }
-      }
+          end
+        end
+      end
     end
 
     private
 
     def recover_log(executer, log)
-      while ! log.eof?
+      until log.eof?
         command = Marshal.load(log)
         executer.execute(command)
       end
@@ -264,9 +265,10 @@ module Madeleine
       result = file_service.dir_entries(directory_name).select {|name|
         name =~ /^\d{#{FILE_COUNTER_SIZE}}\.command_log$/
       }
-      result.each {|name| name.untaint }
-      result.sort!
-      result
+      result.each do |name|
+        name.untaint
+      end
+      result.sort
     end
 
     def initialize(path, file_service)
@@ -287,13 +289,13 @@ module Madeleine
 
     def self.highest_log(directory_name, file_service)
       highest = 0
-      log_file_names(directory_name, file_service).each {|file_name|
+      log_file_names(directory_name, file_service).each do |file_name|
         match = /^(\d{#{FILE_COUNTER_SIZE}})/.match(file_name)
         n = match[1].to_i
         if n > highest
           highest = n
         end
-      }
+      end
       highest
     end
   end
@@ -315,7 +317,7 @@ module Madeleine
     end
 
     def ensure_directory_exists
-      if ! File.exist?(@directory_name)
+      unless File.exist?(@directory_name)
         FileUtils.mkpath(@directory_name)
       end
     end
@@ -353,10 +355,11 @@ module Madeleine
     private
 
     def delete_log_files
-      Dir.glob(@directory_name + File::SEPARATOR + "*.command_log").each {|name|
+      names = Dir.glob(@directory_name + File::SEPARATOR + "*.command_log")
+      names.each do |name|
         name.untaint
         File.delete(name)
-      }
+      end
     end
 
     def open_new_log
@@ -370,14 +373,14 @@ module Madeleine
       return 0 unless File.exist?(directory_name)
       suffix = "snapshot"
       highest = 0
-      Dir.foreach(directory_name) {|file_name|
+      Dir.foreach(directory_name) do |file_name|
         match = /^(\d{#{FILE_COUNTER_SIZE}}\.#{suffix}$)/.match(file_name)
         next unless match
         n = match[1].to_i
         if n > highest
           highest = n
         end
-      }
+      end
       highest
     end
 
@@ -399,12 +402,12 @@ module Madeleine
     def take(system)
       numbered_file = SnapshotFile.next(@directory_name)
       name = numbered_file.name
-      open(name + '.tmp', 'wb') {|snapshot|
+      open("#{name}.tmp", 'wb') do |snapshot|
         @marshaller.dump(system, snapshot)
         snapshot.flush
         snapshot.fsync
-      }
-      File.rename(name + '.tmp', name)
+      end
+      File.rename("#{name}.tmp", name)
     end
   end
 
@@ -423,4 +426,3 @@ module Madeleine
 end
 
 SnapshotMadeleine = Madeleine::SnapshotMadeleine
-

data/lib/madeleine/clock.rb

@@ -7,10 +7,6 @@ require 'madeleine'
 module Madeleine
   module Clock
 
-    # Deprecated. Use SnapshotMadeleine instead.
-    class ClockedSnapshotMadeleine < ::Madeleine::SnapshotMadeleine # :nodoc:
-    end
-
     # Let your system extend this module if you need to access the
     # machine time. Used together with a TimeActor that keeps
     # the clock current.
@@ -53,12 +49,12 @@ module Madeleine
         @madeleine = madeleine
         @is_destroyed = false
         send_tick
-        @thread = Thread.new {
+        @thread = Thread.new do
           until @is_destroyed
             sleep(delay)
             send_tick
           end
-        }
+        end
       end
 
       def send_tick
@@ -75,20 +71,9 @@ module Madeleine
         @time = Time.at(0)
       end
 
-      def forward_to(newTime)
-        @time = newTime
+      def forward_to(new_time)
+        @time = new_time
       end
     end
-
-    #
-    # Internal classes below
-    #
-
-    # Deprecated. Merged into default implementation.
-    class TimeOptimizingLogger < ::Madeleine::Logger # :nodoc:
-    end
-
   end
 end
-
-ClockedSnapshotMadeleine = Madeleine::Clock::ClockedSnapshotMadeleine

data/lib/madeleine/version.rb

@@ -0,0 +1,3 @@
+module Madeleine
+  VERSION = "0.8.0.pre"
+end

data/lib/madeleine/zmarshal.rb

@@ -1,6 +1,6 @@
 #
 # Author::    Anders Bengtsson <ndrsbngtssn@yahoo.se>
-# Copyright:: Copyright (c) 2004
+# Copyright:: Copyright (c) 2004-2012
 #
 
 require 'zlib'
@@ -14,8 +14,7 @@ module Madeleine
   #
   # Uses <tt>zlib</tt> to do on-the-fly compression/decompression.
   #
-  # ZMarshal works with Ruby's own Marshal and YAML, but not with SOAP
-  # marshalling.
+  # ZMarshal works with Ruby's own Marshal and YAML
   #
   # Usage:
   #
@@ -24,7 +23,7 @@ module Madeleine
   #
   #  marshaller = Madeleine::ZMarshal.new(YAML)
   #  madeleine = SnapshotMadeleine.new("my_example_storage", marshaller) {
-  #    SomeExampleApplication.new()
+  #    SomeExampleApplication.new
   #  }
   #
   class ZMarshal
@@ -34,14 +33,9 @@ module Madeleine
     end
 
     def load(stream)
-      zstream = Zlib::GzipReader.new(stream)
+      zstream = WorkaroundGzipReader.new(stream)
       begin
-        # Buffer into a string first, since GzipReader can't handle
-        # Marshal's 0-sized reads and SOAP can't handle streams at all.
-        # In a bright future we can revert to reading directly from the
-        # stream again.
-        buffer = zstream.read
-        return @marshaller.load(buffer)
+        return @marshaller.load(zstream)
       ensure
         zstream.finish
       end
@@ -56,5 +50,18 @@ module Madeleine
       end
       nil
     end
+
+    private
+
+    class WorkaroundGzipReader < Zlib::GzipReader
+      # The 'psych' YAML parser, default since Ruby 1.9.3,
+      # assumes that its input IO has an external_encoding()
+      # method.
+      unless defined? external_encoding
+        def external_encoding
+          nil
+        end
+      end
+    end
   end
 end

metadata

@@ -1,63 +1,111 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
-specification_version: 1
+--- !ruby/object:Gem::Specification
 name: madeleine
-version: !ruby/object:Gem::Version 
-  version: 0.7.3
-date: 2006-06-11 00:00:00 +02:00
-summary: Madeleine is a Ruby implementation of Object Prevalence
-require_paths: 
-- lib
-email: ndrsbngtssn@yahoo.se
-homepage: http://madeleine.rubyforge.org
-rubyforge_project: 
-description: 
-autorequire: madeleine
-default_executable: 
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.1
-  version: 
+version: !ruby/object:Gem::Version
+  version: 0.8.0.pre
+  prerelease: 6
 platform: ruby
-signing_key: 
-cert_chain: 
-authors: 
+authors:
 - Anders Bengtsson
-files: 
-- lib/madeleine.rb
-- lib/madeleine/automatic.rb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Transparent persistence of system state using logging and snapshots
+email: ndrsbngtssn@yahoo.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
 - lib/madeleine/clock.rb
 - lib/madeleine/files.rb
 - lib/madeleine/sanity.rb
+- lib/madeleine/version.rb
 - lib/madeleine/zmarshal.rb
-- samples/dictionary_client.rb
+- lib/madeleine.rb
 - samples/clock_click.rb
+- samples/dictionary_client.rb
 - samples/dictionary_server.rb
 - samples/painter.rb
-- contrib/test_batched.rb
 - contrib/batched.rb
 - contrib/benchmark.rb
-- contrib/threaded_benchmark.rb
 - contrib/create_command.rb
+- contrib/test_batched.rb
 - contrib/test_scalability.rb
+- contrib/threaded_benchmark.rb
 - README
-- NEWS
+- CHANGES.txt
 - COPYING
-test_files: []
-
+homepage: http://github.com/ghostganz/madeleine
+licenses: []
+post_install_message: 
 rdoc_options: []
-
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
 requirements: []
-
-dependencies: []
-
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Madeleine is a Ruby implementation of Object Prevalence
+test_files: []

data/lib/madeleine/automatic.rb

@@ -1,429 +0,0 @@
-require 'yaml'
-require 'madeleine/zmarshal'
-require 'soap/marshal'
-
-module Madeleine
-
-# Automatic commands for Madeleine
-#
-# Author::    Stephen Sykes <sds@stephensykes.com>
-# Copyright:: Copyright (C) 2003-2006
-# Version::   0.42
-#
-# This module provides a way of automatically generating command objects for madeleine to
-# store.  It works by making a proxy object for all objects of any classes in which it is included.
-# Method calls to these objects are intercepted, and stored as a command before being
-# passed on to the real receiver.  The command objects remember which object the command was
-# destined for by using a pair of internal ids that are contained in each of the proxy objects.
-#
-# There is also a mechanism for specifying which methods not to intercept calls to by using
-# automatic_read_only, and its opposite automatic_read_write.
-#
-# Should you require it, the snapshots can be stored as yaml, and can be compressed.  Just pass 
-# the marshaller you want to use as the second argument to AutomaticSnapshotMadeleine.new.  
-# If the passed marshaller did not successfully deserialize the latest snapshot, the system 
-# will try to automatically detect and read either Marshal, YAML, SOAP, or their corresponding
-# compressed versions.
-#
-# This module is designed to work correctly in the case there are multiple madeleine systems in use by
-# a single program, and is also safe to use with threads.
-#
-# Usage:
-#
-#  require 'madeleine'
-#  require 'madeleine/automatic'
-#
-#  class A
-#    include Madeleine::Automatic::Interceptor
-#    attr_reader :foo
-#    automatic_read_only :foo
-#    def initialize(param1, ...)
-#      ...
-#    end
-#    def some_method(paramA, ...)
-#      ...
-#    end
-#    automatic_read_only
-#    def bigfoo
-#      foo.upcase
-#    end
-#  end
-#
-#  mad = AutomaticSnapshotMadeleine.new("storage_directory") { A.new(param1, ...) }
-#
-#  mad.system.some_method(paramA, ...) # logged as a command by madeleine
-#  print mad.system.foo                # not logged
-#  print mad.system.bigfoo             # not logged
-#  mad.take_snapshot
-#
-
-  module Automatic
-#
-# This module should be included (at the top) in any classes that are to be persisted.
-# It will intercept method calls and make sure they are converted into commands that are logged by Madeleine.
-# It does this by returning a Prox object that is a proxy for the real object.
-#
-# It also handles automatic_read_only and automatic_read_write, allowing user specification of which methods
-# should be made into commands
-#
-    module Interceptor
-#
-# When included, redefine new so that we can return a Prox object instead, and define methods to handle
-# keeping track of which methods are read only
-#
-      def self.included(klass)
-        class <<klass
-          alias_method :_old_new, :new
-
-          def new(*args, &block)
-            @read_only_methods ||= []
-            Prox.new(_old_new(*args, &block))
-          end
-#
-# Called when a method added - remember symbol if read only 
-# This is a good place to add in any superclass's read only methods also
-#
-          def method_added(symbol)
-            self.instance_eval {
-              @read_only_methods ||= []
-              @auto_read_only_flag ||= false
-              @read_only_methods << symbol if @auto_read_only_flag
-              c = self
-              while (c = c.superclass)
-                if (c.instance_eval {instance_variables.include? "@read_only_methods"})
-                  @read_only_methods |= c.instance_eval {@read_only_methods}
-                end
-              end
-            }
-          end
-#
-# Set the read only flag, or add read only methods
-#
-          def automatic_read_only(*list)
-            if (list == [])
-              self.instance_eval {@auto_read_only_flag = true}
-            else
-              list.each {|s| self.instance_eval {@read_only_methods ||= []; @read_only_methods << s}}
-            end
-          end
-#
-# Clear the read only flag, or remove read only methods
-#
-          def automatic_read_write(*list)
-            if (list == [])
-              self.instance_eval {@auto_read_only_flag = false}
-            else
-              list.each {|s| self.instance_eval {@read_only_methods ||= []; @read_only_methods.delete(s)}}
-            end
-          end
-
-        end
-      end
-#
-# Return the list of read only methods so Automatic_proxy#method_missing can find what to and what not to make into a command
-#
-      def read_only_methods
-        self.class.instance_eval {@read_only_methods}
-      end
-    end
-
-#
-# A Command object is automatically created for each method call to an object within the system that comes from without.
-# These objects are recorded in the log by Madeleine.
-# 
-    class Command
-      def initialize(symbol, myid, *args)
-        @symbol = symbol
-        @myid = myid
-        @args = args
-      end
-#
-# Called by madeleine when the command is done either first time, or when restoring the log
-#
-      def execute(system)
-        Thread.current[:system].myid2ref(@myid).thing.send(@symbol, *@args)
-      end
-    end
-#
-# This is a little class to pass to SnapshotMadeleine.  This is used for snapshots only. 
-# It acts as the marshaller, and just passes marshalling requests on to the user specified
-# marshaller.  This defaults to Marshal, but could be YAML or another.
-# After we have done a restore, the ObjectSpace is searched for instances of Prox to
-# add new objects to the list in AutomaticSnapshotMadeleine
-#
-    class Automatic_marshaller #:nodoc:
-      def Automatic_marshaller.load(io)
-        restored_obj = Deserialize.load(io, Thread.current[:system].marshaller)
-p restored_obj if restored_obj.class != Prox
-        ObjectSpace.each_object(Prox) {|o| Thread.current[:system].restore(o) if (o.sysid == restored_obj.sysid)}
-        restored_obj
-      end
-      def Automatic_marshaller.dump(obj, io = nil)
-        Thread.current[:system].marshaller.dump(obj, io)
-      end
-    end
-#
-# A Prox object is generated and returned by Interceptor each time a system object is created.
-#
-    class Prox #:nodoc:
-      attr_accessor :thing, :myid, :sysid
-      
-      def initialize(thing)
-        if (thing)
-          raise "App object created outside of app" unless Thread.current[:system]
-          @sysid = Thread.current[:system].sysid
-          @myid = Thread.current[:system].add(self)
-          @thing = thing
-        end
-      end
-#
-# This automatically makes and executes a new Command if a method is called from 
-# outside the system.
-#
-      def method_missing(symbol, *args, &block)
-#      print "Sending #{symbol} to #{@thing.to_s}, myid=#{@myid}, sysid=#{@sysid}\n"
-        raise NoMethodError, "Undefined method" unless @thing.respond_to?(symbol)
-        if (Thread.current[:system])
-          @thing.send(symbol, *args, &block)
-        else
-          raise "Cannot make command with block" if block_given?
-          Thread.current[:system] = AutomaticSnapshotMadeleine.systems[@sysid]
-          begin
-            if (@thing.read_only_methods.include?(symbol))
-              result = Thread.current[:system].execute_query(Command.new(symbol, @myid, *args))
-            else
-              result = Thread.current[:system].execute_command(Command.new(symbol, @myid, *args))
-            end
-          ensure
-            Thread.current[:system] = false
-          end
-          result
-        end
-      end
-#
-# Custom marshalling - this adds the internal id (myid) and the system id to a marshal
-# of the object we are the proxy for.
-# We take care to not marshal the same object twice, so circular references will work.
-# We ignore Thread.current[:system].marshaller here - this is only called by Marshal, and
-# marshal is always used for Command objects
-#
-      def _dump(depth)
-        if (Thread.current[:snapshot_memory])
-          if (Thread.current[:snapshot_memory][self])
-            [@myid.to_s, @sysid].pack("A8A30")
-          else
-            Thread.current[:snapshot_memory][self] = true
-            [@myid.to_s, @sysid].pack("A8A30") + Marshal.dump(@thing, depth)
-          end
-        else
-          [@myid.to_s, @sysid].pack("A8A30")  # never marshal a prox object in a command, just ref
-        end
-      end
-
-#
-# Custom marshalling for Marshal - restore a Prox object.
-#
-      def Prox._load(str)
-        x = Prox.new(nil)
-        a = str.unpack("A8A30a*")
-        x.myid = a[0].to_i
-        x.sysid = a[1]
-        x = Thread.current[:system].restore(x)
-        x.thing = Marshal.load(a[2]) if (a[2] > "")
-        x
-      end
-
-    end
-
-#
-# The AutomaticSnapshotMadeleine class contains an instance of the persister
-# (default is SnapshotMadeleine) and provides additional automatic functionality.
-#
-# The class is instantiated the same way as SnapshotMadeleine:
-# madeleine_sys = AutomaticSnapshotMadeleine.new("storage_directory") { A.new(param1, ...) }
-# The second initialisation parameter is the persister.  Supported persisters are:
-#
-# * Marshal  (default)
-# * YAML
-# * SOAP::Marshal
-# * Madeleine::ZMarshal.new(Marshal)
-# * Madeleine::ZMarshal.new(YAML)
-# * Madeleine::ZMarshal.new(SOAP::Marshal)
-#
-# The class keeps a record of all the systems that currently exist.
-# Each instance of the class keeps a record of Prox objects in that system by internal id (myid).
-#
-# We also add functionality to take_snapshot in order to set things up so that the custom Prox object 
-# marshalling will work correctly.
-#
-    class AutomaticSnapshotMadeleine
-      attr_accessor :marshaller
-      attr_reader :list, :sysid
-
-      def initialize(directory_name, marshaller=Marshal, persister=SnapshotMadeleine, &new_system_block)
-        @sysid ||= Time.now.to_f.to_s + Thread.current.object_id.to_s # Gererate a new sysid
-        @myid_count = 0
-        @list = {}
-        Thread.current[:system] = self # during system startup system should not create commands
-        Thread.critical = true
-        @@systems ||= {}  # holds systems by sysid
-        @@systems[@sysid] = self
-        Thread.critical = false
-        @marshaller = marshaller # until attrb
-
-        begin
-          @persister = persister.new(directory_name, Automatic_marshaller, &new_system_block)
-          @list.delete_if {|k,v|  # set all the prox objects that now exist to have the right sysid
-            begin
-              obj = ObjectSpace._id2ref(v)
-              raise unless obj.respond_to?(:sysid=)
-              obj.sysid = @sysid
-              false
-            rescue RangeError
-              true # Id was to a GC'd object, delete it
-            rescue RuntimeError
-              true # GC'd object, and id was reused for something else
-            end
-          }
-        ensure
-          Thread.current[:system] = false
-        end
-      end
-#
-# Add a proxy object to the list, return the myid for that object
-#
-      def add(proxo)  
-        @list[@myid_count += 1] = proxo.object_id
-        @myid_count
-      end
-#
-# Restore a marshalled proxy object to list - myid_count is increased as required.
-# If the object already exists in the system then the existing object must be used.
-#
-      def restore(proxo)  
-        if (@list[proxo.myid])
-          proxo = myid2ref(proxo.myid)
-        else
-          @list[proxo.myid] = proxo.object_id
-          @myid_count = proxo.myid if (@myid_count < proxo.myid)
-        end
-        proxo
-      end
-#
-# Returns a reference to the object indicated by the internal id supplied.
-#
-      def myid2ref(myid)
-        raise "Internal id #{myid} not found" unless objid = @list[myid]
-        ObjectSpace._id2ref(objid)
-      end
-#
-# Take a snapshot of the system.
-#
-      def take_snapshot
-        begin
-          Thread.current[:system] = self
-          Thread.current[:snapshot_memory] = {}
-          @persister.take_snapshot
-        ensure
-          Thread.current[:snapshot_memory] = nil
-          Thread.current[:system] = false
-        end
-      end
-#
-# Returns the hash containing the systems. 
-#
-      def AutomaticSnapshotMadeleine.systems
-        @@systems
-      end
-#
-# Close method changes the sysid for Prox objects so they can't be mistaken for real ones in a new 
-# system before GC gets them
-#
-      def close
-        begin
-          @list.each_key {|k|
-            ref = myid2ref(k)
-            ref.sysid = nil if ref.class == Prox
-          }
-        rescue RangeError
-          # do nothing
-        end
-        @persister.close
-      end
-
-#
-# Pass on any other calls to the persister
-#
-      def method_missing(symbol, *args, &block)
-        @persister.send(symbol, *args, &block)
-      end
-    end
-
-
-    module Deserialize #:nodoc:
-#
-# Detect format of an io stream. Leave it rewound.
-#
-      def Deserialize.detect(io)
-        c = io.getc
-        c1 = io.getc
-        io.rewind
-        if (c == Marshal::MAJOR_VERSION && c1 <= Marshal::MINOR_VERSION)
-          Marshal
-        elsif (c == 31 && c1 == 139) # gzip magic numbers
-          ZMarshal
-        else
-          while (s = io.gets)
-            break if (s !~ /^\s*$/) # ignore blank lines
-          end
-          io.rewind
-          if (s && s =~ /^\s*<\?[xX][mM][lL]/) # "<?xml" begins an xml serialization
-            SOAP::Marshal
-          else
-            while (s = io.gets)
-              break if (s !~ /^\s*#/ && s !~ /^\s*$/) # ignore blank and comment lines
-            end
-            io.rewind
-            if (s && s =~ /^\s*---/) # "---" is the yaml header
-              YAML
-            else
-              nil # failed to detect
-            end
-          end
-        end
-      end
-#
-# Try to deserialize object.  If there was an error, try to detect marshal format, 
-# and return deserialized object using the right marshaller
-# If detection didn't work, raise up the exception
-#
-      def Deserialize.load(io, marshaller=Marshal)
-        begin
-          raise "Must detect with YAML" if marshaller == YAML
-          marshaller.load(io)
-        rescue Exception => e
-          io.rewind
-          detected_marshaller = detect(io)
-          if (detected_marshaller == ZMarshal)
-            zio = Zlib::GzipReader.new(io)
-            detected_zmarshaller = detect(zio)
-            zio.finish
-            io.rewind
-            if (detected_zmarshaller)
-              ZMarshal.new(detected_zmarshaller).load(io)
-            else
-              raise e
-            end
-          elsif (detected_marshaller)
-            detected_marshaller.load(io)
-          else
-            raise e
-          end
-        end
-      end
-    end
-
-  end
-end
-
-AutomaticSnapshotMadeleine = Madeleine::Automatic::AutomaticSnapshotMadeleine