aggro 0.0.3 → 0.0.4

data/lib/aggro/logging.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+module Aggro
+  # Private: Mixin for logging concerns.
+  module Logging
+    include Logger::Severity
+
+    def log(level, progname, message = nil, &block)
+      (@logger || Aggro.logger).call level, progname, message, &block
+    rescue => e
+      $stderr.puts '`Aggro.logger` failed to log ' \
+                   "#{[level, progname, message, block].join(' ')}\n" \
+                   "#{e.message} (#{e.class})\n#{e.backtrace.join "\n"}"
+    end
+  end
+end

data/lib/aggro/marshal_stream.rb

@@ -0,0 +1,123 @@
+# Private: Wrapper around an IO object to read/write Marshaled objects.
+class MarshalStream
+  include Enumerable
+
+  DEFAULT_MAX_OUTBOX = 10
+
+  class StreamError < StandardError; end
+
+  attr_reader :io
+  attr_reader :max_outbox
+
+  def initialize(io, max_outbox: DEFAULT_MAX_OUTBOX)
+    @io = io
+    @max_outbox = max_outbox
+    @inbox = []
+    @outbox = []
+  end
+
+  def close
+    flush_outbox
+    io.close
+  end
+
+  def closed?
+    io.closed?
+  end
+
+  def each
+    return to_enum unless block_given?
+
+    read { |obj| yield obj } until eof
+  end
+
+  def eof?
+    inbox.empty? && io.eof?
+  end
+
+  alias_method :eof, :eof?
+
+  def flush_buffer
+    self
+  end
+
+  def flush_outbox
+    outbox.each { |obj| write_to_stream(obj.is_a? Proc ? obj.call : obj) }
+    outbox.clear
+
+    self
+  end
+
+  def read
+    if block_given?
+      read_from_inbox { |obj| yield obj }
+      read_from_stream { |obj| yield obj }
+
+      nil
+    else
+      read_one
+    end
+  end
+
+  def read_from_stream
+    yield Marshal.load(io)
+  rescue IOError, SystemCallError
+    raise
+  rescue => e
+    raise StreamError, "Unreadble stream: #{e}"
+  end
+
+  def read_one
+    return inbox.shift unless inbox.empty?
+
+    result = nil
+
+    read { |obj| result.nil? ? result = obj : (inbox << obj) } while result.nil?
+
+    result
+  end
+
+  def to_io
+    io
+  end
+
+  def write(*objects)
+    write_to_buffer(*objects)
+    flush_buffer
+  end
+
+  alias_method :<<, :write
+
+  def write_to_buffer(*objects)
+    flush_outbox
+    objects.each { |object| write_to_stream object }
+
+    self
+  end
+
+  def write_to_outbox(object = nil, &block)
+    outbox << (block || object)
+
+    flush_outbox if outbox.size > max_outbox
+
+    self
+  end
+
+  def write_to_stream(object)
+    Marshal.dump(object, io)
+
+    self
+  end
+
+  private
+
+  attr_reader :inbox
+  attr_reader :outbox
+
+  def read_from_inbox
+    return if inbox.empty?
+
+    inbox.each { |obj| yield obj }
+    inbox.clear
+  end
+end

data/lib/aggro/message/events.rb

@@ -9,11 +9,15 @@ module Aggro
       end
 
       def self.parse_events(string)
-        ObjectStream.new(StringIO.new(string), type: 'marshal')
+        Enumerator.new do |yielder|
+          MarshalStream.new(StringIO.new(string)).each do |raw_event|
+            yielder << EventSerializer.deserialize(raw_event)
+          end
+        end
       end
 
       def serialize_events
-        events.map { |event| EventSerializer.serialize event }.join
+        events.map { |event| Marshal.dump EventSerializer.serialize event }.join
       end
 
       def to_s

data/lib/aggro/message/server_error.rb

@@ -0,0 +1,20 @@
+module Aggro
+  module Message
+    # Public: OK message.
+    class ServerError
+      TYPE_CODE = '00'.freeze
+
+      def self.parse(_string)
+        new
+      end
+
+      def self.new
+        @singleton ||= super
+      end
+
+      def to_s
+        "#{TYPE_CODE}"
+      end
+    end
+  end
+end

data/lib/aggro/node.rb

@@ -20,7 +20,9 @@ module Aggro
       response = client.post(message)
 
       if response.is_a? Message::Endpoint
-        response.endpoint
+        port = URI.parse(response.endpoint).port
+
+        URI.parse(endpoint).tap { |uri| uri.port = port }.to_s
       else
         fail "Could not discover publisher endpoint for #{id}"
       end

data/lib/aggro/projection.rb

@@ -7,6 +7,7 @@ module Aggro
     include EventDSL
 
     def initialize(id)
+      @id = id
       Aggro.event_bus.subscribe(id, self)
     end
   end

data/lib/aggro/server.rb

@@ -35,8 +35,8 @@ module Aggro
     end
 
     def stop
-      @transport_server.stop
       @transport_publisher.close_socket
+      @transport_server.stop
     end
 
     private
@@ -80,9 +80,5 @@ module Aggro
         end
       end
     end
-
-    def publisher
-      @publisher ||= Publisher.new(local_node.publisher_endpoint)
-    end
   end
 end

data/lib/aggro/subscription.rb

@@ -1,6 +1,8 @@
 module Aggro
   # Private: Handles invoking events on a subscriber object.
   class Subscription
+    attr_reader :caught_up
+
     def initialize(topic, subscriber, namespace, filters, at_version)
       @topic = topic
       @subscriber = subscriber
@@ -21,15 +23,27 @@ module Aggro
       invoke(event) if handles_event?(event) && matches_filter?(event)
     end
 
+    def notify_subscription_caught_up
+      @caught_up = true
+
+      return unless @subscriber.handles_event? :caught_up, @namespace
+
+      @subscriber.send "#{@namespace}_caught_up"
+    end
+
     private
 
+    def expand_event(event)
+      event.details.merge now: event.occured_at, today: event.occured_at.to_date
+    end
+
     def handles_event?(event)
       @subscriber.handles_event? event.name, @namespace
     end
 
     def invoke(event)
-      Invokr.invoke method: "#{@namespace}_#{event.name}",
-                    using: event.details, on: @subscriber
+      Invokr.invoke method: "#{@namespace}_#{event.name}", on: @subscriber,
+                    using: expand_event(event)
     end
 
     def matches_filter?(event)

data/lib/aggro/transform/boolean.rb

@@ -5,12 +5,24 @@ module Aggro
       module_function
 
       def deserialize(value)
-        value if value == false || value == true
+        value if truthy?(value) || falsey?(value)
       end
 
       def serialize(value)
-        value if value == false || value == true
+        value if truthy?(value) || falsey?(value)
       end
+
+      def falsey?(value)
+        value == false || value == 'false' || value == '0'
+      end
+
+      private :falsey?
+
+      def truthy?(value)
+        value == true || value == 'true' || value == '1'
+      end
+
+      private :truthy?
     end
   end
 end

data/lib/aggro/transform/date.rb

@@ -0,0 +1,22 @@
+module Aggro
+  module Transform
+    # Private: Transforms date representations.
+    module Date
+      module_function
+
+      def deserialize(value)
+        if value.is_a? ::String
+          ::Date.parse(value)
+        elsif value.is_a? ::Integer
+          ::Date.parse(value.to_s)
+        elsif value.is_a? ::Date
+          value
+        end
+      end
+
+      def serialize(value)
+        value.to_s if value.is_a? ::Date
+      end
+    end
+  end
+end

data/lib/aggro/transform/string.rb

@@ -5,11 +5,11 @@ module Aggro
       module_function
 
       def deserialize(value)
-        value.to_s
+        value.to_s unless value.nil?
       end
 
       def serialize(value)
-        value.to_s
+        value.to_s unless value.nil?
       end
     end
   end

data/lib/aggro/transform/time.rb

@@ -0,0 +1,22 @@
+module Aggro
+  module Transform
+    # Private: Transforms time representations.
+    module Time
+      module_function
+
+      def deserialize(value)
+        if value.is_a? ::String
+          ::Time.parse(value)
+        elsif value.is_a? ::Integer
+          ::Time.parse(value.to_s)
+        elsif value.is_a? ::Time
+          value
+        end
+      end
+
+      def serialize(value)
+        value.to_s if value.is_a? ::Time
+      end
+    end
+  end
+end

data/lib/aggro/version.rb

@@ -1,3 +1,3 @@
 module Aggro
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/aggro/zeromq_transport.rb

@@ -0,0 +1,44 @@
+require 'aggro/zeromq_transport/client'
+require 'aggro/zeromq_transport/publisher'
+require 'aggro/zeromq_transport/server'
+require 'aggro/zeromq_transport/subscriber'
+
+module Aggro
+  # Public: Transport layer over nanomsg sockets.
+  module ZeroMQTransport
+    class << self
+      attr_writer :linger
+    end
+
+    module_function
+
+    def client(endpoint)
+      Client.new endpoint
+    end
+
+    def context
+      @context ||= ZeroMQ::Context.new
+    end
+
+    def linger
+      @linger ||= 1_000
+    end
+
+    def publisher(endpoint)
+      Publisher.new endpoint
+    end
+
+    def server(endpoint, callable = nil, &block)
+      Server.new endpoint, callable, &block
+    end
+
+    def subscriber(endpoint, callable = nil, &block)
+      Subscriber.new endpoint, callable, &block
+    end
+
+    def teardown
+      @context.terminate if @context
+      @context = nil
+    end
+  end
+end

data/lib/aggro/{nanomsg_transport → zeromq_transport}/client.rb

@@ -1,23 +1,22 @@
-require 'aggro/nanomsg_transport/request'
-
 module Aggro
-  module NanomsgTransport
+  module ZeroMQTransport
     # 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.send_string message.to_s
 
-        request_socket.recv_msg
+        response = ''
+        request_socket.recv_string response
+
+        response
       end
 
       def close_socket
-        request_socket.terminate if @open
+        request_socket.close if @open
         @request_socket = nil
         @open = false
       end
@@ -27,7 +26,10 @@ module Aggro
       def request_socket
         @request_socket ||= begin
           @open = true
-          Request.new(@endpoint)
+          socket = ZeroMQTransport.context.socket(ZMQ::REQ)
+          socket.connect @endpoint
+
+          socket
         end
       end
     end

data/lib/aggro/{nanomsg_transport → zeromq_transport}/publisher.rb

@@ -1,17 +1,15 @@
-require 'aggro/nanomsg_transport/publish'
-
 module Aggro
-  module NanomsgTransport
+  module ZeroMQTransport
     # 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
+        return unless @open && @pub_socket
+
+        @pub_socket.close if @pub_socket
         @pub_socket = nil
         @open = false
       end
@@ -20,11 +18,16 @@ module Aggro
         return @pub_socket if @open
 
         @open = true
-        @pub_socket = Publish.new(@endpoint)
+
+        @pub_socket = ZeroMQTransport.context.socket(ZMQ::PUB)
+        @pub_socket.setsockopt ZMQ::LINGER, 1_000
+        @pub_socket.bind @endpoint
+
+        @pub_socket
       end
 
       def publish(message)
-        pub_socket.send_msg message
+        pub_socket.send_string message.to_s
       end
 
       private