ruote-synchronize 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmE5MjczM2EwMjk3YjIwNzBmODg0NDIxYzc1ZDA5NjEzZDgxNGE2Yg==
+  data.tar.gz: !binary |-
+    NmI5YWExMjcxZTIwNDUyM2UzNDA2ZWZkMWM5OTkxZGY2N2MyODk3MA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZGJiNmYyN2ZjNGE5NTI0MmIwN2Y0Njg2MGEyNzU2NThlOTlkMmJhYzVmYTAy
+    YmU5MTQ1NzM1ZDRhMGNhZDJkNTJhNWIwMTZiNDY0NTQ5NzU4ZmI3ZjhiY2Ex
+    NzA1YjMwZDI5NmNjNzZjMzczZDk1NjA0ZmQ3NDE0YzhiMTc5ZTY=
+  data.tar.gz: !binary |-
+    ZWU5MzBkZjZiNTFkY2YxMDk0OTljMWRmMjUzZGJmNzAyNTVjZmY5YmQ4YzA1
+    N2Q5ODgxMTAyZmJhZGVkYmFjNGRjY2YxYjE0ZDQ3NDEzZjUxMTQ1M2Y4MjUx
+    NjJjMmFiNjY3ODM1NDg5ODFhM2ExMjUxZTkwYmIwNzM5OTIyY2Q=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+bundler_args: --without development
+rvm:
+  - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+script: bundle exec rspec spec

data/.yardopts

@@ -0,0 +1,4 @@
+--markup=markdown
+--files LICENSE
+--title ruote-synchronize
+--readme README.md

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruote-broker.gemspec
+gemspec
+
+platforms :ruby_18, :jruby do
+  gem 'json' unless RUBY_VERSION > '1.9' # is there a jruby but 1.8 only selector?
+end
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'coveralls', :require => false
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Adrien Kohlbecker
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+[![Build Status](https://travis-ci.org/adrienkohlbecker/ruote-synchronize.png)](https://travis-ci.org/adrienkohlbecker/ruote-synchronize) [![Coverage Status](https://coveralls.io/repos/adrienkohlbecker/ruote-synchronize/badge.png?branch=master)](https://coveralls.io/r/adrienkohlbecker/ruote-synchronize) [![Code Climate](https://codeclimate.com/github/adrienkohlbecker/ruote-synchronize.png)](https://codeclimate.com/github/adrienkohlbecker/ruote-synchronize) [![Dependency Status](https://gemnasium.com/adrienkohlbecker/ruote-synchronize.png)](https://gemnasium.com/adrienkohlbecker/ruote-synchronize)
+
+# Ruote::Synchronize
+
+- **Homepage**: [github.com/adrienkohlbecker/ruote-synchronize](https://github.com/adrienkohlbecker/ruote-synchronize)
+- **Rdoc**: [rdoc.info/gems/ruote-synchronize](http://rdoc.info/gems/ruote-synchronize)
+- **Author**: Adrien Kohlbecker
+- **License**: MIT License
+- **Latest Version**: 0.1.0
+- **Release Date**: April 29, 2013
+
+## Synopsis
+
+A process synchronisation module for Ruote.
+
+Will define a `synchronize :key => "my_unique_key"` participant.
+You can use it in two processes by defining the same synchronisation key.
+The first process to reach the synchronization will wait for the other one.
+
+## Usage
+
+```ruby
+
+# Charly and Doug will only run when both Alice and Bob have run,
+# no matter which one of Alice or Bob finishes first
+
+Ruote::Synchronize.setup(engine)
+
+pdef1 = Ruote.process_definition do
+  alice
+  synchronize :key => 'my_very_unique_key'
+  charly
+end
+
+pdef2 = Ruote.process_definition do
+  bob
+  synchronize :key => 'my_very_unique_key'
+  doug
+end
+```
+
+It works by storing the first workitem along with the key.
+When the second process reaches synchronize, it will find the previous workitem,
+receive it (allowing the first process to proceed), and reply immediately.
+
+You must use a key that you know will NEVER be used outside of the two process you want to synchronize.
+
+**Pay attention to multiple launches** (if your process is launched by an HTTP request for example).
+If three processes with the same key are launched, the two first will be synchronized and the last one will be left hanging.
+
+## Requirements
+
+A functionall installation of [Ruote](http://ruote.rubyforge.org) is needed.
+
+ruote-synchronize has been tested on Ruby 1.8+.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruote-synchronize'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruote-synchronize
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Run the tests (`bundle exec rspec`)
+6. Create new Pull Request
+
+## Changelog
+
+- **April 29, 2013**: 0.1.0 release
+    - Initial release

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/ruote/synchronize.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+require 'ruote'
+require 'ruote/synchronize/broker'
+require 'ruote/synchronize/participant'
+require 'ruote/synchronize/version'
+
+module Ruote
+
+  # A process synchronisation module for Ruote.
+  #
+  # Will define a `synchronize :key => "my_unique_key"` participant.
+  # You can use it in two processes by defining the same synchronisation key.
+  # The first process to reach the synchronization will wait for the other one.
+  #
+  # It works by storing the first workitem along with the key.
+  # When the second process reaches synchronize, it will find the previous workitem,
+  # receive it (allowing the first process to proceed), and reply immediately.
+  #
+  # You must use a key that you know will NEVER be used outside of the two process you want to synchronize.
+  #
+  # Pay attention to multiple launches (if your process is launched by an HTTP request for example).
+  # If three processes with the same key are launched, the two first will be synchronized and the last one will be left hanging.
+  #
+  # @example Charly and Doug will only run when both Alice and Bob have run, no matter which one of Alice or Bob finishes first
+  #
+  #     Ruote::Synchronize.setup(engine)
+  #
+  #     pdef1 = Ruote.process_definition do
+  #       alice
+  #       synchronize :key => 'my_very_unique_key'
+  #       charly
+  #     end
+  #
+  #     pdef2 = Ruote.process_definition do
+  #       bob
+  #       synchronize :key => 'my_very_unique_key'
+  #       doug
+  #     end
+  module Synchronize
+
+    # Will register the `synchronize` storage type and participant.
+    # You need to execute this method before launching any processes.
+    # @param [Ruote::Dashboard, Ruote::Engine] dashboard your Ruote dashboard.
+    # @return [void]
+    def self.setup(dashboard)
+
+      dashboard.context.storage.add_type 'synchronize'
+      dashboard.register_participant 'synchronize', Ruote::Synchronize::Participant
+
+    end
+
+  end
+end

data/lib/ruote/synchronize/broker.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+module Ruote
+  module Synchronize
+
+    # A Ruote Receiver that act as a broker between two processes.
+    # It will store workitems under the `synchronize` storage type.
+    class Broker
+
+      include Ruote::ReceiverMixin
+
+      # @param [Ruote::Context] context (needed by Ruote)
+      def initialize(context)
+        @context = context
+      end
+
+      # Check if there was a previous workitem stored with the same key.
+      # If so, receives and deletes the stored workitem.
+      # Else, stores the workitem with the key.
+      # @param [#to_s] key The unique key to do the lookup with
+      # @param [Ruote::Workitem] workitem The workitem to store
+      # @return [true, false] True if there was a previous workitem
+      #   with the same key, false otherwise
+      def publish(key, workitem)
+
+        if doc = stored_doc_from_key(key)
+          # another process already registered the same key
+          # allow both processes to continue
+          continue_with doc
+          true
+        else
+          # this process is the first to register
+          # store the workitem for now
+          wait_for key, workitem
+          false
+        end
+
+      end
+
+      # Deletes a previously stored key from storage
+      # @param [#to_s] key The key to delere
+      # @return [void]
+      def unpublish(key)
+        doc = stored_doc_from_key(key)
+        @context.storage.delete(doc) if doc
+      end
+
+      private
+
+      def stored_doc_from_key(key)
+        @context.storage.get('synchronize', key)
+      end
+
+      def continue_with(doc)
+
+        stored_workitem = Ruote::Workitem.new(doc['workitem'])
+        receive(stored_workitem)
+        @context.storage.delete(doc)
+
+      end
+
+      def wait_for(key, workitem)
+
+        doc = {
+          'type' => 'synchronize',
+          '_id' => key,
+          'workitem' => workitem.to_h
+        }
+        @context.storage.put(doc)
+
+      end
+
+
+    end
+
+  end
+end

data/lib/ruote/synchronize/participant.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+module Ruote
+module Synchronize
+
+  # Raised when the synchronize participant is used without a key
+  # @example Will raise UndefinedKey during process execution
+  #     pdef = Ruote.process_definition do
+  #       synchronize
+  #       synchronize :key => nil
+  #       synchronize :key => ''
+  #     end
+  class UndefinedKey < RuntimeError
+  end
+
+  # A special kind of participant registered as "synchronize"
+  class Participant
+
+    include Ruote::LocalParticipant
+
+    # Replies if another synchronize call was made previously with the same key.
+    # Otherwise stores the workitem and does not reply.
+    # @raise [UndefinedKey] if synchronize was called with a nil or empty key.
+    # @return [void]
+    def on_workitem
+
+      key = workitem.lookup('params.key')
+      raise UndefinedKey if key.to_s.empty?
+
+      reply if broker.publish(key, workitem)
+
+    end
+
+    # Deletes the synchronization key from storage if it still exists.
+    # @return [void]
+    def on_cancel
+
+      key = applied_workitem.lookup('params.key')
+      broker.unpublish(key)
+
+    end
+
+    private
+
+    def broker
+      @broker ||= Ruote::Synchronize::Broker.new(self.context)
+    end
+
+  end
+end
+end

data/lib/ruote/synchronize/version.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+module Ruote
+  module Synchronize
+    VERSION = '0.1.0'
+  end
+end

data/ruote-synchronize.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruote/synchronize/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruote-synchronize"
+  spec.version       = Ruote::Synchronize::VERSION
+  spec.authors       = ["Adrien Kohlbecker"]
+  spec.email         = ["adrien.kohlbecker@gmail.com"]
+  spec.description   = %q{A process synchronisation module for Ruote.}
+  spec.summary       = %q{A process synchronisation module for Ruote.
+                        Will define a synchronize :key => "my_unique_key" participant.
+                        You can use it in two processes by defining the same synchronisation key.
+                        The first process to reach the synchronization will wait for the other one.}.gsub(/^\s+/, '')
+
+  spec.homepage      = "https://github.com/adrienkohlbecker/ruote-synchronize"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ruote"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'mutant'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'redcarpet'
+end

data/spec/lib/ruote/synchronize/broker_spec.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe Ruote::Synchronize::Broker do
+
+  before :each do
+
+    @board = Ruote::Dashboard.new(Ruote::Worker.new(Ruote::HashStorage.new))
+
+    @board.register(/^block_/) do |workitem|
+      workitem.fields[workitem.participant_name] = 'was here'
+    end
+
+    Ruote::Synchronize.setup(@board)
+
+  end
+
+  after :each do
+
+    @board.shutdown
+    @board.storage.purge!
+
+  end
+
+  context '#initialize' do
+
+    it 'accepts a context' do
+
+      expect{Ruote::Synchronize::Broker.new}.to raise_error
+      expect{Ruote::Synchronize::Broker.new(@board.context)}.not_to raise_error
+
+    end
+
+    it 'registers the synchronize participant' do
+
+      sync = Ruote::Synchronize::Broker.new(@board.context)
+      expect(@board.participant('synchronize')).not_to be_nil
+      expect(@board.participant('synchronize').class).to eq(Ruote::Synchronize::Participant)
+
+    end
+
+  end
+
+  context '#publish' do
+
+    let(:sync) { Ruote::Synchronize::Broker.new(@board.context) }
+    let(:key) { 'my_key' }
+    let(:workitem) { Ruote::Workitem.new({'abc'=> true}) }
+
+    context 'with a fresh storage' do
+
+      it 'stores the workitem with the message' do
+        sync.publish(key, workitem)
+        expect(@board.context.storage.get('synchronize', key)['workitem']).to eq(workitem.to_h)
+      end
+
+      it 'returns false' do
+        expect(sync.publish(key, workitem).is_a? FalseClass).to be_true
+      end
+
+    end
+
+    context 'with a previously published message' do
+
+      before :each do
+        sync.publish(key, workitem)
+      end
+
+      let(:another_workitem) { Ruote::Workitem.new({:def => true})  }
+
+      it 'deletes the previous message' do
+        sync.publish(key, another_workitem)
+        expect(@board.context.storage.get('synchronize', key)).to be_nil
+
+      end
+
+      it 'returns true' do
+        expect(sync.publish(key, another_workitem).is_a? TrueClass).to be_true
+      end
+
+      it 'receives the previous workitem' do
+        sync.should_receive(:receive).with(workitem)
+        sync.publish(key, another_workitem)
+      end
+
+    end
+
+
+  end
+
+  context '#unpublish' do
+
+    let(:sync) { Ruote::Synchronize::Broker.new(@board.context) }
+    let(:key) { 'my_key' }
+    let(:workitem) { Ruote::Workitem.new({'abc'=> true}) }
+
+    context 'with a fresh storage' do
+
+      it 'returns nil' do
+        expect(sync.unpublish(key)).to be_nil
+      end
+
+    end
+
+    context 'with a previously published message' do
+
+      before :each do
+        sync.publish(key, workitem)
+      end
+
+      it 'deletes the previous message' do
+        sync.unpublish(key)
+        expect(@board.context.storage.get('synchronize', key)).to be_nil
+      end
+
+    end
+
+
+  end
+
+
+end

data/spec/lib/ruote/synchronize/participant_spec.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'ruote/storage/fs_storage'
+
+describe Ruote::Synchronize::Broker do
+
+  before :each do
+    @board = Ruote::Dashboard.new(Ruote::Worker.new(Ruote::FsStorage.new('ruote_work')))
+    @participant = Ruote::Synchronize::Participant.new
+    @participant.context = @board.context
+  end
+
+  after :each do
+    @board.shutdown
+    @board.storage.purge!
+  end
+
+  context '#on_workitem' do
+
+    let(:workitem) { Ruote::Workitem.new({'abc' => true, 'fields' => {'params' => {'key' => 'my_key'}}}) }
+    let(:key) { 'my_key' }
+
+    it 'raises if the key is not defined' do
+      workitem.fields['params']['key'] = nil
+      expect{@participant._on_workitem(workitem)}.to raise_error(Ruote::Synchronize::UndefinedKey)
+    end
+
+    it 'raises if the key is an empty string' do
+      workitem.fields['params']['key'] = ''
+      expect{@participant._on_workitem(workitem)}.to raise_error(Ruote::Synchronize::UndefinedKey)
+    end
+
+    context 'with a fresh storage' do
+
+      it 'stores the message' do
+        @participant._on_workitem(workitem)
+        expect(@board.context.storage.get('synchronize', key)).not_to be_nil
+      end
+
+      it 'does not reply' do
+        @participant.should_not_receive(:reply)
+        @participant._on_workitem(workitem)
+      end
+
+    end
+
+    context 'with a previous message' do
+
+      before :each do
+        @another_participant = Ruote::Synchronize::Participant.new
+        @another_participant.context = @board.context
+        @another_participant._on_workitem(workitem)
+      end
+
+      it 'replies to the other participant' do
+        Ruote::Synchronize::Broker.any_instance.should_receive(:receive).with(@another_participant.workitem)
+        @participant._on_workitem(workitem)
+      end
+
+      it 'replies immediately' do
+        @participant.should_receive(:reply)
+        @participant._on_workitem(workitem)
+      end
+
+    end
+
+  end
+
+  context '#on_cancel' do
+
+    let(:workitem) { Ruote::Workitem.new({'abc' => true, 'fields' => {'params' => {'key' => 'my_key'}}}) }
+    let(:key) { 'my_key' }
+
+    it 'deletes the message' do
+
+      @participant._on_workitem(workitem)
+      @participant.stub(:applied_workitem).and_return workitem
+      @participant.on_cancel
+      expect(@board.context.storage.get('synchronize', key)).to be_nil
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'ruote/synchronize'
+
+RSpec.configure do |config|
+
+  config.mock_with :rspec
+
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: ruote-synchronize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adrien Kohlbecker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruote
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutant
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A process synchronisation module for Ruote.
+email:
+- adrien.kohlbecker@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- .yardopts
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/ruote/synchronize.rb
+- lib/ruote/synchronize/broker.rb
+- lib/ruote/synchronize/participant.rb
+- lib/ruote/synchronize/version.rb
+- ruote-synchronize.gemspec
+- spec/lib/ruote/synchronize/broker_spec.rb
+- spec/lib/ruote/synchronize/participant_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/adrienkohlbecker/ruote-synchronize
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A process synchronisation module for Ruote. Will define a synchronize :key
+  => "my_unique_key" participant. You can use it in two processes by defining the
+  same synchronisation key. The first process to reach the synchronization will wait
+  for the other one.
+test_files:
+- spec/lib/ruote/synchronize/broker_spec.rb
+- spec/lib/ruote/synchronize/participant_spec.rb
+- spec/spec_helper.rb
+has_rdoc: