aggro 0.0.1 → 0.0.2

data/lib/aggro/nanomsg_transport/client.rb

@@ -0,0 +1,35 @@
+require 'aggro/nanomsg_transport/request'
+
+module Aggro
+  module NanomsgTransport
+    # Public: Client for making requests against a nanomsg server.
+    class Client
+      def initialize(endpoint)
+        ObjectSpace.define_finalizer self, method(:close_socket)
+
+        @endpoint = endpoint
+      end
+
+      def post(message)
+        request_socket.send_msg message
+
+        request_socket.recv_msg
+      end
+
+      def close_socket
+        request_socket.terminate if @open
+        @request_socket = nil
+        @open = false
+      end
+
+      private
+
+      def request_socket
+        @request_socket ||= begin
+          @open = true
+          Request.new(@endpoint)
+        end
+      end
+    end
+  end
+end

data/lib/aggro/nanomsg_transport/connection.rb

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,17 @@
+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/publisher.rb

@@ -0,0 +1,37 @@
+require 'aggro/nanomsg_transport/publish'
+
+module Aggro
+  module NanomsgTransport
+    # Public: Handles publishing messages on a given endpoint.
+    class Publisher
+      def initialize(endpoint)
+        ObjectSpace.define_finalizer self, method(:close_socket)
+
+        @endpoint = endpoint
+      end
+
+      def close_socket
+        pub_socket.terminate if @open
+        @pub_socket = nil
+        @open = false
+      end
+
+      def open_socket
+        return @pub_socket if @open
+
+        @open = true
+        @pub_socket = Publish.new(@endpoint)
+      end
+
+      def publish(message)
+        pub_socket.send_msg message
+      end
+
+      private
+
+      def pub_socket
+        @pub_socket || open_socket
+      end
+    end
+  end
+end

data/lib/aggro/nanomsg_transport/raw_reply.rb

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,27 @@
+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/lib/aggro/nanomsg_transport/subscriber.rb

@@ -0,0 +1,82 @@
+require 'aggro/nanomsg_transport/subscribe'
+
+module Aggro
+  module NanomsgTransport
+    # Public: Handles subscribing to messages on a given endpoint.
+    class Subscriber
+      class SubscriberAlreadyRunning < RuntimeError; end
+
+      def initialize(endpoint, callable = nil, &block)
+        fail ArgumentError unless callable || block_given?
+
+        @callable = block_given? ? block : callable
+        @endpoint = endpoint
+        @mutex = Mutex.new
+        @selector = NIO::Selector.new
+
+        ObjectSpace.define_finalizer self, method(:stop)
+      end
+
+      def add_subscription(topic)
+        start unless @running
+
+        @mutex.synchronize do
+          sub_socket.add_subscription(topic)
+        end
+
+        self
+      end
+
+      def start
+        @mutex.synchronize do
+          return self if @running
+
+          @running = true
+          start_on_thread
+
+          sleep 0.01 while @selector.empty?
+        end
+
+        self
+      end
+
+      def stop
+        @mutex.synchronize do
+          return self unless @running
+
+          @running = false
+          @selector.wakeup
+
+          sleep 0.01 until @selector.empty?
+        end
+
+        self
+      end
+
+      private
+
+      def handle_message
+        message = sub_socket.recv_msg
+        @callable.call(message) if message
+      end
+
+      def sub_socket
+        @sub_socket ||= Subscribe.new(@endpoint)
+      end
+
+      def start_on_thread
+        Concurrent::SingleThreadExecutor.new.post do
+          io = IO.new(sub_socket.recv_fd, 'rb', autoclose: false)
+          @selector.register io, :r
+
+          @selector.select { handle_message } while @running
+
+          @selector.deregister io
+          io.close
+          sub_socket.terminate
+          @sub_socket = nil
+        end
+      end
+    end
+  end
+end