moleculer 0.1.0

data/lib/moleculer/broker.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require_relative "registry"
+require_relative "transporters"
+require_relative "support"
+
+module Moleculer
+  ##
+  # The Broker is the primary component of Moleculer. It handles action, events, and communication with remote nodes.
+  # Only a single broker should be run for any given process, and it is automatically started when Moleculer::start or
+  # Moleculer::run is called.
+  class Broker
+    include Moleculer::Support
+    extend Forwardable
+    attr_reader :config
+
+    def_delegators :@config, :node_id, :heartbeat_interval, :services, :service_prefix
+
+    ##
+    # @param config [Moleculer::Config] the broker configuration
+    def initialize(config)
+      @config = config
+
+      @config.broker = self
+
+      @logger      = @config.logger.get_child("[BROKER]")
+      @registry    = Registry.new(@config)
+      @transporter = Transporters.for(@config.transporter).new(@config)
+      @contexts    = Concurrent::Map.new
+    end
+
+    ##
+    # Call the provided action.
+    #
+    # @param action_name [String] the action to call.
+    # @param params [Hash] the params with which to call the action
+    # @param meta [Hash] the metadata of the request
+    #
+    # @return [Hash] the return result of the action call
+    def call(action_name, params, meta: {}, node_id: nil, timeout: Moleculer.config.timeout)
+      action = node_id ? @registry.fetch_action_for_node_id(action_name, node_id) : @registry.fetch_action(action_name)
+
+      context = Context.new(
+        broker:  self,
+        action:  action,
+        params:  params,
+        meta:    meta,
+        timeout: timeout,
+      )
+
+      future = Concurrent::Promises.resolvable_future
+
+      @contexts[context.id] = {
+        context:   context,
+        called_at: Time.now,
+        future:    future,
+      }
+
+      action.execute(context, self)
+
+      future.value!(context.timeout)
+    end
+
+    def emit(event_name, payload)
+      @logger.debug("emitting event '#{event_name}'")
+      events = @registry.fetch_events_for_emit(event_name)
+
+      events.each { |e| e.execute(payload, self) }
+    end
+
+    def run
+      self_read, self_write = IO.pipe
+
+      %w[INT TERM].each do |sig|
+        trap sig do
+          self_write.puts(sig)
+        end
+      end
+
+      begin
+        start
+
+        while (readable_io = IO.select([self_read]))
+          signal           = readable_io.first[0].gets.strip
+          handle_signal(signal)
+        end
+      rescue Interrupt
+        stop
+      end
+    end
+
+    def start
+      @logger.info "starting"
+      @transporter.connect
+      register_local_node
+      start_subscribers
+      publish_discover
+      publish_info
+      start_heartbeat
+      self
+    end
+
+    def stop
+      @logger.info "stopping"
+      publish(:disconnect)
+      @transporter.disconnect
+      exit 0
+    end
+
+    def wait_for_services(*services)
+      until (services = @registry.missing_services(*services)) && services.empty?
+        @logger.info "waiting for services '#{services.join(', ')}'"
+        sleep 0.1
+      end
+    end
+
+    def local_node
+      @registry.local_node
+    end
+
+    ##
+    # Processes an incoming message and passes it to the appropriate channel for handling
+    #
+    # @param [String] channel the channel in which the message came in on
+    # @param [Hash] message the raw deserialized message
+    def process_message(channel, message)
+      subscribers[channel] << Packets.for(channel.split(".")[1]).new(message) if subscribers[channel]
+    rescue StandardError => e
+      @logger.error e
+    end
+
+    def process_response(packet)
+      context = @contexts.delete(packet.id)
+      context[:future].fulfill(packet.data)
+    end
+
+    def process_event(packet)
+      @logger.debug("processing event '#{packet.event}'")
+      events = @registry.fetch_events_for_node_id(packet.event, node_id)
+
+      events.each { |e| e.execute(packet.data) }
+    rescue StandardError => e
+      @logger.error e
+    end
+
+    def process_request(packet)
+      @logger.debug "processing request #{packet.id}"
+      action = @registry.fetch_action_for_node_id(packet.action, node_id)
+      node   = @registry.fetch_node(packet.sender)
+
+      context = Context.new(
+        id:      packet.id,
+        broker:  self,
+        action:  action,
+        params:  packet.params,
+        meta:    packet.meta,
+        timeout: @config.timeout,
+      )
+
+      response = action.execute(context, self)
+
+      publish_res(
+        id:      context.id,
+        success: true,
+        data:    response,
+        error:   {},
+        meta:    context.meta,
+        stream:  false,
+        node:    node,
+      )
+    end
+
+    private
+
+    def handle_signal(sig)
+      case sig
+      when "INT", "TERM"
+        raise Interrupt
+      end
+    end
+
+    def publish(packet_type, message = {})
+      packet = Packets.for(packet_type).new(message)
+      @transporter.publish(packet)
+    end
+
+    def publish_event(event_data)
+      publish_to_node(:event, event_data.delete(:node), event_data)
+    end
+
+    def publish_heartbeat
+      publish(:heartbeat)
+    end
+
+    ##
+    # Publishes the discover packet
+    def publish_discover
+      publish(:discover)
+    end
+
+    def publish_info(node_id = nil)
+      return publish(:info, @registry.local_node.as_json) unless node_id
+
+      node = @registry.safe_fetch_node(node_id) || node_id
+      publish_to_node(:info, node, @registry.local_node.as_json)
+    end
+
+    def publish_req(request_data)
+      publish_to_node(:req, request_data.delete(:node), request_data)
+    end
+
+    def publish_res(response_data)
+      publish_to_node(:res, response_data.delete(:node), response_data)
+    end
+
+    def publish_to_node(packet_type, node, message = {})
+      packet = Packets.for(packet_type).new(message.merge(node: node))
+      @transporter.publish(packet)
+    end
+
+    def register_local_node
+      @logger.info "registering #{services.length} local services"
+      node = Node.new(
+        node_id:  node_id,
+        services: services,
+        local:    true,
+      )
+      @registry.register_node(node)
+    end
+
+    def register_or_update_remote_node(info_packet)
+      node = Node.from_remote_info(info_packet)
+      @registry.register_node(node)
+    end
+
+    def register_local_services
+      services.each do |service|
+        register_service(service)
+      end
+    end
+
+    def register_service(service)
+      @registry.register_local_service(service)
+    end
+
+    def start_heartbeat
+      Concurrent::TimerTask.new(execution_interval: heartbeat_interval) do
+        publish_heartbeat
+        @registry.expire_nodes
+      end.execute
+    end
+
+    def start_subscribers
+      subscribe_to_info
+      subscribe_to_res
+      subscribe_to_req
+      subscribe_to_events
+      subscribe_to_discover
+      subscribe_to_disconnect
+      subscribe_to_heartbeat
+    end
+
+    def subscribe_to_events
+      subscribe("MOL.EVENT.#{node_id}") do |packet|
+        process_event(packet)
+      end
+    end
+
+    def subscribe_to_info
+      subscribe("MOL.INFO.#{node_id}") do |packet|
+        register_or_update_remote_node(packet)
+      end
+      subscribe("MOL.INFO") do |packet|
+        register_or_update_remote_node(packet)
+      end
+    end
+
+    def subscribe_to_res
+      subscribe("MOL.RES.#{node_id}") do |packet|
+        process_response(packet)
+      end
+    end
+
+    def subscribe_to_req
+      subscribe("MOL.REQ.#{node_id}") do |packet|
+        process_request(packet)
+      end
+    end
+
+    def subscribe_to_discover
+      subscribe("MOL.DISCOVER") do |packet|
+        publish_info(packet.sender) unless packet.sender == node_id
+      end
+      subscribe("MOL.DISCOVER.#{node_id}") do |packet|
+        publish_info(packet.sender)
+      end
+    end
+
+    def subscribe_to_heartbeat
+      subscribe("MOL.HEARTBEAT") do |packet|
+        node = @registry.safe_fetch_node(packet.sender)
+        node.beat
+      end
+    end
+
+    def subscribe_to_disconnect
+      subscribe("MOL.DISCONNECT") do |packet|
+        @registry.remove_node(packet.sender)
+      end
+    end
+
+    def subscribe(channel, &block)
+      @transporter.subscribe(channel, &block)
+    end
+  end
+end

data/lib/moleculer/configuration.rb

@@ -0,0 +1,109 @@
+module Moleculer
+  ##
+  # Handles Moleculer configuration
+  # @private
+  class Configuration
+    ##
+    # @private
+    class ServiceList
+      def initialize(configuration)
+        @configuration = configuration
+        @services      = []
+      end
+
+      def <<(service)
+        service.broker = @configuration.broker
+        @services << service
+      end
+
+      def length
+        @services.length
+      end
+
+      def first
+        @services.first
+      end
+
+      def map(&block)
+        @services.map(&block)
+      end
+
+      def include?(service)
+        @services.include?(service)
+      end
+    end
+
+    private_constant :ServiceList
+
+    class << self
+      attr_reader :accessors
+
+      private
+
+      def config_accessor(attribute, default = nil, &block)
+        @accessors                 ||= {}
+        @accessors[attribute.to_sym] = { default: default, block: block }
+
+        class_eval <<-method
+          def #{attribute}
+            @#{attribute} ||= default_for("#{attribute}".to_sym)
+          end
+        method
+
+        instance_eval do
+          attr_writer attribute.to_sym
+        end
+      end
+    end
+
+    config_accessor :log_file
+    config_accessor :log_level, :debug
+    config_accessor :logger do |c|
+      logger           = Ougai::Logger.new(c.log_file || STDOUT)
+      logger.formatter = Ougai::Formatters::Readable.new("MOL")
+      logger.level     = c.log_level
+      Moleculer::Support::LogProxy.new(logger)
+    end
+    config_accessor :heartbeat_interval, 5
+    config_accessor :timeout, 5
+    config_accessor :transporter, "redis://localhost"
+    config_accessor :serializer, :json
+    config_accessor :node_id, "#{Socket.gethostname.downcase}-#{Process.pid}"
+    config_accessor :service_prefix
+
+    attr_accessor :broker
+
+    def initialize(options={})
+      options.each do |option, value|
+        send("#{option}=".to_sym, value)
+      end
+    end
+
+    def services
+      @services ||= ServiceList.new(self)
+    end
+
+    def services=(array)
+      @services = ServiceList.new(self)
+      array.each { |s| @services << s}
+    end
+
+    private
+
+    def accessors
+      self.class.accessors
+    end
+
+    def default_for(attribute)
+      accessors[attribute][:default] || (has_block_for?(attribute) ? block_for(attribute).call(self) : nil)
+    end
+
+    def block_for(attribute)
+      accessors[attribute][:block]
+    end
+
+    def has_block_for?(attribute)
+      accessors[attribute][:block] && true
+    end
+  end
+end

data/lib/moleculer/context.rb

@@ -0,0 +1,24 @@
+module Moleculer
+  class Context
+    attr_reader :request_id,
+                :action,
+                :params,
+                :meta,
+                :level,
+                :timeout,
+                :id
+
+    def initialize(broker:, action:, params:, meta:, parent_id: nil, level: 1, timeout:, id: nil)
+      @id         = id ? id : SecureRandom.uuid
+      @broker     = broker
+      @action     = action
+      @request_id = SecureRandom.uuid
+      @parent_id  = parent_id
+      @params     = params
+      @meta       = meta
+      @level      = level
+      @timeout    = timeout
+    end
+
+  end
+end

data/lib/moleculer/errors/action_not_found.rb

@@ -0,0 +1,6 @@
+module Moleculer
+  module Errors
+    class ActionNotFound < StandardError
+    end
+  end
+end

data/lib/moleculer/errors/invalid_action_response.rb

@@ -0,0 +1,11 @@
+module Moleculer
+  module Errors
+    ##
+    # Raised when an action does not return a hash
+    class InvalidActionResponse < StandardError
+      def initialize(response)
+        super "Action must return a Hash, instead it returned a #{response.class.name}"
+      end
+    end
+  end
+end

data/lib/moleculer/errors/local_node_already_registered.rb

@@ -0,0 +1,6 @@
+module Moleculer
+  module Errors
+    class LocalNodeAlreadyRegistered < StandardError
+    end
+  end
+end

data/lib/moleculer/errors/node_not_found.rb

@@ -0,0 +1,6 @@
+module Moleculer
+  module Errors
+    class NodeNotFound < StandardError
+    end
+  end
+end

data/lib/moleculer/errors/transporter_already_started.rb

@@ -0,0 +1,6 @@
+module Moleculer
+  module Errors
+    class TransporterAlreadyStarted < StandardError
+    end
+  end
+end

data/lib/moleculer/node.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Moleculer
+  ##
+  # Nodes are a representation of communicating apps within the same event bus.
+  # A node is something that emits/listens to events within the bus and
+  # communicates accordingly.
+  class Node
+    class << self
+      def from_remote_info(info_packet)
+        new(
+          services: info_packet.services,
+          node_id:  info_packet.sender,
+        )
+      end
+    end
+
+    attr_reader :id,
+                :services
+
+    def initialize(options = {})
+      @id       = options.fetch(:node_id)
+      @local    = options.fetch(:local, false)
+      @hostname = options.fetch(:hostname, Socket.gethostname)
+
+      svcs = options.fetch(:services)
+      # TODO: move this up to from_remote_info
+      svcs.map! { |service| Service.from_remote_info(service, self) } if svcs.first.is_a? Hash
+      @services = Hash[svcs.map { |s| [s.service_name, s] }]
+    end
+
+    def register_service(service)
+      @services[service.name] = service
+    end
+
+    ##
+    # @return [Hash] returns a key, value mapping of available actions on this node
+    # TODO: refactor this into a list object
+    def actions
+      unless @actions
+        @actions = {}
+
+        @services.each_value { |s| s.actions.each { |key, value| @actions[key] = value } }
+      end
+      @actions
+    end
+
+    ##
+    # @return [Hash] returns a key value mapping of events on this node
+    # TODO: refactor this into a list object
+    def events
+      unless @events
+        @events = {}
+        @services.each_value do |s|
+          s.events.each do |key, value|
+            @events[key] ||= []
+            @events[key] << value
+          end
+        end
+      end
+      @events
+    end
+
+    ##
+    # @return [Time] the time of the last heartbeat, or Time#now if the node is local.
+    def last_heartbeat_at
+      return Time.now if local?
+
+      @last_heartbeat_at || Time.now
+    end
+
+    ##
+    # Updates the last heartbeat to Time#now
+    def beat
+      @last_heartbeat_at = Time.now
+    end
+
+    def local?
+      @local
+    end
+
+    def as_json
+      {
+        config:   {},
+        seq:      1,
+        ipList:   [],
+        hostname: @hostname,
+        services: @services.values.map(&:as_json),
+        client:   client_attrubutes
+      }
+    end
+
+    private
+
+    def client_attrubutes
+      {
+        type:         "Ruby",
+        version:      Moleculer::VERSION,
+        lang_version: RUBY_VERSION
+      }
+    end
+  end
+end

data/lib/moleculer/packets/base.rb

@@ -0,0 +1,47 @@
+require_relative "../support"
+
+module Moleculer
+  module Packets
+    ##
+    # @abstract Subclass for packet types.
+    class Base
+      include Support
+      ##
+      # The protocol version
+      attr_reader :ver
+
+      ##
+      # The sender of the packet
+      attr_reader :sender
+
+      def self.packet_name
+        name.split("::").last.upcase
+      end
+
+      ##
+      # @param data [Hash] the raw packet data
+      # @options data [String] :ver the protocol version, defaults to `'3'`
+      # @options  data [String] :sender the packet sender, defaults to `Moleculer#node_id`
+      def initialize(data = {})
+        @ver    = HashUtil.fetch(data, :ver, "3")
+        @sender = HashUtil.fetch(data, :sender, Moleculer.config.node_id)
+      end
+
+      ##
+      # The publishing topic for the packet. This is used to publish packets to the moleculer network. Override as
+      # needed.
+      #
+      # @return [String] the pub/sub topic to publish to
+      def topic
+        "MOL.#{self.class.packet_name}"
+      end
+
+      def as_json
+        {
+          ver:    ver,
+          sender: sender,
+        }
+      end
+    end
+  end
+end

data/lib/moleculer/packets/disconnect.rb

@@ -0,0 +1,10 @@
+require_relative "base"
+
+module Moleculer
+  module Packets
+    ##
+    # Represents a DISCONNECT packet
+    class Disconnect < Base
+    end
+  end
+end

data/lib/moleculer/packets/discover.rb

@@ -0,0 +1,10 @@
+require_relative "base"
+
+module Moleculer
+  module Packets
+    ##
+    # Represents a DISCOVER packet
+    class Discover < Base
+    end
+  end
+end

data/lib/moleculer/packets/event.rb

@@ -0,0 +1,37 @@
+require_relative "base"
+
+module Moleculer
+  module Packets
+    ##
+    # Represents a EVENT packet
+    class Event < Base
+      attr_reader :event,
+                  :data,
+                  :broadcast,
+                  :groups
+
+      def initialize(data)
+        super(data)
+
+        @event     = HashUtil.fetch(data, :event)
+        @data      = HashUtil.fetch(data, :data)
+        @broadcast = HashUtil.fetch(data, :broadcast)
+        @groups    = HashUtil.fetch(data, :groups, [])
+        @node      = HashUtil.fetch(data, :node, nil)
+      end
+
+      def as_json
+        super.merge(
+          event:     @event,
+          data:      @data,
+          broadcast: @broadcast,
+          groups:    @groups,
+        )
+      end
+
+      def topic
+        "#{super}.#{@node.id}"
+      end
+    end
+  end
+end