madeleine 0.7.1

data/lib/madeleine/files.rb

@@ -0,0 +1,19 @@
+#
+# Wrapper for Ruby's file services, replaced during testing
+# so we can run tests without touching a real filesystem.
+#
+
+class FileService
+
+  def open(*args)
+    super(*args)
+  end
+
+  def exist?(name)
+    File.exist?(name)
+  end
+
+  def dir_entries(name)
+    Dir.entries(name)
+  end
+end

data/lib/madeleine/zmarshal.rb

@@ -0,0 +1,60 @@
+#
+# Author::    Anders Bengtsson <ndrsbngtssn@yahoo.se>
+# Copyright:: Copyright (c) 2004
+#
+
+require 'zlib'
+
+module Madeleine
+  #
+  # Snapshot marshaller for compressed snapshots.
+  #
+  # Compresses the snapshots created by another marshaller. Uses either
+  # Marshal (the default) or another supplied marshaller.
+  #
+  # 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.
+  #
+  # Usage:
+  #
+  #  require 'madeleine'
+  #  require 'madeleine/zmarshal'
+  #
+  #  marshaller = Madeleine::ZMarshal.new(YAML)
+  #  madeleine = SnapshotMadeleine.new("my_example_storage", marshaller) {
+  #    SomeExampleApplication.new()
+  #  }
+  #
+  class ZMarshal
+
+    def initialize(marshaller=Marshal)
+      @marshaller = marshaller
+    end
+
+    def load(stream)
+      zstream = Zlib::GzipReader.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)
+      ensure
+        zstream.finish
+      end
+    end
+
+    def dump(system, stream)
+      zstream = Zlib::GzipWriter.new(stream)
+      begin
+        @marshaller.dump(system, zstream)
+      ensure
+        zstream.finish
+      end
+      nil
+    end
+  end
+end

data/samples/clock_click.rb

@@ -0,0 +1,73 @@
+#
+# Simple example of using time with Madeleine.
+#
+
+$LOAD_PATH.unshift(".." + File::SEPARATOR + "lib")
+
+require 'madeleine/clock'
+require 'tk'
+
+# The Clicker keeps track of when it was last clicked.
+#
+# To access the time it extends ClockedSystem, which provides
+# it with the 'clock' attribute.
+#
+class Clicker
+  include Madeleine::Clock::ClockedSystem
+
+  def initialize
+    @last_clicked = nil
+  end
+
+  def click
+    @last_clicked = clock.time
+  end
+
+  def last_clicked
+    return '-' if @last_clicked.nil?
+    @last_clicked.to_s
+  end
+end
+
+# A command to update the Clicker with.
+#
+class Click
+  def execute(system)
+    system.click
+  end
+end
+
+# Launch a ClockedSnapshotMadeleine.
+#
+# ClockedSnapshotMadeleine works like the regular SnapshotMadeleine, but
+# optimizes away redundant commands from TimeActor.
+#
+madeleine = ClockedSnapshotMadeleine.new("clock-demo") { Clicker.new }
+
+# Launch the TimeActor.
+#
+# This provides time commands, without which the system's time would stand still.
+#
+Madeleine::Clock::TimeActor.launch(madeleine)
+
+clicker = madeleine.system
+
+# The GUI
+
+root = TkRoot.new() { title "Madeleine Clock Example" }
+label = TkLabel.new(root) {
+  text "Last clicked " + clicker.last_clicked
+  width 40
+  pack
+}
+button = TkButton.new(root) {
+  text 'Click'
+  command proc {
+    madeleine.execute_command(Click.new)
+    label.text("Last clicked " + clicker.last_clicked)
+  }
+  pack
+}
+
+Tk.mainloop
+

data/samples/dictionary_client.rb

@@ -0,0 +1,23 @@
+#
+# Dictionary client
+#
+# See dictionary_server.rb for details
+#
+
+require 'drb'
+
+DRb.start_service
+dictionary = DRbObject.new(nil, "druby://localhost:1234")
+
+if ARGV.length == 1
+  puts dictionary.lookup(ARGV[0])
+elsif ARGV.length == 2
+  dictionary.add(ARGV[0], ARGV[1])
+  puts "Stored"
+else
+  puts "Usage: dictionary_client <key> [<value>]"
+end
+
+
+  
+

data/samples/dictionary_server.rb

@@ -0,0 +1,94 @@
+#
+# A dictionary server using Distributed Ruby (DRb).
+#
+# All modifications to the dictionary are done as commands,
+# while read-only queries (i.e 'lookup') are done directly.
+#
+# First launch this server in the background, then use
+# dictionary_client.rb to look up and add items to the
+# dictionary.
+# You can kill the server at any time. The contents of the
+# dictionary will still be there when you restart it.
+#
+# DRb is available at http://raa.ruby-lang.org/list.rhtml?name=druby
+#
+
+$LOAD_PATH.unshift(".." + File::SEPARATOR + "lib")
+require 'madeleine'
+
+require 'drb'
+
+
+class Dictionary
+  def initialize
+    @data = {}
+  end
+
+  def add(key, value)
+    @data[key] = value
+  end
+
+  def lookup(key)
+    @data[key]
+  end
+end
+
+
+class Addition
+  def initialize(key, value)
+    @key, @value = key, value
+  end
+
+  def execute(system)
+    system.add(@key, @value)
+  end
+end
+
+
+class Lookup
+  def initialize(key)
+    @key = key
+  end
+
+  def execute(system)
+    system.lookup(@key)
+  end
+end
+
+
+class DictionaryServer
+
+  def initialize(madeleine)
+    @madeleine = madeleine
+    @dictionary = madeleine.system
+  end
+
+  def add(key, value)
+    # When adding a new key-value pair we modify the system, so
+    # this operation has to be done through a command.
+    @madeleine.execute_command(Addition.new(key, value))
+  end
+
+  def lookup(key)
+    # A lookup is a read-only operation, so we can do it as a non-logged
+    # query. If we weren't worried about concurrency problems we could
+    # have just called @dictionary.lookup(key) directly instead.
+    @madeleine.execute_query(Lookup.new(key))
+  end
+end
+
+
+madeleine = SnapshotMadeleine.new("dictionary-base") { Dictionary.new }
+
+Thread.new(madeleine) {
+  puts "Taking snapshot every 30 seconds."
+  while true
+    sleep(30)
+    madeleine.take_snapshot
+  end
+}
+
+DRb.start_service("druby://localhost:1234",
+                  DictionaryServer.new(madeleine))
+DRb.thread.join
+

data/samples/painter.rb

@@ -0,0 +1,60 @@
+#
+# Simple drawing program to show Madeleine's logging feature.
+#
+# When you restart the program, your old artwork is still there.
+#
+# (Note: The GUI components used here aren't marshal-able,
+# so in a real app you would have to do custom marshaling for
+# the Painter class to get working snapshots. Then again, in a real
+# app you wouldn't use the GUI components to hold the app's data,
+# would you?)
+#
+
+$LOAD_PATH.unshift(".." + File::SEPARATOR + "lib")
+
+require 'madeleine'
+
+require 'tkclass'
+
+class Painter
+
+  def initialize(canvas)
+    @canvas = canvas
+  end
+
+  def draw(x, y)
+    line = Line.new(@canvas, x, y, x + 1, y + 1)
+    line.fill('black')
+  end
+end
+
+class PaintCommand
+
+  def initialize(x, y)
+    @x, @y = x, y
+  end
+
+  def execute(system)
+    system.draw(@x, @y)
+  end
+end
+
+root = TkRoot.new() { title "Madeleine Painter" }
+canvas = Canvas.new(root)
+canvas.pack
+
+$madeleine = Madeleine::SnapshotMadeleine.new("painter-demo") { Painter.new(canvas) }
+
+canvas.bind("1",
+            proc {|x, y|
+              $madeleine.execute_command(PaintCommand.new(x, y))
+            },
+            "%x %y")
+canvas.bind("B1-Motion",
+            proc {|x, y|
+              $madeleine.execute_command(PaintCommand.new(x, y))
+            },
+            "%x %y")
+
+Tk.mainloop
+

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.4
+specification_version: 1
+name: madeleine
+version: !ruby/object:Gem::Version 
+  version: 0.7.1
+date: 2005-01-06
+summary: Madeleine is a Ruby implementation of Object Prevalence
+require_paths: 
+  - lib
+email: ndrsbngtssn@yahoo.se
+homepage: http://madeleine.sourceforge.net
+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: 
+platform: ruby
+authors: 
+  - Anders Bengtsson
+files: 
+  - lib/madeleine.rb
+  - lib/madeleine/automatic.rb
+  - lib/madeleine/clock.rb
+  - lib/madeleine/files.rb
+  - lib/madeleine/zmarshal.rb
+  - samples/clock_click.rb
+  - samples/dictionary_client.rb
+  - samples/dictionary_server.rb
+  - samples/painter.rb
+  - contrib/batched.rb
+  - contrib/benchmark.rb
+  - contrib/test_batched.rb
+  - contrib/test_scalability.rb
+  - contrib/threaded_benchmark.rb
+  - README
+  - NEWS
+  - COPYING
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []