madeleine 0.7.1

data/COPYING

@@ -0,0 +1,31 @@
+
+    Copyright (c) 2003-2004, Anders Bengtsson
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+ 
+      1. Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+ 
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in the
+         documentation and/or other materials provided with the distribution.
+ 
+      3. The names of its contributors may not be used to endorse or promote
+         products derived from this software without specific prior written
+         permission.
+ 
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+    CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+    TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+    ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.

data/NEWS

@@ -0,0 +1,55 @@
+
+Madeleine 0.7.1 (August 22, 2004):
+
+    * ZMarshal changed to work around Zlib bug.
+    * automatic_read_only fixed when intercepted class is inherited from
+
+Madeleine 0.7 (July 23, 2004):
+
+    * Broken clock unit test on win32 fixed.
+    * AutomaticSnapshotMadeleine detects snapshot format on recovery
+    * Snapshot compression with Madeleine::ZMarshal
+    * YAML snapshots supported for automatic commands
+    * SOAP snapshots supported for automatic commands
+    * Read-only methods for automatic commands
+
+Madeleine 0.6.1 (March 30, 2004):
+
+    * Bug fix: Use binary mode for I/O, fixes log replay
+      on mswin32 port of Ruby (Patch from Martin Tampe)
+
+Madeleine 0.6 (March 28, 2004):
+
+    * Changed license to BSD
+    * Added a RubyGem specification
+    * Re-designed initialization (but still backward-compatible)
+    * Bug fix: Fixed use of finalized object's id in AutomaticSnapshotMadeleine
+
+Madeleine 0.5 (August 31, 2003):
+
+    * Bug fix: Log order on recovery was wrong on some platforms
+      (Reported by IIMA Susumu)
+    * No longer requires the system clock to always increase
+    * Shared locks for queries
+
+Madeleine 0.4 (July 4, 2003):
+
+    * Deprecated ClockedSnapshotMadeleine
+    * Added execute_query()
+    * API documentation in RDoc format
+
+Madeleine 0.3 (May 15, 2003):
+
+    * Automatic commands
+    * Some classes exported to the default module
+    * Clock support not loaded by default (require 'madeleine/clock')
+    * Bug fix: Error handling when replaying logged commands.
+    * New system through block instead of argument (API change)
+    * Works in $SAFE = 1
+
+Madeleine 0.2:
+
+    * Supports custom marshalling implementations.
+    * Changed interface for ClockedSystem and Clock.
+    * Some documentation added, including API docs.
+

data/README

@@ -0,0 +1,78 @@
+
+Madeleine is a Ruby implementation of Object Prevalence: Transparent
+persistence of business objects using command logging and complete
+system snapshots.
+
+<http://madeleine.sourceforge.net/>
+
+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:
+
+    require 'madeleine'
+
+    # Create an application as a prevalent system
+
+    madeleine = SnapshotMadeleine.new("my_example_storage") {
+      SomeExampleApplication.new()
+    }
+
+    # Do modifications of the system by sending commands through
+    # the Madeleine instance. A command is an object with a suitable
+    # "execute(system)" method.
+
+    madeleine.execute_command(command)
+
+
+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.
+
+Contact:
+
+    Homepage:
+    <http://madeleine.sourceforge.net/>
+
+    Questions, bug reports, patches, complaints? Use the mailing list:
+    <http://lists.sourceforge.net/lists/listinfo/madeleine-devel>
+
+License:
+
+    BSD (see the file COPYING)
+
+Credits:
+
+    Anders Bengtsson   -   Prevalence core impl.
+    Stephen Sykes      -   Automatic commands impl.
+
+    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
+
+    Thanks to Klaus Wuestefeld and the Prevayler developers for the
+    model of this software; to Minero Aoki for the installer; to Matz and
+    the core developers for the Ruby language!
+

data/contrib/batched.rb

@@ -0,0 +1,298 @@
+# Batched writes for Madeleine
+#
+# 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.
+#
+# Writes are batched for a specified amount of time, before written to disk and
+# then executed.
+#
+# For a detailed discussion about the problem, see
+#  http://www.prevayler.org/wiki.jsp?topic=OvercomingTheWriteBottleneck
+#
+#
+# Usage is identical to normal SnapshotMadeleine, and it can also be used as
+# persister for AutomaticSnapshotMadeleine. (One difference: the log isn't 
+# visible on disk until any commands are executed.)
+#
+# You can also use the execute_query method for shared synchronzied queries,
+# for eaay coarse-grained locking of the system.
+#
+# The exclusive lock is only locked during the actual execution of commands and
+# while closing.
+#
+# Keeping both log writes and executes of commands in the originating thread 
+# is needed by AutomaticSnapshotPrevayler. Hence the strange SimplisticPipe
+# class.
+#
+# Todo: 
+#    - It seems like Sync (sync.rb) prefers shared locks. This should probably
+#       be changed.
+#
+#
+# Madeleine - Ruby Object Prevalence
+#
+# Copyright(c) Anders Bengtsson 2003
+#
+
+require 'madeleine'
+require 'madeleine/clock'
+
+include Madeleine::Clock
+
+module Madeleine
+  module Batch
+    class BatchedSnapshotMadeleine < SnapshotMadeleine
+
+      def initialize(directory_name, marshaller=Marshal, &new_system_block)
+        super(directory_name, marshaller, &new_system_block)
+        @log_actor = LogActor.launch(self)
+      end
+
+      def execute_command(command)
+        verify_command_sane(command)
+        queued_command = QueuedCommand.new(command)
+        @lock.synchronize(:SH) do
+          raise "closed" if @closed
+          @logger.store(queued_command)
+        end
+        queued_command.wait_for
+      end
+
+      def execute_query(query)
+        verify_command_sane(query)
+        @lock.synchronize(:SH) do
+          execute_without_storing(query)
+        end
+      end
+
+      def close
+        @log_actor.destroy
+        @lock.synchronize do
+          @logger.close
+          @closed = true
+        end
+      end
+
+      def flush
+        @lock.synchronize do
+          @logger.flush
+        end
+      end
+
+      def take_snapshot
+        @lock.synchronize(:SH) do
+          @lock.synchronize do
+            @logger.close
+          end
+          Snapshot.new(@directory_name, system, @marshaller).take
+          @logger.reset
+        end
+      end
+
+      private
+
+      def create_lock
+        Sync.new
+      end
+
+      def create_logger(directory_name, log_factory)
+        BatchedLogger.new(directory_name, log_factory, self.system)
+      end
+
+      def log_factory
+        BatchedLogFactory.new
+      end
+    end
+
+    private
+
+    class LogActor
+      def self.launch(madeleine, delay=0.01)
+        result = new(madeleine, delay)
+        result
+      end
+
+      def destroy
+        @is_destroyed = true
+        if @thread.alive?
+          @thread.wakeup
+          @thread.join
+        end
+      end
+
+      private
+
+      def initialize(madeleine, delay)
+        @is_destroyed = false
+
+        madeleine.flush
+        @thread = Thread.new {
+          until @is_destroyed
+            sleep(delay)
+            madeleine.flush
+          end
+        }
+      end
+    end
+
+    class BatchedLogFactory
+      def create_log(directory_name)
+        BatchedLog.new(directory_name)
+      end
+    end
+
+    class BatchedLogger < Logger
+      def initialize(directory_name, log_factory, system)
+        super(directory_name, log_factory)
+        @buffer = []
+        @system = system
+      end
+
+      def store(queued_command)
+        @buffer << queued_command
+      end
+
+      def close
+        return if @log.nil?
+        flush
+        @log.close
+        @log = nil
+      end
+
+      def flush
+        return if @buffer.empty?
+
+        open_new_log if @log.nil?
+
+        if @system.kind_of?(ClockedSystem)
+          @buffer.unshift(QueuedTick.new)
+        end
+
+        @buffer.each do |queued_command|
+          queued_command.store(@log)
+        end
+
+        @log.flush
+
+        @buffer.each do |queued_command|
+          queued_command.execute(@system)
+        end
+
+        @buffer.clear
+      end
+    end
+
+    class BatchedLog < CommandLog
+      def store(command)
+        Marshal.dump(command, @file)
+      end
+
+      def flush
+        @file.flush
+        @file.fsync
+      end
+    end
+
+    class QueuedCommand
+      def initialize(command)
+        @command = command
+        @pipe = SimplisticPipe.new
+      end
+
+      def store(log)
+        @pipe.write(log)
+      end
+
+      def execute(system)
+        @pipe.write(system)
+      end
+
+      def wait_for
+        @pipe.read do |log|
+          log.store(@command)
+        end
+
+        @pipe.read do |system|          
+          return @command.execute(system)
+        end
+      end
+    end
+
+    class QueuedTick
+      def initialize
+        @tick = Tick.new(Time.now)
+      end
+
+      def store(log)
+        log.store(@tick)
+      end
+
+      def execute(system)
+        @tick.execute(system)
+      end
+    end
+
+    class SimplisticPipe
+      def initialize 
+        @receive_lock = Mutex.new.lock
+        @consume_lock = Mutex.new.lock
+        @message = nil
+      end
+
+      def read
+        begin
+          wait_for_message_received
+
+          if block_given?
+            yield @message
+          else
+            return @message
+          end
+
+        ensure
+          message_consumed
+        end
+      end
+
+      def write(message)
+        raise WriteBlockedException unless can_write?
+
+        @message = message
+        message_received
+        wait_for_message_consumed
+        @message = nil
+      end
+
+      def can_write?
+        @message.nil?
+      end
+
+      private
+ 
+      def message_received
+        @receive_lock.unlock
+      end
+
+      def wait_for_message_received
+        @receive_lock.lock
+      end
+
+      def message_consumed
+        @consume_lock.unlock
+      end
+
+      def wait_for_message_consumed
+        @consume_lock.lock
+      end
+    end
+
+    class WriteBlockedException < Exception
+    end
+  end
+end
+
+BatchedSnapshotMadeleine = Madeleine::Batch::BatchedSnapshotMadeleine