stn-dcell 0.16.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99f99f9345e669d2241b7fce6fc22464cc0d8469
+  data.tar.gz: 604466b8723cb8e228474a4d1f44e1adbab62812
+SHA512:
+  metadata.gz: 673cc9abf920468319875aca305aafd1afa25aa7f69795dd12a693935390c5acb1e2d998118d3b56ba733343e2728e29e4c4c035c94572c42d36803344b6801d
+  data.tar.gz: f162d1bb986e35f1b2d6ff8049d483cc057915dac713556cf44d60fc3c4dceb5bd2430c3d16458f230a5cc63c9bba68a313b8964706b4b37bfb5b3ca4a088796

data/.coveralls.yml

@@ -0,0 +1 @@
+service-name: travis-pro

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/*
+zookeeper/*
+coverage

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format documentation
+--backtrace
+--warnings

data/.travis.yml

@@ -0,0 +1,30 @@
+language: ruby
+
+before_install: sudo apt-get install libzmq3-dev
+
+services:
+  - mongodb
+  - redis-server
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - jruby-19mode
+  - jruby-head
+  - rbx-19mode
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: jruby-19mode
+    - rvm: rbx-19mode # rbx seems to be losing exception messages o_O
+
+branches:
+  only:
+    - master
+
+env:
+    - DCELL_TEST_ADAPTER=redis
+    - DCELL_TEST_ADAPTER=mongodb

data/CHANGES.md

@@ -0,0 +1,53 @@
+0.16.0 (2014-09-04)
+-------------------
+* Timeouts for cell discovery
+* Update Explorer to use new Reel API
+
+0.15.0 (2013-09-04)
+-------------------
+* Tracking release for Celluloid 0.15
+* Use the celluloid-redis gem with the Redis adapter
+
+0.14.0 (2013-05-07)
+-------------------
+* Allow InfoService to run on linux when lsb-release is missing
+* Remove broken moneta adapter
+* Use ephemeral mode for ZK adapter
+* Add support for executing blocks over DCell
+
+0.13.0
+------
+* First semi-stable release in nearly forever! Yay!
+* Rip out the unstable gossip system, replace the original Zookeeper and
+  Redis adapters.
+* Compatibility fixes with newer versions of the Celluloid suite
+
+0.10.0
+------
+* DCell::Explorer provides a web UI with Reel
+* Info service at DCell::Node#[:info]
+* Distributed gossip protocol, now default adapter
+* Support for marshaling Celluloid::Futures
+* Cassandra registry
+* Initial DCell::NodeManager
+* celluloid-zmq split out into a separate gem
+* Use Celluloid.uuid for mailbox and call IDs
+
+0.9.0
+-----
+* Use new Celluloid::ZMQ APIs
+
+0.8.0
+-----
+* Track calls in-flight with DCell::RPC and DCell::RPC::Manager
+* Compatibility changes for Celluloid 0.8.0
+
+0.7.1
+-----
+* Bump version to match Celluloid
+* Factor 0MQ bindings into the celluloid-zmq gem
+* Heartbeat system for detecting downed nodes
+
+0.0.1
+-----
+* Initial release

data/Gemfile

@@ -0,0 +1,18 @@
+source "http://rubygems.org"
+
+gem 'celluloid',        github: 'celluloid/celluloid',        tag: 'v0.16.0'
+gem 'celluloid-io',     github: 'celluloid/celluloid-io',     tag: 'v0.16.1'
+gem 'celluloid-zmq',    github: 'celluloid/celluloid-zmq',    tag: 'v0.16.0'
+gem 'celluloid-redis',  github: 'celluloid/celluloid-redis',  branch: 'master'
+gem 'reel',             github: 'celluloid/reel',             tag: 'v0.4.0'
+
+#gem 'ffi-rzmq', github: 'chuckremes/ffi-rzmq'
+
+gem 'jruby-openssl', platform: :jruby
+gem 'coveralls',     require: false
+
+# Specify your gem's dependencies in dcell.gemspec
+gemspec
+
+gem 'zk'
+gem 'mongoid'

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Tony Arcieri
+
+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,168 @@
+![DCell](https://github.com/celluloid/dcell/raw/master/logo.png)
+=====
+[![Gem Version](https://badge.fury.io/rb/dcell.png)](http://rubygems.org/gems/dcell)
+[![Build Status](https://secure.travis-ci.org/celluloid/dcell.png?branch=master)](http://travis-ci.org/celluloid/dcell)
+[![Code Climate](https://codeclimate.com/github/celluloid/dcell.png)](https://codeclimate.com/github/celluloid/dcell)
+[![Coverage Status](https://coveralls.io/repos/celluloid/dcell/badge.png?branch=master)](https://coveralls.io/r/celluloid/dcell)
+
+> "Objects can message objects transparently that live on other machines
+> over the network, and you don't have to worry about the networking gunk,
+> and you don't have to worry about finding them, and you don't have to
+> worry about anything. It's just as if you messaged an object that's
+> right next door."
+> _--Steve Jobs describing the NeXT Portable Distributed Object system_
+
+DCell is a simple and easy way to build distributed applications in Ruby.
+Somewhat similar to DRb, DCell lets you easily expose Ruby objects as network
+services, and call them remotely just like you would any other Ruby object.
+However, unlike DRb all objects in the system are concurrent. You can create
+and register several available services on a given node, obtain handles to
+them, and easily pass these handles around the network just like any other
+objects.
+
+DCell is a distributed extension to [Celluloid][celluloid], which provides
+concurrent objects for Ruby with many of the features of Erlang, such as the
+ability to supervise objects and restart them when they crash, and also link to
+other objects and receive event notifications of when they crash. This makes
+it easier to build robust, fault-tolerant distributed systems.
+
+DCell uses the [0MQ][zeromq] messaging protocol which provides a robust,
+fault-tolerant brokerless transport for asynchronous messages sent between
+nodes. DCell is built on top of the [Celluloid::ZMQ][celluloid-zmq] library,
+which provides a Celluloid-oriented wrapper around the underlying
+[ffi-rzmq][ffi-rzmq] library.
+
+[Please see the DCell Wiki](https://github.com/celluloid/dcell/wiki)
+for more detailed documentation and usage notes.
+
+Like DCell? [Join the Celluloid Google Group][googlegroup]
+
+[celluloid]: http://celluloid.io/
+[zeromq]: http://www.zeromq.org/
+[celluloid-zmq]: https://github.com/celluloid/celluloid-zmq
+[ffi-rzmq]: https://github.com/chuckremes/ffi-rzmq
+[googlegroup]: http://groups.google.com/group/celluloid-ruby
+
+### Is it any good?
+
+[Yes.](http://news.ycombinator.com/item?id=3067434)
+
+### Is It "Production Ready™"?
+
+Not entirely, but eager early adopters are welcome!
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'dcell'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dcell
+
+Inside of your Ruby program do:
+
+    require 'dcell'
+
+...to pull it in as a dependency.
+
+Example
+-------
+
+Copy and paste this into `itchy.rb` (or run `bundle exec examples/itchy.rb`):
+
+```ruby
+require 'dcell'
+
+DCell.start :id => "itchy", :addr => "tcp://127.0.0.1:9001"
+
+class Itchy
+  include Celluloid
+
+  def initialize
+    puts "Ready for mayhem!"
+    @n = 0
+  end
+
+  def fight
+    @n = (@n % 6) + 1
+    if @n <= 3
+      puts "Bite!"
+    else
+      puts "Fight!"
+    end
+  end
+end
+
+Itchy.supervise_as :itchy
+sleep
+```
+
+You can now launch itchy with:
+
+```
+ruby itchy.rb
+```
+
+Now copy and paste the following into `scratchy.rb` (also in examples)
+
+```ruby
+require 'dcell'
+
+DCell.start :id => "scratchy", :addr => "tcp://127.0.0.1:9002"
+itchy_node = DCell::Node["itchy"]
+
+puts "Fighting itchy! (check itchy's output)"
+
+6.times do
+  itchy_node[:itchy].fight
+  sleep 1
+end
+```
+
+Now run scratchy side-by-side with itchy. You should see this on itchy:
+
+```
+$ bundle exec examples/itchy.rb
+Ready for mayhem!
+I, [2012-12-25T22:52:45.362355 #74272]  INFO -- : Connected to scratchy
+Bite!
+Bite!
+Bite!
+Fight!
+Fight!
+Fight!
+```
+
+This is a basic example how individual DCell::Nodes have registered Celluloid actors which can be accessed remotely by other DCell::Nodes.
+
+Supported Platforms
+-------------------
+
+DCell works on Ruby 1.9.3, JRuby 1.6, and Rubinius 2.0.
+
+DCell requires Ruby 1.9 mode on all interpreters. This works out of the
+box on MRI/YARV, and requires the following flags elsewhere:
+
+* JRuby: --1.9 command line option, or JRUBY_OPTS=--1.9 environment variable
+* rbx: -X19 command line option
+
+Contributing to DCell
+-------------------------
+
+* Fork this repository on github
+* Make your changes and send me a pull request
+* If I like them I'll merge them
+* If I've accepted a patch, feel free to ask for commit access
+
+Copyright
+---------
+
+Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License.
+See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+Dir["tasks/**/*.task"].each { |task| load task }
+
+task :default => :spec

data/benchmarks/messaging.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'dcell'
+DCell.setup
+DCell.run!
+
+RECEIVER_PORT = 2043
+
+$receiver_pid = Process.spawn Gem.ruby, File.expand_path("../receiver.rb", __FILE__)
+STDERR.print "Waiting for test node to start up..."
+
+socket = nil
+30.times do
+  begin
+    socket = TCPSocket.open("127.0.0.1", RECEIVER_PORT)
+    break if socket
+  rescue Errno::ECONNREFUSED
+    STDERR.print "."
+    sleep 1
+  end
+end
+
+if socket
+  STDERR.puts " done!"
+  socket.close
+else
+  STDERR.puts " FAILED!"
+  raise "couldn't connect to test node!"
+end
+
+class AsyncPerformanceTest
+  include Celluloid
+
+  def initialize(progenator, n = 10000)
+    @n = n
+    @receiver = progenator.spawn_async_receiver(n, current_actor)
+  end
+
+  def run
+    @n.times { @receiver.async.increment }
+    wait :complete
+  end
+
+  def complete
+    signal :complete
+  end
+end
+
+DCell.start :id => "messaging_node", :addr => "tcp://127.0.0.1:2042",
+  :directory => {
+    :id => "benchmark_receiver",
+    :addr => "tcp://127.0.0.1:#{RECEIVER_PORT}"
+  }
+
+receiver = DCell::Node['benchmark_receiver']
+progenator = receiver[:progenator]
+
+test = AsyncPerformanceTest.new progenator
+time = Benchmark.measure { test.run }.real
+messages_per_second = 1 / time * 10000
+
+puts "messages_per_second: #{"%0.2f" % messages_per_second}"
+
+Process.kill 9, $receiver_pid
+Process.wait $receiver_pid rescue nil
+
+exit 0

data/benchmarks/receiver.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'dcell'
+DCell.start :id => 'benchmark_receiver', :addr => 'tcp://127.0.0.1:2043'
+
+class AsyncReceiver
+  include Celluloid
+  attr_reader :count
+
+  def initialize(n, actor)
+    @n, @actor = n, actor
+    @count = 0
+  end
+
+  def increment
+    @count += 1
+    @actor.async.complete if @count == @n
+    @count
+  end
+end
+
+class Progenator
+  include Celluloid
+
+  def spawn_async_receiver(n, actor)
+    AsyncReceiver.new(n, actor)
+  end
+end
+
+class BenchmarkApplication < Celluloid::SupervisionGroup
+  supervise DCell::SupervisionGroup
+  supervise Progenator, :as => :progenator
+end
+
+BenchmarkApplication.run

data/dcell.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dcell/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "stn-dcell"
+  gem.version     = DCell::VERSION
+  gem.license     = 'MIT'
+  gem.authors     = ["Tony Arcieri"]
+  gem.email       = ["tony.arcieri@gmail.com"]
+  gem.homepage    = "http://github.com/celluloid/dcell"
+  gem.summary     = "An asynchronous distributed object framework based on Celluloid"
+  gem.description = "DCell is an distributed object framework based on Celluloid built on 0MQ and Zookeeper"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "celluloid",     "~> 0.16.0"
+  gem.add_runtime_dependency "celluloid-zmq", "~> 0.16.0"
+  gem.add_runtime_dependency "reel",          "~> 0.4.0"
+  gem.add_runtime_dependency "http",          "~> 0.5.0"
+  gem.add_runtime_dependency "celluloid-redis"
+  gem.add_runtime_dependency "redis-namespace"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec",     "~> 2.14.0"
+end