aggro 0.0.3 → 0.0.4

data/lib/aggro/abstract_store.rb

@@ -1,12 +0,0 @@
-module Aggro
-  # Private: Abstract class for an event store.
-  class AbstractStore
-    def read(_refs)
-      fail NotImplementedError
-    end
-
-    def write(_event_streams)
-      fail NotImplementedError
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/connection.rb

@@ -1,98 +0,0 @@
-require 'ffi'
-require 'nn-core'
-require 'aggro/nanomsg_transport/socket_error'
-
-module Aggro
-  module NanomsgTransport
-    # Private: Base class for nanomsg socket wrappers.
-    class Connection
-      attr_reader :socket
-
-      def initialize(endpoint)
-        @endpoint = endpoint
-        @rcv_buffer = FFI::MemoryPointer.new(:pointer)
-
-        allocate_socket
-        setup_socket
-        set_endpoint
-      end
-
-      def setup_socket
-        set_socket_option NNCore::NN_LINGER, 100
-        set_socket_option NNCore::NN_SNDBUF, 131_072
-        set_socket_option NNCore::NN_RCVBUF, 131_072
-      end
-
-      def send_msg(stringable)
-        msg = stringable.to_s
-        nbytes = NNCore::LibNanomsg.nn_send(@socket, msg, msg.bytesize, 0)
-        assert(nbytes)
-
-        nbytes
-      end
-
-      def recv_fd
-        get_socket_option NNCore::NN_RCVFD
-      end
-
-      def recv_msg
-        nbytes = NNCore::LibNanomsg.nn_recv(@socket, @rcv_buffer,
-                                            NNCore::NN_MSG, 0)
-
-        assert(nbytes)
-
-        str = @rcv_buffer.read_pointer
-        response = str.read_string(nbytes)
-        NNCore::LibNanomsg.nn_freemsg str
-
-        response
-      rescue SocketError => e
-        raise e unless e.errno == NNCore::EAGAIN
-
-        nil
-      end
-
-      def terminate
-        assert NNCore::LibNanomsg.nn_close(@socket)
-      end
-
-      protected
-
-      def assert(rc)
-        fail SocketError.new NNCore::LibNanomsg.nn_errno unless rc >= 0
-      end
-
-      def get_socket_option(setting, level = NNCore::NN_SOL_SOCKET)
-        result = FFI::MemoryPointer.new(:int32)
-        size = FFI::MemoryPointer.new(:size_t)
-        size.write_int result.size
-
-        rc = NNCore::LibNanomsg.nn_getsockopt(@socket, level, setting,
-                                              result, size)
-
-        assert(rc)
-
-        result.read_int
-      end
-
-      def prepare_socket_option(value)
-        if value.is_a? String
-          [value, value.bytesize]
-        else
-          option = FFI::MemoryPointer.new(:int32)
-          option.write_int(value)
-
-          [option, 4]
-        end
-      end
-
-      def set_socket_option(setting, value, level = NNCore::NN_SOL_SOCKET)
-        option, option_length = prepare_socket_option(value)
-
-        rc = NNCore::LibNanomsg.nn_setsockopt(@socket, level, setting,
-                                              option, option_length)
-        assert(rc)
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/publish.rb

@@ -1,17 +0,0 @@
-require 'aggro/nanomsg_transport/connection'
-
-module Aggro
-  module NanomsgTransport
-    # Private: Wrapper for a nanomsg PUB node.
-    class Publish < Connection
-      def allocate_socket
-        @socket = NNCore::LibNanomsg.nn_socket(NNCore::AF_SP, NNCore::NN_PUB)
-        assert @socket
-      end
-
-      def set_endpoint
-        assert NNCore::LibNanomsg.nn_bind(@socket, @endpoint)
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/raw_reply.rb

@@ -1,18 +0,0 @@
-require 'aggro/nanomsg_transport/connection'
-
-module Aggro
-  module NanomsgTransport
-    # Private: Wrapper for a nanomsg XREP node.
-    class RawReply < Connection
-      def allocate_socket
-        @socket = NNCore::LibNanomsg.nn_socket(NNCore::AF_SP_RAW,
-                                               NNCore::NN_REP)
-        assert @socket
-      end
-
-      def set_endpoint
-        assert NNCore::LibNanomsg.nn_bind(@socket, @endpoint)
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/raw_request.rb

@@ -1,18 +0,0 @@
-require 'aggro/nanomsg_transport/connection'
-
-module Aggro
-  module NanomsgTransport
-    # Private: Wrapper for a nanomsg XREQ node.
-    class RawRequest < Connection
-      def allocate_socket
-        @socket = NNCore::LibNanomsg.nn_socket(NNCore::AF_SP_RAW,
-                                               NNCore::NN_REQ)
-        assert @socket
-      end
-
-      def set_endpoint
-        assert NNCore::LibNanomsg.nn_bind(@socket, @endpoint)
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/reply.rb

@@ -1,17 +0,0 @@
-require 'aggro/nanomsg_transport/connection'
-
-module Aggro
-  module NanomsgTransport
-    # Private: Wrapper for a nanomsg REP node.
-    class Reply < Connection
-      def allocate_socket
-        @socket = NNCore::LibNanomsg.nn_socket(NNCore::AF_SP, NNCore::NN_REP)
-        assert @socket
-      end
-
-      def set_endpoint
-        assert NNCore::LibNanomsg.nn_connect(@socket, @endpoint)
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/request.rb

@@ -1,17 +0,0 @@
-require 'aggro/nanomsg_transport/connection'
-
-module Aggro
-  module NanomsgTransport
-    # Private: Wrapper for a nanomsg REQ node.
-    class Request < Connection
-      def allocate_socket
-        @socket = NNCore::LibNanomsg.nn_socket(NNCore::AF_SP, NNCore::NN_REQ)
-        assert @socket
-      end
-
-      def set_endpoint
-        assert NNCore::LibNanomsg.nn_connect(@socket, @endpoint)
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/server.rb

@@ -1,84 +0,0 @@
-require 'nio'
-
-require 'aggro/nanomsg_transport/raw_reply'
-require 'aggro/nanomsg_transport/raw_request'
-require 'aggro/nanomsg_transport/reply'
-
-module Aggro
-  module NanomsgTransport
-    # Public: Server to handle messages from nanomsg clients.
-    class Server
-      DEFAULT_WORKER_COUNT = 16
-
-      class ServerAlreadyRunning < RuntimeError; end
-
-      def initialize(endpoint, callable = nil, &block)
-        fail ArgumentError unless callable || block_given?
-
-        @callable = block_given? ? block : callable
-        @endpoint = endpoint
-        @selectors = DEFAULT_WORKER_COUNT.times.map { NIO::Selector.new }
-        @inproc_endpoint = "inproc://aggro-server-#{SecureRandom.hex}"
-
-        ObjectSpace.define_finalizer self, method(:stop)
-      end
-
-      def start
-        fail ServerAlreadyRunning if @running
-
-        @running = true
-        start_master
-        DEFAULT_WORKER_COUNT.times { |i| start_worker i }
-
-        sleep 0.01 while @selectors.any?(&:empty?)
-
-        self
-      end
-
-      def stop
-        return self unless @running
-
-        @running = false
-        @selectors.each(&:wakeup)
-
-        sleep 0.01 until @selectors.any?(&:empty?)
-
-        @raw_reply.terminate
-        @raw_request.terminate
-
-        self
-      end
-
-      private
-
-      def handle_request(socket)
-        message = socket.recv_msg
-        socket.send_msg @callable.call(message) if @running
-      end
-
-      def start_master
-        @master_thread = Concurrent::SingleThreadExecutor.new.post do
-          @raw_reply = RawReply.new(@endpoint)
-          @raw_request = RawRequest.new(@inproc_endpoint)
-
-          NNCore::LibNanomsg.nn_device @raw_request.socket, @raw_reply.socket
-        end
-      end
-
-      def start_worker(i)
-        Concurrent::SingleThreadExecutor.new.post do
-          reply = Reply.new(@inproc_endpoint)
-          io = IO.new(reply.recv_fd, 'rb', autoclose: false)
-
-          @selectors[i].register io, :r
-
-          @selectors[i].select { handle_request(reply) } while @running
-
-          @selectors[i].deregister io
-          io.close
-          reply.terminate
-        end
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/socket_error.rb

@@ -1,20 +0,0 @@
-module Aggro
-  module NanomsgTransport
-    # Public: An error calling the nanomsg API.
-    class SocketError < RuntimeError
-      attr_reader :errno
-
-      def initialize(errno)
-        @errno = errno
-      end
-
-      def error_message
-        NNCore::LibNanomsg.nn_strerror(errno)
-      end
-
-      def to_s
-        "Last nanomsg API call failed with '#{error_message}'"
-      end
-    end
-  end
-end

data/lib/aggro/nanomsg_transport/subscribe.rb

@@ -1,27 +0,0 @@
-require 'aggro/nanomsg_transport/connection'
-
-module Aggro
-  module NanomsgTransport
-    # Private: Wrapper for a nanomsg SUB node.
-    class Subscribe < Connection
-      def add_subscription(topic)
-        set_socket_option NNCore::NN_SUB_SUBSCRIBE, topic, NNCore::NN_SUB
-      end
-
-      def allocate_socket
-        @socket = NNCore::LibNanomsg.nn_socket(NNCore::AF_SP, NNCore::NN_SUB)
-        assert @socket
-      end
-
-      def set_endpoint
-        assert NNCore::LibNanomsg.nn_connect(@socket, @endpoint)
-      end
-
-      def setup_socket
-        super
-
-        set_socket_option NNCore::NN_RCVTIMEO, 100
-      end
-    end
-  end
-end

data/spec/lib/aggro/abstract_store_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe AbstractStore do
-  subject(:store) { AbstractStore.new }
-
-  describe '#read' do
-    it 'should raise not implemented error' do
-      expect { store.read(double) }.to raise_error NotImplementedError
-    end
-  end
-
-  describe '#write' do
-    it 'should raise not implemented error' do
-      expect { store.write(double) }.to raise_error NotImplementedError
-    end
-  end
-end

data/spec/lib/aggro/nanomsg_transport/socket_error_spec.rb

@@ -1,21 +0,0 @@
-RSpec.describe NanomsgTransport::SocketError do
-  subject(:error) { NanomsgTransport::SocketError.new 5 }
-
-  let(:nanomsg_api) { spy nn_strerror: 'No u' }
-
-  before do
-    stub_const 'NNCore::LibNanomsg', nanomsg_api
-  end
-
-  describe '#to_s' do
-    it 'should ask nanomsg for the meaning of the errno' do
-      error.to_s
-
-      expect(nanomsg_api).to have_received(:nn_strerror).with 5
-    end
-
-    it 'should provide a human readable error message' do
-      expect(error.to_s).to eq "Last nanomsg API call failed with 'No u'"
-    end
-  end
-end