mikka 1.1.1-java → 2.0.0.pre0-java

data/.rvmrc

@@ -1 +1 @@
-rvm --create use jruby-1.6.5@mikka
+rvm --create use jruby-1.6.7@mikka

data/Gemfile

@@ -1,3 +1,7 @@
 source :rubygems
 
 gemspec
+
+group :test do
+  gem 'rspec'
+end

data/README.mdown

@@ -2,6 +2,8 @@
 
 Mikka is a thin Ruby wrapper around Akka. It makes Akka's Java API more pleasing to the Rubyist's eye.
 
+It uses Akka 1.2, but there are plans to create an Akka 2.0 version as soon as possible. Follow the 2.0 development in the [`mikka-2.0` branch](https://github.com/iconara/mikka/tree/mikka-2.0).
+
 ## Work in progress
 
 Mikka is a work in progress, but currently used in production. It currently mostly scratches my own itchs, but improvement suggestions and patches are welcome. 
@@ -12,9 +14,9 @@ If you make something that can serve as a useful illustration of some concept, p
 
 ## Requirements
 
-Only tested in JRuby 1.6.3 and Ruby 1.9 mode (add `jruby --1.9` or set `JRUBY_OPTS='--1.9`).
+Tested in JRuby 1.6.5+ and Ruby 1.9 mode (run with `jruby --1.9` or set `JRUBY_OPTS='--1.9`).
 
-The required Akka and Scala JARs are loaded from the [akka-actor-jars](https://rubygems.org/gems/akka-actor-jars) and [scala-library-jars](https://rubygems.org/gems/scala-library-jars) wrapper gems.
+The required Akka and Scala JARs are loaded from the [akka-actor-jars](https://rubygems.org/gems/akka-actor-jars), [akka-remote-jars](https://rubygems.org/gems/akka-remote-jars) and [scala-library-jars](https://rubygems.org/gems/scala-library-jars) wrapper gems.
 
 ## Installation
 
@@ -23,10 +25,11 @@ The required Akka and Scala JARs are loaded from the [akka-actor-jars](https://r
 ## Contributors
 
 Theo Hultberg, [@iconara](http://twitter.com/iconara)
+Daniel Gaiottino, [@bantai](http://twitter.com/bantai)
 
 ## License
 
-Mikka is licensed under the Apache 2 license, the same as Akka. See http://akka.io/docs/akka/1.1.2/project/licenses.html
+Mikka is licensed under the Apache 2 license, the same as Akka. See http://akka.io/docs/akka/1.2/project/licenses.html
 
 ## Mikka?
 

data/lib/akka.rb

@@ -2,30 +2,23 @@
 
 require 'java'
 require 'akka-actor-jars'
-require 'akka-remote-jars'
 
 
 module Akka
-  import 'akka.actor.Actors'
-  
   module Actor
-    include_package 'akka.actor'
-
-    import 'akka.actor.ActorRef'
-    import 'akka.actor.UntypedActor'
-
-    class UntypedActor
-      def self.create(*args)
-        new(*args)
-      end
-    end
+    java_import 'akka.actor.ActorSystem'
+    java_import 'akka.actor.ActorRef'
+    java_import 'akka.actor.UntypedActor'
+    java_import 'akka.actor.Props'
+    java_import 'akka.actor.Terminated'
   end
-  
-  module Config
-    include_package 'akka.config'
+
+  module Dispatch
+    java_import 'akka.dispatch.Await'
   end
-  
-  module Routing
-    include_package 'akka.routing'
+
+  module Util
+    java_import 'akka.util.Duration'
+    java_import 'akka.util.Timeout'
   end
 end

data/lib/mikka.rb

@@ -1,192 +1,122 @@
 # encoding: utf-8
 
-require 'java'
 require 'akka'
 
 
 module Mikka
-  import java.util.Arrays
-  
-  def self.actor_of(*args, &block)
-    Akka::Actor::Actors.actor_of(*args, &block)
+  def self.create_actor_system(*args)
+    Akka::Actor::ActorSystem.create(*args)
   end
-  
-  def self.actor(&block)
-    Akka::Actor::Actors.actor_of { ProcActor.new(&block) }
+
+  def self.await_result(future, options={})
+    Akka::Dispatch::Await.result(future, Duration[options[:timeout]])
   end
   
-  def self.registry
-    Akka::Actor::Actors.registry
+  def self.current_actor=(actor)
+    Thread.current[:mikka_current_actor] = actor
   end
   
   def self.current_actor
     Thread.current[:mikka_current_actor]
   end
   
-  module Messages
-    def self.broadcast(message)
-      Akka::Routing::Routing::Broadcast.new(message)
-    end
-  
-    def self.poison_pill
-      Akka::Actor::Actors.poison_pill
-    end
+  def self.capture_current_actor(ref)
+    self.current_actor = ref
+    yield
+  ensure
+    self.current_actor = nil
   end
   
-  module Remote
-    DEFAULT_HOST = 'localhost'
-    DEFAULT_PORT = 2552
-    
-    def self.start(options=nil)
-      if options
-      then remote_support.start(options.fetch(:host, DEFAULT_HOST), options.fetch(:port, DEFAULT_PORT))
-      else remote_support.start
-      end
+  ActorRef = Akka::Actor::ActorRef
+  Props = Akka::Actor::Props
+  Duration = Akka::Util::Duration
+  Timeout = Akka::Util::Timeout
+  Terminated = Akka::Actor::Terminated
+
+  class Props
+    def self.[](*args, &block)
+      options = args.last.is_a?(Hash) && args.pop
+      creator = ((args.first.is_a?(Proc) || args.first.is_a?(Class)) && args.first) || (options && options[:creator]) || block
+      raise ArgumentError, %(No creator specified) unless creator
+      props = new
+      props = props.with_creator(creator)
+      props
     end
-    
-    def self.actor_for(id, options={})
-      remote_support.actor_for(id, options.fetch(:host, DEFAULT_HOST), options.fetch(:port, DEFAULT_PORT))
+
+    class << self
+      alias_method :create, :[]
     end
-    
-  private
-    def self.remote_support
-      Akka::Actors.remote
+  end
+
+  class Duration
+    def self.[](*args)
+      Akka::Util::Duration.apply(*args)
     end
   end
-  
+
+  class ActorRef
+    def <<(msg)
+      tell(msg, Mikka.current_actor)
+    end
+  end
+
   module RubyesqueActorCallbacks
     def receive(message); end
     def pre_start; end
     def post_stop; end
     def pre_restart(reason); end
     def post_restart(reason); end
-    
+
     def onReceive(message); receive(message); end
     def preStart; super; pre_start; end
     def postStop; super; post_stop; end
     def preRestart(reason); super; pre_restart(reason); end
     def postRestart(reason); super; post_restart(reason); end
   end
-  
+
   module ImplicitSender
     def onReceive(*args)
-      capture_current_actor { super }
+      Mikka.capture_current_actor(get_self) { super }
     end
     
     def preStart(*args)
-      capture_current_actor { super }
+      Mikka.capture_current_actor(get_self) { super }
     end
     
     def postStop(*args)
-      capture_current_actor { super }
+      Mikka.capture_current_actor(get_self) { super }
     end
     
     def preRestart(*args)
-      capture_current_actor { super }
+      Mikka.capture_current_actor(get_self) { super }
     end
     
     def postRestart(*args)
-      capture_current_actor { super }
-    end
-    
-  private
-    
-    def capture_current_actor
-      Thread.current[:mikka_current_actor] = context
-      yield
-    ensure
-      Thread.current[:mikka_current_actor] = nil
-    end
+      Mikka.capture_current_actor(get_self) { super }
+    end    
   end
-  
-  module SupervisionDsl
-    module ClassMethods
-      def fault_handling(config)
-        trap = config[:trap].map { |e| e.java_class }
-        max_retries = config.fetch(:max_retries, 5)
-        time_range = config.fetch(:time_range, 5000)
-        case config[:strategy]
-        when :all_for_one
-          @fault_handling_strategy = Akka::Config::Supervision::AllForOneStrategy.new(trap, max_retries, time_range)
-        when :one_for_one
-          @fault_handling_strategy = Akka::Config::Supervision::OneForOneStrategy.new(trap, max_retries, time_range)
-        else
-          raise ArgumentError, 'strategy must be one of :all_for_one or :one_for_one'
-        end
-      end
-    
-      def registered_fault_handling_strategy
-        @fault_handling_strategy
-      end
-    
-      def life_cycle(type)
-        @life_cycle = begin
-          case type
-          when :permanent then Akka::Config::Supervision.permanent
-          when :temporary then Akka::Config::Supervision.temporary
-          when :undefined then Akka::Config::Supervision.undefined_life_cycle
-          else raise ArgumentError, 'type must be one of :permanent, :temporary or :undefined'
-          end
-        end
-      end
-    
-      def registered_life_cycle
-        @life_cycle
-      end
-    end
-    
-    module InstanceMethods
-      def initialize(*args)
-        super
-        if self.class.registered_fault_handling_strategy
-          context.fault_handler = self.class.registered_fault_handling_strategy
-        end
-        if self.class.registered_life_cycle
-          context.life_cycle = self.class.registered_life_cycle
-        end
-      end
-    end
-    
-    def self.included(m)
-      m.extend(ClassMethods)
-      m.include(InstanceMethods)
-    end
-  end
-  
+
   class Actor < Akka::Actor::UntypedActor
-    include SupervisionDsl
     include RubyesqueActorCallbacks
     include ImplicitSender
+    
+    class << self
+      alias_method :apply, :new
+      alias_method :create, :new
+    end
   end
-  
-  class ProcActor < Actor
-    def initialize(&receive)
-      define_singleton_method(:receive, receive)
+
+  module PropsConstructor
+    def Props(&block)
+      Props.create(&block)
     end
   end
   
-  def self.load_balancer(options={})
-    actors = options[:actors]
-    unless actors
-      type = options[:type]
-      count = options[:count]
-      raise ArgumentError, "Either :actors or :type and :count must be specified" unless type && count
-      actors = (0...count).map { actor_of(type) }
-    end
-    actors.each { |a| a.start }
-    actor_list = Arrays.as_list(actors.to_java)
-    actor_seq = Akka::Routing::CyclicIterator.new(actor_list)
-    actor_factory = proc { actor_seq }.to_function
-    Akka::Routing::Routing.load_balancer_actor(actor_factory)
+  module Useful
+    include PropsConstructor
+    extend PropsConstructor
+
+    Props = ::Mikka::Props
   end
 end
 
-module Akka
-  module Actor
-    module ActorRef
-      def <<(message)
-        send_one_way(message, Mikka.current_actor)
-      end
-    end
-  end
-end

data/lib/mikka/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Mikka
-  VERSION = '1.1.1'
+  VERSION = '2.0.0.pre0'
 end

data/mikka.gemspec

@@ -9,16 +9,15 @@ Gem::Specification.new do |s|
   s.name        = 'mikka'
   s.version     = Mikka::VERSION
   s.platform    = 'java'
-  s.authors     = ['Theo Hultberg']
-  s.email       = ['theo@iconara.net']
+  s.authors     = ['Theo Hultberg', 'Daniel Gaiottino']
+  s.email       = ['theo@iconara.net', 'daniel.gaiottino@gmail.com']
   s.homepage    = 'http://github.com/iconara/mikka'
   s.summary     = %q{Mikka is a JRuby wrapper for Akka}
   s.description = %q{Mikka adapts Akka's Java API to fit better with Ruby}
 
   s.rubyforge_project = 'mikka'
   
-  s.add_dependency 'akka-actor-jars', '~> 1.2.0'
-  s.add_dependency 'akka-remote-jars', '~> 1.2.0'
+  s.add_dependency 'akka-actor-jars', '~> 2.0.2'
 
   s.files         = `git ls-files`.split("\n")
   # s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/mikka_spec.rb

@@ -0,0 +1,49 @@
+require_relative 'spec_helper'
+
+
+module Mikka
+  class TestActor < Mikka::Actor
+    def receive(msg)
+      sender << msg
+    end
+  end
+
+  describe 'actor creation' do
+    before do
+      @system = Mikka.create_actor_system('testsystem')
+    end
+
+    after do
+      @system.shutdown
+    end
+
+    it 'creates an actor from a class' do
+      actor_props = Props[TestActor]
+      actor = @system.actor_of(actor_props, 'some_actor')
+      actor.should be_a(ActorRef)
+    end
+
+    it 'creates an actor from a factory proc' do
+      actor_props = Props[:creator => proc { TestActor.new }]
+      actor = @system.actor_of(actor_props, 'some_actor')
+      actor.should be_a(ActorRef)
+    end
+
+    it 'creates an actor from a factory block' do
+      actor_props = Props.create { TestActor.new }
+      actor = @system.actor_of(actor_props, 'some_actor')
+      actor.should be_a(ActorRef)
+    end
+
+    it 'creates an actor from a factory block passed to the Props function' do
+      actor_props = Useful.Props { TestActor.new }
+      actor = @system.actor_of(actor_props, 'some_actor')
+      actor.should be_a(ActorRef)
+    end
+
+    # future = actor.ask(:hi, 1000)
+    # reply = Mikka.await_result(future, :timeout => '1000ms')
+    # reply.should == :hi
+    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'mikka'

metadata

@@ -1,41 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: mikka
 version: !ruby/object:Gem::Version
-  prerelease:
-  version: 1.1.1
+  prerelease: 6
+  version: 2.0.0.pre0
 platform: java
 authors:
 - Theo Hultberg
+- Daniel Gaiottino
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2011-10-25 00:00:00.000000000Z
+date: 2012-08-07 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: akka-actor-jars
-  version_requirements: &2056 !ruby/object:Gem::Requirement
+  version_requirements: &2058 !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 2.0.2
     none: false
-  requirement: *2056
-  prerelease: false
-  type: :runtime
-- !ruby/object:Gem::Dependency
-  name: akka-remote-jars
-  version_requirements: &2074 !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-    none: false
-  requirement: *2074
+  requirement: *2058
   prerelease: false
   type: :runtime
 description: Mikka adapts Akka's Java API to fit better with Ruby
 email:
 - theo@iconara.net
+- daniel.gaiottino@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -45,17 +36,12 @@ files:
 - Gemfile
 - README.mdown
 - Rakefile
-- examples/hello_world.rb
-- examples/load_balancing1.rb
-- examples/load_balancing2.rb
-- examples/proc_example.rb
-- examples/remoting.rb
-- examples/simple_example.rb
-- examples/supervision1.rb
 - lib/akka.rb
 - lib/mikka.rb
 - lib/mikka/version.rb
 - mikka.gemspec
+- spec/mikka_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/iconara/mikka
 licenses: []
 post_install_message:
@@ -70,13 +56,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
   none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
   none: false
 requirements: []
 rubyforge_project: mikka
-rubygems_version: 1.8.9
+rubygems_version: 1.8.15
 signing_key:
 specification_version: 3
 summary: Mikka is a JRuby wrapper for Akka

data/examples/hello_world.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../lib', __FILE__)
-
-require 'bundler/setup'
-require 'mikka'
-
-# 0.
-# The numbers at the top of the comment blocks follow the flow of the 
-# application, read them in order to see the sequence of events.
-
-# 1.
-# The simplest way to create an actor is to do it with a block. The block
-# will receive each message and execute in the scope of an actor object (so
-# `context` will be available -- more on that later).
-#
-# The variable `phil` will not refer directly to an actor instance, but to an
-# `ActorRef`. There are many reasons for this, and for the full picture refer
-# to the Akka documentation. The short explanation is that it makes it 
-# possible to restart and replace the actor without the clients knowing that
-# the actor instance was changed, and it makes remote actors transparent.
-phil = Mikka.actor do |msg|
-  # 8. 
-  # Ruby doesn't have pattern matching, but `case` is usually enough. If you
-  # Have separate classes for your messages you can match on class.
-  case msg
-  when Introduction
-    # 9.
-    # The `Introduction` class has a field called `to_whom` that contains a
-    # reference to an actor that someone want to introduce us to. Let's send
-    # that actor a `Greeting`. 
-    msg.to_whom << Greeting.new('Hello, dear sir.')
-  when Greeting
-    puts "Received greeting: #{msg.body}"
-    # 12.
-    # The reply got routed back to this actor. Now we want to shut down this
-    # actor too, so that the application can shut down.
-    context.exit
-  end
-end
-
-# 2.
-# If you need more control over your actor's life cycle, or want to create
-# more than one of the same you can can declare a subclass of Mikka::Actor.
-# The #receive method is called for each message the actor receives. You can
-# do things when the actor starts by implementing #pre_start, and when the 
-# actor stops by implementing #post_stop.
-#
-# Don't create instances of this class yourself, an error will be raised if
-# it's done in the wrong way, see below for how it's supposed to be done.
-class Replier < Mikka::Actor
-  def receive(msg)
-    case msg
-    when Greeting
-      puts "Received greeting: #{msg.body}"
-      # 10.
-      # To reply to a message without having to explicitly refer to the sender
-      # use #reply (you can, however, store the sender and reply later if you
-      # want, it is available through `context.sender.get`).
-      #
-      # A word of caution: the sender is not always set, for example when the
-      # message was sent from a non-actor context like in 6. Also, the Scala 
-      # API sets the sender implicitly in a way that is not possible in Java 
-      # or Ruby, and even if Mikka does it's best to emulate the Scala way,
-      # it's not foolproof. If you want to guard agains errors when replying
-      # you can use #reply_safe instead of #reply. It will return true if the
-      # message could be sent, and false otherwise.
-      context.reply(Greeting.new('Why, hello old chap.'))
-      # 11.
-      # Now we're through with this actor, so we shut it down.
-      context.exit
-    end
-  end
-end
-
-# 3.
-# This is how you create an actor reference from a subclass of Mikka::Actor.
-# Creating the instance this way makes sure that the actor is set up correctly
-# (refer to the Akka documentation as to why it works this way).
-sam = Mikka.actor_of(Replier)
-
-# 4.
-# Messages can be anything, but if your messages are more complex than a 
-# simple string or symbol you are best off declaring a proper class to 
-# encapsulate them. `Struct` is convenient in this case (but creates mutable
-# objects, consider using the `immutable_struct` gem instead).
-class Introduction < Struct.new(:to_whom); end
-class Greeting < Struct.new(:body); end
-
-# 5.
-# An actor must be started before it can be used!
-phil.start
-sam.start
-
-# 6.
-# And finally, this is how to send a message to an actor. In Erlang and Scala
-# it is done with !, but that operator is not overridable in Ruby, so we have
-# to make do with <<. The Akka Java API defines #send_one_way (actually
-# sendOneWay, but JRuby fixes the casing for us), which can also be used.
-#
-# Here we send a message to `phil`, the message is an object that contains a
-# reference to the actor `sam`.
-phil << Introduction.new(sam)
-
-# 7.
-# The application will keep running until the last actor is dead. If you want
-# to force shutdown you can use `Mikka.registry.shutdown_all`.

data/examples/load_balancing1.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../lib', __FILE__)
-
-require 'bundler/setup'
-require 'mikka'
-
-
-worker1 = Mikka.actor { |msg| puts "Worker 1 working on #{msg}" }
-worker2 = Mikka.actor { |msg| puts "Worker 2 working on #{msg}" }
-balancer = Mikka.load_balancer(:actors => [worker1, worker2])
-
-10.times do |i|
-  balancer << "item #{i}"
-end
-
-balancer << Mikka::Messages.broadcast("a message to everyone")
-balancer << Mikka::Messages.poison_pill
-
-Mikka.registry.shutdown_all

data/examples/load_balancing2.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../lib', __FILE__)
-
-require 'bundler/setup'
-require 'mikka'
-
-
-class Worker < Mikka::Actor
-  def receive(message)
-    puts "#{context.uuid} Work on #{message}"
-  end
-end
-
-balancer = Mikka.load_balancer(:type => Worker, :count => 4)
-
-10.times do |i|
-  balancer << "item #{i}"
-end
-
-balancer << Mikka::Messages.broadcast("a message to everyone")
-
-Mikka.registry.shutdown_all

data/examples/proc_example.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../lib', __FILE__)
-
-require 'bundler/setup'
-require 'mikka'
-
-
-actor = Mikka.actor do |message|
-  case message
-  when 'hi'
-    puts "hello yourself"
-  when 'goodbye'
-    puts "adieu"
-    context.exit
-  else
-    puts "sorry, come again?"
-  end
-end
-
-actor.start
-actor << 'hi'
-actor << 'hello'
-actor << 'goodbye'

data/examples/remoting.rb

@@ -1,70 +0,0 @@
-$: << File.expand_path('../../lib', __FILE__)
-
-# Run this with the argument 'server' to start a server, then run again 
-# without argument to run a client
-
-require 'mikka'
-
-
-SERVICE_NAME = 'translation-service'
-SERVER_PORT = 1337
-
-
-if ARGV.any? && ARGV.first == 'server'
-  # this is the server, it spawns the actor, starts a server and registers the 
-  # actor with the server
-
-  class ServerActor < Mikka::Actor
-    TRANSLATIONS = {
-      'bonjour' => 'hello'
-    }
-    
-    def receive(message)
-      context.reply_safe(TRANSLATIONS[message])
-    end
-  end
-
-  # start the server, the host can be specified with :host and defaults to
-  # localhost (the port defaults to 2552, but 1337 is cooler)
-  server = Mikka::Remote.start(:port => SERVER_PORT)
-
-  # create and register an actor with the server, this ID is used by the 
-  # client to get a reference to the actor
-  server.register(SERVICE_NAME, Mikka.actor_of(ServerActor))
-  
-  # now we're just waiting for messages
-else
-  # this is the client code, it connects to the remote actor and sends it a message
-  
-  class ClientActor < Mikka::Actor
-    def initialize(word)
-      super() # remember to use super with parentheses!
-      @word = word
-    end
-    
-    def pre_start
-      # this gets an actor reference to the remote actor, you need to supply
-      # the ID the actor was registered with, and the host and port where it's
-      # running (these default to localhost and 2552)
-      @translation_actor = Mikka::Remote.actor_for(SERVICE_NAME, :port => SERVER_PORT)
-      @translation_actor << @word
-    end
-    
-    def receive(message)
-      if message
-        puts "#{@word} means #{message}"
-      else
-        puts "#{@word} has no meaning"
-      end
-      context.exit
-    end
-  end
-  
-  # if you want to receive replies you need to start a server on the client 
-  # side too, but you can use the no-args constructor to use the defaults
-  # (just don't use the defaults for both server and client)
-  Mikka::Remote.start
-  
-  client = Mikka.actor_of { ClientActor.new('bonjour') }
-  client.start
-end

data/examples/simple_example.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../lib', __FILE__)
-
-require 'bundler/setup'
-require 'mikka'
-
-
-class Stallone < Mikka::Actor
-  def receive(message)
-    context.exit if message == 'punch!'
-  end
-end
-
-stallone = Mikka.actor_of(Stallone).start
-stallone << 'punch!'

data/examples/supervision1.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../lib', __FILE__)
-
-require 'bundler/setup'
-require 'mikka'
-
-
-class Worker < Mikka::Actor
-  life_cycle :permanent
-  
-  def pre_start
-    puts "#{context.id} starting"
-  end
-  
-  def pre_restart(reason)
-    puts "#{context.id} restarting"
-  end
-  
-  def post_restart(reason)
-    puts "#{context.id} restarted"
-  end
-  
-  def post_stop
-    puts "#{context.id} stopped"
-  end
-  
-  def receive(message)
-    raise java.lang.Exception.new('Oh, shucks') if message == 'hard work'
-    puts "#{context.id} Work on #{message}"
-  end
-end
-
-class Manager < Mikka::Actor
-  fault_handling :strategy => :all_for_one, :trap => [java.lang.Exception], :max_retries => 3, :time_range => 3000
-  
-  def pre_start
-    @worker1 = Mikka.actor_of { Worker.new }
-    @worker2 = Mikka.actor_of { Worker.new }
-    @worker1.id = 'worker1'
-    @worker2.id = 'worker2'
-    context.start_link(@worker1)
-    context.start_link(@worker2)
-    @worker1 << 'simple work'
-    @worker2 << 'hard work'
-    @worker2 << 'simple work'
-    @worker2 << 'simple work'
-    @worker2 << 'hard work'
-    @worker2 << 'simple work'
-    @worker2 << 'simple work'
-    @worker2 << 'simple work'
-  end
-end
-
-manager = Mikka.actor_of(Manager).start