rloss 0.0.1

data/lib/floss/rpc/in_memory.rb

@@ -0,0 +1,39 @@
+require 'floss/rpc'
+
+class Floss::RPC::InMemory
+  class Client < Floss::RPC::Client
+    include Celluloid
+
+    attr_accessor :address
+
+    def initialize(address)
+      self.address = address
+    end
+
+    def call(command, payload)
+      timeout(Floss::RPC::TIMEOUT) { actor.execute(command, payload) }
+    rescue Celluloid::DeadActorError, Celluloid::Task::TimeoutError
+      raise Floss::TimeoutError
+    end
+
+    def actor
+      Celluloid::Actor[address]
+    end
+  end
+
+  class Server < Floss::RPC::Server
+    include Celluloid
+
+    execute_block_on_receiver :initialize
+
+    def initialize(address, &handler)
+      super
+
+      Actor[address] = Actor.current
+    end
+
+    def execute(command, payload)
+      handler.call(command, payload)
+    end
+  end
+end

data/lib/floss/rpc/zmq.rb

@@ -0,0 +1,120 @@
+require 'floss/rpc'
+require 'celluloid/io/stream'
+require 'celluloid/zmq'
+
+class Floss::RPC::ZMQ
+  class Client < Floss::RPC::Client
+    include Celluloid::ZMQ
+
+    # @return [Celluloid::IO::Stream::Latch]
+    attr_accessor :latch
+
+    attr_accessor :address
+
+    # @return [Celluloid::ZMQ::ReqSocket]
+    attr_accessor :socket
+
+    # Disconnect when shutting the client down.
+    finalizer :disconnect
+
+    def initialize(address)
+      self.latch = Celluloid::IO::Stream::Latch.new
+      self.address = address
+      connect
+    end
+
+    def connect
+      self.socket = Celluloid::ZMQ::ReqSocket.new
+      socket.connect(address)
+    end
+
+    def disconnect
+      socket.close if socket
+    end
+
+    def call(command, payload)
+      message = encode_request(command, payload)
+      response = latch.synchronize { request(message) }
+      decode_response(response)
+    end
+
+    def request(message)
+      timeout(Floss::RPC::TIMEOUT) do
+        socket.send(message)
+        socket.read
+      end
+    rescue Celluloid::Task::TimeoutError
+      disconnect
+      connect
+      abort Floss::TimeoutError.new("RPC timed out (#{address}).")
+    end
+
+    def encode_request(command, payload)
+      "#{command}:#{Marshal.dump(payload)}"
+    end
+
+    def decode_response(response)
+      Marshal.load(response)
+    end
+  end
+
+  class Server < Floss::RPC::Server
+    include Celluloid::ZMQ
+    include Celluloid::Logger
+
+    attr_accessor :socket
+
+    execute_block_on_receiver :initialize
+    finalizer :finalize
+
+    def initialize(address, &handler)
+      super
+      async.run
+    end
+
+    def run
+      self.socket = RepSocket.new
+
+      begin
+        info("Binding to #{address}")
+        socket.bind(address)
+      rescue IOError
+        socket.close
+        raise
+      end
+
+      async.loop!
+    end
+
+    def loop!
+      loop { handle(socket.read) }
+    end
+
+    # @param [String] request  A request string containing command and payload separated by a colon.
+    def handle(request)
+      command, payload = decode_request(request)
+      response = handler.call(command, payload)
+      socket.send(encode_response(response))
+    end
+
+    def encode_response(response)
+      Marshal.dump(response)
+    end
+
+    def decode_request(request)
+      command, payload = request.split(':', 2)
+      payload = Marshal.load(payload)
+
+      [command.to_sym, payload]
+    end
+
+    def finalize
+      socket.close if socket
+    end
+
+    def terminate
+      super
+      socket.close if socket
+    end
+  end
+end

data/lib/floss/test_helper.rb

@@ -0,0 +1,15 @@
+require 'floss'
+
+module Floss::TestHelper
+  extend self
+
+  # Takes a list of node ids and yields a list of peers for each id.
+  def cluster(ids, &block)
+    cluster_size = ids.size
+
+    cluster_size.times.map do |i|
+      combination = ids.rotate(i)
+      block.call(combination.first, combination[1..-1])
+    end
+  end
+end

data/lib/floss/version.rb

@@ -0,0 +1,3 @@
+module Floss
+  VERSION = "0.0.1"
+end

data/rloss.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/floss/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Robby Ranshous"]
+  gem.email         = ["rranshous@gmail.com"]
+  gem.description   = "Floss distributed consensus module for Celluloid"
+  gem.summary       = "Floss is an implementation of the Raft distributed consensus protocol for Celluloid"
+  gem.homepage      = "https://github.com/rranshous/rloss"
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rloss"
+  gem.require_paths = ["lib"]
+  gem.version       = Floss::VERSION
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake'
+  gem.add_runtime_dependency 'celluloid-zmq'
+  gem.add_runtime_dependency 'celluloid-io'
+end

data/spec/functional/log_spec.rb

@@ -0,0 +1,59 @@
+require 'floss/log'
+require 'floss/log/simple'
+
+shared_examples 'a Log implementation' do
+
+  before do
+    @log = described_class.new {}
+    @log.remove_starting_with(0)
+  end
+
+  it 'returns empty when there are no entries' do
+    @log.should be_empty
+  end
+
+  it 'appends entries' do
+    entries = [Floss::Log::Entry.new('command1',1),
+               Floss::Log::Entry.new('command2',1),
+               Floss::Log::Entry.new('command3',1)
+    ]
+    @log.append(entries)
+  end
+
+  it 'can return an entry by index' do
+    entries = [Floss::Log::Entry.new('command1',1)]
+    @log.append(entries)
+    entry = @log[0]
+    entry.command.should eql('command1')
+  end
+
+  it 'can return a range of entries' do
+    entries = [Floss::Log::Entry.new('command1',1),
+               Floss::Log::Entry.new('command2',1),
+               Floss::Log::Entry.new('command3',1)
+    ]
+    @log.append(entries)
+    range = @log.starting_with(1)
+    range.size.should eql(2)
+    range[0].command.should eql('command2')
+  end
+
+  it 'can return index of the last entry' do
+    @log.append([Floss::Log::Entry.new('command1',1),
+                Floss::Log::Entry.new('command2',1)])
+    idx = @log.last_index
+    idx.should eql(1)
+  end
+
+  it 'returns the term of the last entry' do
+    @log.append([Floss::Log::Entry.new('command1',1),
+                Floss::Log::Entry.new('command2',1)])
+    term = @log.last_term
+    term.should eql(1)
+  end
+
+end
+
+describe Floss::Log::Simple do
+  it_should_behave_like 'a Log implementation'
+end

data/spec/functional/node_spec.rb

@@ -0,0 +1,10 @@
+require 'floss/node'
+
+describe Floss::Node do
+  it "doesn't crash when all of its peers are down" do
+    opts = {id: 'tcp://127.0.0.1:7001', peers: ['tcp://127.0.0.1:7002', 'tcp://127.0.0.1:7003']}
+    node = described_class.new(opts)
+    sleep(node.broadcast_time)
+    expect(node).to be_alive
+  end
+end

data/spec/functional/rpc_spec.rb

@@ -0,0 +1,76 @@
+require 'floss/rpc'
+require 'floss/rpc/zmq'
+require 'floss/rpc/in_memory'
+
+class TestActor
+  include Celluloid
+
+  execute_block_on_receiver :exec
+
+  def exec
+    yield
+  end
+end
+
+shared_examples 'an RPC implementation' do
+  def actor_run(&block)
+    actor = TestActor.new
+    result = actor.exec(&block)
+    actor.terminate
+    result
+  end
+
+  let(:server_class) { described_class::Server }
+  let(:client_class) { described_class::Client }
+
+  let(:command) { :command }
+  let(:payload) { Hash[key: 'value'] }
+
+  it 'executes calls' do
+    server = server_class.new(address) { |command, payload| [command, payload] }
+    client = client_class.new(address)
+    actor_run { client.call(command, payload) }.should eq([command, payload])
+  end
+
+  it 'executes multiple calls sequentially' do
+    calls = 3.times.map { |i| [:command, i] }
+    server = server_class.new(address) { |command, payload| [command, payload] }
+    client = client_class.new(address)
+    actor_run { calls.map { |args| client.call(*args) } }.should eq(calls)
+  end
+
+  it 'raises an error if server is not available' do
+    client = client_class.new(address)
+    expect { actor_run { client.call(:command, :payload) } }.to raise_error(Floss::TimeoutError)
+    expect { client.to be_alive }
+  end
+
+  it 'raises an error if server does not respond in time' do
+    server = server_class.new(address) { |command, payload| sleep 1.5; [command, payload] }
+    client = client_class.new(address)
+    expect { actor_run { client.call(:command, :payload) } }.to raise_error(Floss::TimeoutError)
+    expect { client.to be_alive }
+  end
+end
+
+describe Floss::RPC::InMemory do
+  let(:address) { :node1 }
+
+  before(:each) do
+    Celluloid.shutdown
+    Celluloid.boot
+  end
+
+  it_should_behave_like 'an RPC implementation'
+end
+
+describe Floss::RPC::ZMQ do
+  let(:address) { 'tcp://127.0.0.1:12345' }
+
+  before(:each) do
+    Celluloid.shutdown
+    Celluloid.boot
+  end
+
+  it_should_behave_like 'an RPC implementation'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'logger'
+require 'celluloid'
+
+logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'w')
+logfile.sync = true
+Celluloid.logger = Logger.new(logfile)
+Celluloid.shutdown_timeout = 1

data/test.rb

@@ -0,0 +1,51 @@
+$: << File.expand_path('../lib', __FILE__)
+
+require 'floss/node'
+
+CLUSTER_SIZE = 5
+
+nodes = CLUSTER_SIZE.times.map do |i|
+  port = 50000 + i
+  "tcp://127.0.0.1:#{port}"
+end
+
+supervisor = Celluloid::SupervisionGroup.run!
+
+CLUSTER_SIZE.times.map do |i|
+  combination = nodes.rotate(i)
+  options = {id: combination.first, peers: combination[1..-1]}
+  supervisor.supervise(Floss::Node, options)
+end
+
+sleep 1
+
+begin
+  leader = supervisor.actors.find(&:leader?)
+  puts "The leader is #{leader.id}"
+
+  leader.execute("Hello World!")
+rescue => e
+  puts "Couldn't execute my command!"
+  p e
+end
+
+sleep 1
+
+begin
+  leader = supervisor.actors.find(&:leader?)
+  puts "The leader is #{leader.id}"
+
+  leader.execute("Hello Again!")
+rescue => e
+  puts "Couldn't execute my command!"
+  p e
+end
+
+sleep 0.5
+
+supervisor.actors.each do |actor|
+  Celluloid.logger.info("Log of #{actor.id}: #{actor.log.entries}")
+end
+
+sleep 1
+exit

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: rloss
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robby Ranshous
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: rake
+  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: celluloid-zmq
+  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: celluloid-io
+  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'
+description: Floss distributed consensus module for Celluloid
+email:
+- rranshous@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/distributed_hash.rb
+- lib/floss.rb
+- lib/floss/count_down_latch.rb
+- lib/floss/latch.rb
+- lib/floss/log.rb
+- lib/floss/log/simple.rb
+- lib/floss/log_replicator.rb
+- lib/floss/node.rb
+- lib/floss/one_off_latch.rb
+- lib/floss/peer.rb
+- lib/floss/proxy.rb
+- lib/floss/rpc.rb
+- lib/floss/rpc/in_memory.rb
+- lib/floss/rpc/zmq.rb
+- lib/floss/test_helper.rb
+- lib/floss/version.rb
+- log/.gitkeep
+- rloss.gemspec
+- spec/functional/log_spec.rb
+- spec/functional/node_spec.rb
+- spec/functional/rpc_spec.rb
+- spec/spec_helper.rb
+- test.rb
+homepage: https://github.com/rranshous/rloss
+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.5.2
+signing_key: 
+specification_version: 4
+summary: Floss is an implementation of the Raft distributed consensus protocol for
+  Celluloid
+test_files:
+- spec/functional/log_spec.rb
+- spec/functional/node_spec.rb
+- spec/functional/rpc_spec.rb
+- spec/spec_helper.rb