moleculer 0.1.0

data/lib/moleculer/service/base.rb

@@ -0,0 +1,117 @@
+require_relative "action"
+require_relative "event"
+
+module Moleculer
+  module Service
+    ##
+    # @abstract subclass to define a local service.
+    class Base
+      class << self
+        # @!attribute [rw] service_prefix
+        #   @return [string] a prefix to add to the service name. The service_prefix is inherited from the parent class
+        #           if it is not already defined in the current class.
+        attr_writer :service_prefix
+
+        ##
+        # The broker this service is attached to
+        attr_accessor :broker
+
+        def service_prefix
+          Moleculer.service_prefix
+        end
+
+        def node
+          broker.local_node
+        end
+
+        def broker
+          @broker || Moleculer.broker
+        end
+
+        ##
+        # Set the service_name to the provided name. If the node is local it will prefix the service name with the
+        # service prefix
+        #
+        # @param name [String] the name to which the service_name should be set
+        def service_name(name = nil)
+          @service_name = name if name
+
+          return "#{broker.service_prefix}.#{@service_name}" unless broker.service_prefix.nil?
+
+          @service_name
+        end
+
+        ##
+        # Defines an action on the service.
+        #
+        # @param name [String|Symbol] the name of the action.
+        # @param method [Symbol] the method to which the action maps.
+        # @param options [Hash] the action options.
+        # @option options [Boolean|Hash] :cache if true, will use default caching options, if a hash is provided caching
+        # options will reflect the hash.
+        # @option options [Hash] params list of param and param types. Can be used to coerce specific params to the
+        # provided type.
+        def action(name, method, options = {})
+          actions[action_name_for(name)] = Action.new(name, self, method, options)
+        end
+
+        ##
+        # Defines an event on the service.
+        #
+        # @param name [String|Symbol] the name of the event.
+        # @param method [Symbol] the method to which the event maps.
+        # @param options [Hash] event options.
+        # @option options [Hash] :group the group in which the event should belong, defaults to the service_name
+        def event(name, method, options = {})
+          events[name] = Event.new(name, self, method, options)
+        end
+
+        def actions
+          @actions ||= {}
+        end
+
+        def events
+          @events ||= {}
+        end
+
+        def action_name_for(name)
+          "#{service_name}.#{name}"
+        end
+      end
+
+      def initialize(broker)
+        @broker = broker
+      end
+
+      ##
+      # returns the action defined on the service class
+      # @see action
+      def actions
+        self.class.actions
+      end
+
+      ##
+      # returns the events defined on the service class
+      # @see events
+      def events
+        self.class.events
+      end
+
+      ##
+      # @return [Moleculer::Broker] the moleculer broker the service is attached to
+      def broker
+        self.class.broker
+      end
+
+      def self.as_json
+        {
+          name:     service_name,
+          settings: {},
+          metadata: {},
+          actions:  Hash[actions.values.map { |a| [a.name.to_sym, a.as_json] }],
+          events:   Hash[events.values.map { |e| [e.name.to_sym, e.as_json] }],
+        }
+      end
+    end
+  end
+end

data/lib/moleculer/service/event.rb

@@ -0,0 +1,50 @@
+require_relative "../errors/invalid_action_response"
+require_relative "../support"
+module Moleculer
+  module Service
+    ##
+    # Represents a service event.
+    class Event
+      # @!attribute [r] name
+      #   @return [String] the name of the action
+      # @!attribute [r] service
+      #   @return [Moleculer::Service] the service that this event is tied to
+      attr_reader :name, :service
+
+      ##
+      # @param name [String] the name of the action
+      # @param service [Moleculer::Service] the service to which the action belongs
+      # @param method [Symbol] the method which the event calls when executed
+      # @param options [Hash] the method options
+      # TODO: add ability to group events
+      def initialize(name, service, method, options = {})
+        @name    = name
+        @service = service
+        @method  = method
+        @service = service
+        @options = options
+      end
+
+      ##
+      # Executes the event
+      # @param data [Hash] the event data
+      def execute(data, broker)
+        @service.new(broker).public_send(@method, data)
+      end
+
+      ##
+      # @return [Moleculer::Node] the node of the service this event is tied to
+      def node
+        @service.node
+      end
+
+      ##
+      # @return [Hash] a hash representing this event as it would be in JSON
+      def as_json
+        {
+          name: name,
+        }
+      end
+    end
+  end
+end

data/lib/moleculer/service/remote.rb

@@ -0,0 +1,80 @@
+module Moleculer
+  ##
+  # @private
+  module Service
+    ##
+    # Creates a service instance from remote service info
+    #
+    # @param [Hash] service_info remote service information
+    def self.from_remote_info(service_info, service_node)
+      Class.new(Remote) do
+        service_name Support::HashUtil.fetch(service_info, :name)
+        fetch_actions(service_info)
+        fetch_events(service_info)
+        node service_node
+      end
+    end
+
+    ##
+    # Represents a remote service
+    class Remote < Base
+      class << self
+        def node(n = nil)
+          @node = n if n
+          @node
+        end
+
+        def service_name(name = nil)
+          @service_name = name if name
+
+          @service_name
+        end
+
+        private
+
+        def action_name_for(name)
+          name
+        end
+
+        def fetch_actions(service_info)
+          seq = 0
+          Support::HashUtil.fetch(service_info, :actions).values.each do |a|
+            next if Support::HashUtil.fetch(a, :name) =~ /^\$/
+
+            define_method("action_#{seq}".to_sym) do |ctx|
+              @broker.send(:publish_req,
+                           id:         ctx.id,
+                           action:     ctx.action.name,
+                           params:     ctx.params,
+                           meta:       ctx.meta,
+                           timeout:    ctx.timeout,
+                           node:       self.class.node,
+                           request_id: ctx.request_id,
+                           stream:     false)
+              {}
+            end
+            action(Support::HashUtil.fetch(a, :name), "action_#{seq}".to_sym)
+            seq += 1
+          end
+        end
+
+        def fetch_events(service_info)
+          seq = 0
+          Support::HashUtil.fetch(service_info, :events).values.each do |a|
+            name = Support::HashUtil.fetch(a, :name)
+            define_method("event_#{seq}".to_sym) do |data|
+              @broker.send(:publish_event,
+                           event:     name,
+                           data:      data,
+                           broadcast: false,
+                           groups:    [],
+                           node:      self.class.node)
+            end
+            event(name, "event_#{seq}".to_sym)
+            seq += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moleculer/service.rb

@@ -0,0 +1,2 @@
+require_relative "service/base"
+require_relative "service/remote"

data/lib/moleculer/support/hash_util.rb

@@ -0,0 +1,48 @@
+require_relative "string_util"
+
+module Moleculer
+  module Support
+    ##
+    # A module of functional methods for working with hashes
+    module HashUtil
+      extend self
+      ##
+      # Works like fetch, but instead indifferently uses strings and symbols. It will try both snake case and camel
+      # case versions of the key.
+      #
+      # @param hash [Hash] the hash to fetch from
+      # @param key [Object] the key to fetch from the hash. This uses Hash#fetch internally, and if a string or synbol
+      # is passed the hash will use an indifferent fetch
+      # @param default [Object] the a fallback default if fetch fails. If not provided an exception will be raised if
+      #        key cannot be found
+      #
+      # @return [Object] the value at the given key
+      def fetch(hash, key, default = :__no_default__)
+        return fetch_with_string(hash, key, default) if key.is_a?(String) || key.is_a?(Symbol)
+        return hash.fetch(key, default) if default != :__no_default__
+
+        hash.fetch(key)
+      end
+
+      private
+
+      def fetch_with_string(hash, key, default)
+        ret = get_camel(hash, key).nil? ? get_underscore(hash, key) : get_camel(hash, key)
+        return default if default != :__no_default__ && ret.nil?
+        raise KeyError, %(key not found: "#{key}") if ret.nil?
+
+        ret
+      end
+
+      def get_camel(hash, key)
+        camelized = StringUtil.camelize(key.to_s)
+        hash[camelized].nil? ? hash[camelized.to_sym] : hash[camelized]
+      end
+
+      def get_underscore(hash, key)
+        underscored = StringUtil.underscore(key.to_s)
+        hash[underscored].nil? ? hash[underscored.to_sym] : hash[underscored]
+      end
+    end
+  end
+end

data/lib/moleculer/support/log_proxy.rb

@@ -0,0 +1,67 @@
+require "ap"
+
+module Moleculer
+  module Support
+    ##
+    # LogProxy acts as a bridge between multiple logger types.
+    # @private
+    class LogProxy
+      def initialize(logger, prefix = "")
+        @logger = logger
+        @prefix = prefix
+      end
+
+      ##
+      # @return [Moleculer::LogProxy] a prefixed child of the log proxy
+      def get_child(prefix)
+        self.class.new(@logger, prefix)
+      end
+
+      def fatal(*args)
+        @logger.fatal(parse_args(args.unshift(@prefix))) if @logger
+      end
+
+      def error(*args)
+        @logger.error(parse_args(args.unshift(@prefix))) if @logger
+      end
+
+      def warn(*args)
+        @logger.warn(parse_args(args.unshift(@prefix))) if @logger
+      end
+
+      def info(*args)
+        @logger.info(parse_args(args.unshift(@prefix))) if @logger
+      end
+
+      def debug(*args)
+        @logger.debug(parse_args(args.unshift(@prefix))) if @logger
+      end
+
+      def trace(*args)
+        return unless @logger
+
+        return @logger.trace(parse_args(args.unshift(@prefix))) if @logger.respond_to?(:trace)
+
+        @logger.debug(parse_args(args.unshift(@prefix)))
+      end
+
+      def level
+        @logger.level
+      end
+
+      private
+
+      def parse_args(args)
+        if args.last.is_a?(Hash)
+          args.each_index do |v|
+            args[v] = "\n" + args[v].ai + "\n" unless args[v].is_a?(String)
+          end
+        elsif args.last.is_a?(StandardError)
+          args = [args.slice(0, 1), args.last.message, "\n  ", args.last.backtrace.join("\n   ")].flatten
+        end
+
+        args.join(" ").strip
+      end
+    end
+  end
+end

data/lib/moleculer/support/open_struct.rb

@@ -0,0 +1,15 @@
+require "ostruct"
+
+module Moleculer
+  module Support
+    ##
+    # An OpenStruct that supports camelized serialization for JSON
+    class OpenStruct < ::OpenStruct
+      ##
+      # @return [Hash] the object prepared for conversion to JSON for transmission
+      def as_json
+        Hash[to_h.map { |item| [StringUtil.camelize(item[0]), item[1]] }]
+      end
+    end
+  end
+end

data/lib/moleculer/support/string_util.rb

@@ -0,0 +1,25 @@
+module Moleculer
+  module Support
+    ##
+    # A module of functional methods for working with strings.
+    module StringUtil
+      extend self
+      ##
+      # Converts a string to lowerCamelCase.
+      #
+      # @param term [String] the term to convert
+      def camelize(term)
+        new_term = term.gsub(/(?:^|_)([a-z])/) { $1.upcase }
+        new_term[0..1].downcase + new_term[2..-1]
+      end
+
+      ##
+      # Makes an underscored, lowercase form from the expression in the string.
+      #
+      # @param term[String] the word to convert into an underscored string
+      def underscore(term)
+        term.gsub(/(?<!^)[A-Z]/) { "_#$&" }.downcase
+      end
+    end
+  end
+end

data/lib/moleculer/support.rb

@@ -0,0 +1,4 @@
+require_relative "support/hash_util"
+require_relative "support/string_util"
+require_relative "support/open_struct"
+require_relative "support/log_proxy"

data/lib/moleculer/transporters/redis.rb

@@ -0,0 +1,207 @@
+require "redis"
+
+# frozen_string_literal: true
+
+module Moleculer
+  module Transporters
+    ##
+    # The Moleculer Redis transporter
+    class Redis
+      ##
+      # @private
+      # Represents the publisher connection
+      class Publisher
+        def initialize(config)
+          @uri        = config.transporter
+          @logger     = config.logger.get_child("[REDIS.TRANSPORTER.PUBLISHER]")
+          @serializer = Serializers.for(config.serializer).new(config)
+        end
+
+        ##
+        # Publishes the packet to the packet's topic
+        def publish(packet)
+          topic = packet.topic
+          @logger.trace "publishing packet to '#{topic}'", packet.as_json
+          connection.publish(topic, @serializer.serialize(packet))
+        end
+
+        ##
+        # Connects to redis
+        def connect
+          @logger.debug "connecting publisher client on '#{@uri}'"
+          connection
+        end
+
+        ##
+        # Disconnects from redis
+        def disconnect
+          @logger.debug "disconnecting publisher client"
+          connection.disconnect!
+        end
+
+        private
+
+        def connection
+          @connection ||= ::Redis.new(url: @uri)
+        end
+      end
+
+      ##
+      # Represents the subscriber connection
+      # @private
+      class Subscriber
+        ##
+        # Represents a subscription
+        class Subscription
+          def initialize(config:, channel:, block:)
+            @connection  = ::Redis.new(url: config.transporter)
+            @channel     = channel
+            @block       = block
+            @logger      = config.logger.get_child("[REDIS.TRANSPORTER.SUBSCRIPTION.#{channel}]")
+            @serializer  = Serializers.for(config.serializer).new(config)
+            @node_id     = config.node_id
+
+            # it is necessary to send some sort of message to signal the subscriber to disconnect and shutdown
+            # this is an internal message
+            reset_disconnect
+          end
+
+          ##
+          # Starts the subscriber
+          def connect
+            @thread = Thread.new do
+              begin
+                @logger.debug "starting subscription to '#{@channel}'"
+                @connection.subscribe(@channel) do |on|
+                  on.unsubscribe do
+                    unsubscribe
+                  end
+
+                  on.message do |_, message|
+                    packet = process_message(message)
+                    next unless packet
+
+                    process_packet(packet)
+                  end
+                end
+              rescue StandardError => error
+                @logger.fatal error
+                exit 1
+              end
+            end
+            self
+          end
+
+          def disconnect
+            @logger.debug "unsubscribing from '#{@channel}'"
+            redis = ::Redis.new(url: @uri)
+            redis.publish(@channel, @disconnect_hash.value)
+            redis.disconnect!
+          end
+
+          def reset_disconnect
+            @disconnect_hash ||= Concurrent::AtomicReference.new
+            @disconnect_hash.set("#{@node_id}.#{SecureRandom.hex}.disconnect")
+          end
+
+          private
+
+          def deserialize(message)
+            parsed = @serializer.deserialize(message)
+            return nil if parsed["sender"] == @node_id
+
+            parsed
+          end
+
+          def message_is_disconnect?(message)
+            message.split(".")[-1] == "disconnect"
+          end
+
+          def process_packet(packet)
+            return @connection.unsubscribe if packet == :disconnect
+
+            @logger.trace "received packet from #{packet.sender}:", packet.as_json
+
+            @block.call(packet)
+          rescue StandardError => error
+            @logger.error error
+          end
+
+          def process_message(message)
+            return :disconnect if message == @disconnect_hash
+
+            return nil if message_is_disconnect?(message)
+
+            packet_type = Packets.for(@channel.split(".")[1])
+
+            parsed = deserialize(message)
+
+            return nil unless parsed
+
+
+            packet_type.new(parsed)
+          rescue StandardError => error
+            @logger.error error
+          end
+
+          def unsubscribe
+            @logger.debug "disconnecting channel '#{@channel}'"
+            @connection.disconnect!
+          end
+        end
+
+        def initialize(config)
+          @config        = config
+          @uri           = config.transporter
+          @logger        = config.logger.get_child("[REDIS.TRANSPORTER]")
+          @subscriptions = Concurrent::Array.new
+        end
+
+        def subscribe(channel, &block)
+          @logger.debug "subscribing to channel '#{channel}'"
+          @subscriptions << Subscription.new(
+            channel: channel,
+            block:   block,
+            config:  @config,
+          ).connect
+        end
+
+        def disconnect
+          @logger.debug "disconnecting subscriptions"
+          @subscriptions.each(&:disconnect)
+        end
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      def subscribe(channel, &block)
+        subscriber.subscribe(channel, &block)
+      end
+
+      def publish(packet)
+        publisher.publish(packet)
+      end
+
+      def connect
+        publisher.connect
+      end
+
+      def disconnect
+        publisher.disconnect
+        subscriber.disconnect
+      end
+
+      private
+
+      def publisher
+        @publisher ||= Publisher.new(@config)
+      end
+
+      def subscriber
+        @subscriber ||= Subscriber.new(@config)
+      end
+    end
+  end
+end

data/lib/moleculer/transporters.rb

@@ -0,0 +1,22 @@
+require "uri"
+
+module Moleculer
+  ##
+  # Transporters allow you to run services on multiple nodes. They provide the communication channels for other with
+  # other nodes handling the transfer of events, action calls and responses, ...etc.
+  module Transporters
+
+    ##
+    # Returns a new transporter for the provided transporter uri
+    #
+    # @param [String] uri the transporter uri
+    # @param [Moleculer::Broker] broker the broker instance
+    #
+    # @return [Moleculer::Transporters::Base] the transporter instance
+    def self.for(uri)
+      parsed = URI(uri)
+      require_relative("./transporters/#{parsed.scheme}")
+      const_get(parsed.scheme.split("_").map(&:capitalize).join)
+    end
+  end
+end

data/lib/moleculer/version.rb

@@ -0,0 +1,3 @@
+module Moleculer
+  VERSION = "0.1.0"
+end