gorg_service 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc3822b0c00f7ba359527dcaa1245707ca309c0d
-  data.tar.gz: b8f61e1735b52a535df86432317d4981765663ce
+  metadata.gz: 23984c4b8e4322a1423a2d6458c7025303da38b7
+  data.tar.gz: 6c3e2e694dc143d926742bab066b31448808b4b5
 SHA512:
-  metadata.gz: a60aecc1ffd07385e7dec4620456b436b4d64227de4fcae6669f0a1d8637a119e472f7701c6222aa72272b7701a54e661eb4a38f7b07442cee8e82cae0f76f63
-  data.tar.gz: 863da64b36760eee6a28c637d61ef2a558ea1d00e86bed8792da8bb435a6ee99b7383834cde05bc98beab27e0ce9ed851e43195b756a8635ba8e67fa6de0009a
+  metadata.gz: 268e2a10c35eec58d78d6a177d05d53a648ff62e955323419649673fbfa18c99de4dd2705793bc2d18ad8169d1ba83cab2d0f5d7c7d3b583bcd210a91016ef09
+  data.tar.gz: dff239c0d3c80884cf6f8adf47b54c97160ed801c870ea5dffec578dd7dda07fc449a159a1f2a4a36f5d059370de1d7ab3d534090470f6997b41cf9598c6c60e

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Alexandre Narbonne
+Copyright (c) 2016 Société des ingénieurs Arts et Métiers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -45,8 +45,7 @@ GorgService.configure do |c|
   # c.rabbitmq_vhost = "/"
   #
   #
-  # c.rabbitmq_queue_name = c.application_name
-  # c.rabbitmq_exchange_name = "exchange"
+  # c.rabbitmq_event_exchange_name = "exchange"
   #
   # time before trying again on softfail in milliseconds (temporary error)
   # c.rabbitmq_deferred_time = 1800000 # 30min
@@ -58,15 +57,6 @@ GorgService.configure do |c|
   # Central logging is disable if nil
   # c.log_routing_key = nil
   #
-  # Routing hash
-  #  map routing_key of received message with MessageHandler 
-  #  exemple:
-  # c.message_handler_map={
-  #   "some.routing.key" => MyMessageHandler,
-  #   "Another.routing.key" => OtherMessageHandler,
-  #   "third.routing.key" => MyMessageHandler,
-  # }
-  c.message_handler_map= {} #TODO : Set my routing hash
 
  end
 ```
@@ -80,19 +70,19 @@ my_service.run
 ```
 ### Routing and MessageHandler
 When running, GorgService act as a consumer on Gadz.org RabbitMQ network.
-It bind its queue on the main exchange and subscribes to routing keys defines in `message_handler_map`
+It bind its queue on the main exchange and subscribes to routing keys with `listen_to`
 
 Each received message will be routed to the corresponding `MessageHandler`. AMQP wildcards are supported.The first key to match the incoming routing key will be used.
 
-A `MessageHandler` is a kind of controller. This is where you put the message is processed.
+A `MessageHandler` is a kind of controller. This is where you the message is processed.
 A `MessageHandler` expect a `GorgService::Message` as param of its `initializer`method.
 
 Here is an exemple `MessageHandler` :
 ```ruby
-require 'json'
-require 'json-schema' #Checkout https://github.com/ruby-json-schema/json-schema
 
-class ExampleMessageHandler < GorgService::MessageHandler
+class ExampleMessageHandler < GorgService::Consumer::MessageHandler::EventHandler
+
+  listen_to "event.user.updated"
 
   EXPECTED_SCHEMA = {
     "type" => "object",
@@ -102,22 +92,25 @@ class ExampleMessageHandler < GorgService::MessageHandler
     }
   }
   
-  def initialize(msg)
-    data=msg.data
-    begin
-      JSON::Validator.validate!(EXPECTED_SCHEMA, data)
-    rescue JSON::Schema::ValidationError => e
-      #This message can't be processed, it will be discarded
-      raise_hardfail("Invalid message",e)
-    end
-
+  def validate
+    message.validate_with(EXPECTED_SCHEMA)
+  end
+  
+  def process
     begin
-      MyAPI.send(msg.data)
-    rescue MyAPI::UnavailableConnection => e
-      # This message can be processed but external resources
-      # are not available at this moment, retry later
-      raise_softfail("Can't connect to MyAPI",e)
-    end
+        if example=Example.update(message.data[:user_id])
+          producer=GorgServiceProducer.new
+          event=GorgService::Message.new(
+            event: "event.example.updated",
+            data: {example_id: example.id}
+          )
+          producer.publish_message(event)
+        else
+          raise_hardfail("Unable to update example")
+        end
+     rescue ApiConnectionError => e
+      raise_softfail("Unable to connect to API",error: e)
+     end
   end
 end
 ```
@@ -156,7 +149,6 @@ Error log structure :
 
 ## To Do
 
- - Internal logs using Logger
  - Allow disable JSON Schema Validation on incomming messages
  - Message and ErrorLog attributes validation
 

data/bin/console

@@ -11,7 +11,7 @@ require "gorg_service"
 # Pry.start
 
 #You can add a file bin/env.rb to set convenience environment such as configuration
-env_path=File.join(File.dirname(__FILE__),"/env.rb") 
+env_path=File.expand_path("./env.rb",File.dirname(__FILE__)) 
 require env_path if File.file?(env_path)
 
 require "irb"

data/bin/worker

@@ -11,7 +11,7 @@ require "gorg_service"
 # Pry.start
 
 #You should add a file bin/env.rb to set convenience environment such as configuration
-env_path=File.join(File.dirname(__FILE__),"/env.rb") 
+env_path=File.expand_path("./env.rb",File.dirname(__FILE__)) 
 require env_path if File.file?(env_path)
 
 GorgService.new.run

data/gorg_service.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'bunny', '~> 2.2', '>= 2.2.2'
   spec.add_dependency 'json-schema', '~> 2.6'
-  spec.add_dependency 'gorg_message_sender', '~> 1'
+  spec.add_dependency 'gorg_message_sender', '~> 1.4.2'
 
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/gorg_service/configuration.rb

@@ -21,8 +21,7 @@ class GorgService
                   :application_id,
                   :rabbitmq_host,
                   :rabbitmq_port,
-                  :rabbitmq_queue_name,
-                  :rabbitmq_exchange_name,
+                  :rabbitmq_event_exchange_name,
                   :rabbitmq_deferred_time,
                   :rabbitmq_max_attempts,
                   :rabbitmq_user,
@@ -41,9 +40,8 @@ class GorgService
       @message_handler_map     = {}
       @rabbitmq_host           = "localhost"
       @rabbitmq_port           = 5672
-      @rabbitmq_queue_name     = @application_id
       @rabbitmq_deferred_time  = 1800000    #30 minutes
-      @rabbitmq_exchange_name  = "exchange"
+      @rabbitmq_event_exchange_name  = "exchange"
       @rabbitmq_user           = nil
       @rabbitmq_password       = nil
       @rabbitmq_vhost          = "/"
@@ -51,5 +49,20 @@ class GorgService
       @log_routing_key         = nil
       @prefetch_count          = 1
     end
+
+    def rabbitmq_queue_name=(value)
+      warn "[DEPRECATION] GorgService::Configuration : `rabbitmq_queue_name=` is deprecated and will be removed soon."
+    end
+
+    # Deprecated: please use rabbitmq_event_exchange_name instead
+    def rabbitmq_exchange_name
+      @rabbitmq_event_exchange_name
+    end
+
+    # Deprecated: please use rabbitmq_event_exchange_name instead
+    def rabbitmq_exchange_name=(v)
+      warn "[DEPRECATION] GorgService::Configuration : `rabbitmq_exchange_name` is deprecated. Please use `rabbitmq_event_exchange_name` instead."
+      @rabbitmq_event_exchange_name=v
+    end
   end
 end

data/lib/gorg_service/consumer/errors.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+class GorgService
+  class Consumer
+    #Common behavior of failling errors
+    class FailError < StandardError
+      attr_reader :error_raised
+
+      def initialize(message = nil, error_raised = nil)
+        @message = message
+        @error_raised = error_raised
+      end
+
+      def message
+        @message
+      end
+
+      def type
+        ""
+      end
+    end
+
+    #Softfail error : This message should be processed again later
+    class SoftfailError < FailError
+      def type
+        "softerror"
+      end
+    end
+
+    #Hardfail error : This message is not processable and will never be
+    class HardfailError < FailError
+      def type
+        "harderror"
+      end
+    end
+  end
+end

data/lib/gorg_service/consumer/listener.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bunny"
+
+class GorgService
+  class Consumer
+    class Listener
+
+      attr_accessor :consumer
+
+
+
+      def initialize(env: nil, max_attempts: 48, log_routing_key: nil)
+        @max_attempts=max_attempts.to_i
+        @log_routing_key=log_routing_key
+
+        @env=env
+      end
+
+      def listen
+        @consumer=@env.job_queue.subscribe(:manual_ack => true) do |delivery_info, properties, body|
+          #Log
+          routing_key=delivery_info[:routing_key]
+          GorgService.logger.info "Received message with routing key #{routing_key}"
+          GorgService.logger.debug "Message properties : #{properties.to_s}"
+          GorgService.logger.debug "Message payload : #{body.to_s[0...10000]}"
+
+          #Process
+          process_message(delivery_info, properties, body)
+
+          #Acknoledge
+          @env.ch.ack(delivery_info.delivery_tag)
+        end
+      end
+
+      def stop
+        @consumer.cancel
+      end
+
+      protected
+
+      def process_message(delivery_info, _properties, body)
+        message=nil
+        begin
+          #Parse message
+          message=Message.parse(delivery_info, _properties, body)
+
+          #Process message
+          incomming_message_error_count=message.errors.count
+          MessageRouter.new(message)
+          process_logging(message) if message.errors.count>incomming_message_error_count
+
+        rescue SoftfailError => e
+          process_softfail(e, message)
+        rescue HardfailError => e
+          process_hardfail(e, message)
+        end
+      end
+
+      def process_softfail(e, message)
+        message.log_error(e)
+        GorgService.logger.error "SOFTFAIL ERROR : #{e.message}"
+        if message.errors.count.to_i >= @max_attempts
+          GorgService.logger.info " DISCARD MESSAGE : #{message.errors.count} errors in message log"
+          process_hardfail(HardfailError.new("Too Much SoftError : This message reached the limit of softerror (max: #{@max_attempts})"), message)
+        else
+          send_to_deferred_queue(message)
+        end
+      end
+
+      def process_hardfail(e, message)
+        GorgService.logger.error "HARDFAIL ERROR : #{e.message}, #{e.error_raised&&e.error_raised.inspect}"
+        GorgService.logger.info " DISCARD MESSAGE"
+        if message
+          message.log_error(e)
+          process_logging(message)
+        end
+      end
+
+      def process_logging(message)
+        message.routing_key=@log_routing_key
+        GorgService::Producer.new.publish_message(message)
+        #RabbitmqProducer.new.send_raw(message.to_json, @log_routing_key, verbose: true) if @log_routing_key
+      end
+
+      def send_to_deferred_queue(msg)
+        if @env.delayed_queue_for msg.event
+          @env.delayed_in_exchange.publish(msg.to_json, :routing_key => msg.event)
+          GorgService.logger.info "DEFER MESSAGE : message sent to #{@env.delayed_in_exchange.name} with routing key #{msg.event}"
+        else
+          raise "DelayedQueueNotFound"
+        end
+      end
+    end
+  end
+end

data/lib/gorg_service/consumer/message_handler/base.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+class GorgService
+  class Consumer
+    module MessageHandler
+      class Base
+
+        def initialize(message)
+          @message=message
+
+          begin
+            validate
+          rescue GorgService::Message::DataValidationError => e
+            raise_hardfail("DataValidationError",error: e.errors)
+          end
+          process
+        end
+
+        def validate
+          GorgService.logger.warn "WARNING : No message schema validation in #{self.class.name}, implement it in #validate(message) "
+        end
+
+        def process
+          GorgService.logger.warn "WARNING : You must define your MessageHandler behavior in #process"
+        end
+
+        def message
+          @message
+        end
+        alias_method :msg, :message
+
+        def raise_hardfail(message, error: nil)
+          raise HardfailError.new(message, error)
+        end
+
+        def raise_softfail(message, error: nil)
+          raise SoftfailError.new(message, error)
+        end
+
+        class << self
+
+          def listen_to(routing_key)
+            MessageRouter.register_route(routing_key, self)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gorg_service/consumer/message_handler/event_handler.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+class GorgService
+  class Consumer
+    module MessageHandler
+      class EventHandler < Base
+
+      end
+    end
+  end
+end

data/lib/gorg_service/consumer/message_handler/reply_handler.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+class GorgService
+  class Consumer
+    module MessageHandler
+      class ReplyHandler < Base
+
+      end
+    end
+  end
+end

data/lib/gorg_service/consumer/message_handler/request_handler.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+class GorgService
+  class Consumer
+    module MessageHandler
+      class RequestHandler < Base
+
+        def reply_with(data)
+          if message.expect_reply?
+
+            reply=GorgService::Message.new(
+              event: message.reply_routing_key,
+              data: data,
+              correlation_id: message.id,
+              type: "reply"
+            )
+
+            replier=GorgService::Producer.new
+            replier.publish_message(reply,exchange: message.reply_to)
+          end
+        end
+
+        def raise_hardfail(message, error: nil, data: nil)
+          reply_with({
+                         status: 'hardfail',
+                         error_message: message,
+                         debug_message: error&&error.inspect,
+                         error_data: data
+                     })
+
+          super(message, error: error)
+        end
+
+        def raise_softfail(message, error: nil, data: nil)
+          reply_with({
+                         status: 'softfail',
+                         error_message: message,
+                         debug_message: error&&error.inspect,
+                         error_data: data
+                     })
+          super(message, error: error)
+        end
+
+      end
+    end
+  end
+end

data/lib/gorg_service/consumer/message_handler.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+class GorgService
+  class Consumer
+    module MessageHandler
+
+    end
+  end
+end
+
+require "gorg_service/consumer/message_handler/base"
+require "gorg_service/consumer/message_handler/event_handler"
+require "gorg_service/consumer/message_handler/request_handler"
+require "gorg_service/consumer/message_handler/reply_handler"

data/lib/gorg_service/consumer/message_router.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+class GorgService
+  class Consumer
+    class MessageRouter
+
+      def initialize(message)
+        message_handler=self.class.message_handler_for message.routing_key
+        raise HardfailError.new("Routing error : No message handler found for this routing key") unless message_handler
+
+        message_handler.new(message)
+      end
+
+      class << self
+
+        def routes
+          @routes||={}
+        end
+
+        def register_route(routing_key, message_handler)
+          routes[routing_key]=message_handler
+        end
+
+        def listened_keys
+          routes.keys
+        end
+
+        def message_handler_for routing_key
+          @routes.each do |k, mh|
+            return mh if amqp_key_to_regex(k).match(routing_key)
+          end
+          false
+        end
+
+        private
+
+        def amqp_key_to_regex(key)
+          regex_base=key.gsub('.', '\.')
+                         .gsub('*', '([a-zA-Z0-9\-_:]+)')
+                         .gsub(/(\\\.)?#(\\\.)?/, '((\.)?[a-zA-Z0-9\-_:]*(\.)?)*')
+
+          /^#{regex_base}$/
+        end
+
+      end
+    end
+  end
+end

data/lib/gorg_service/consumer.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "gorg_service/consumer/message_router"
+require "gorg_service/consumer/errors"
+require "gorg_service/consumer/listener"
+require "gorg_service/consumer/message_handler"
+
+class GorgService
+  class Consumer
+
+    attr_accessor :environment
+
+    def initialize(environment: GorgService.environment)
+      @environment=environment
+    end
+
+    def listener
+      @listener ||= Listener.new(
+          env: environment,
+          max_attempts: GorgService.configuration.rabbitmq_max_attempts.to_i,
+          log_routing_key: GorgService.configuration.log_routing_key
+      )
+    end
+
+    def run
+      begin
+        self.start
+        puts " [*] Waiting for messages. To exit press CTRL+C"
+        loop do
+          sleep(1)
+        end
+      rescue SystemExit, Interrupt => _
+        self.stop
+      end
+    end
+
+    def start
+      listener.listen
+    end
+
+    def stop
+      listener.stop
+    end
+  end
+end

data/lib/gorg_service/message.rb

@@ -11,8 +11,27 @@ require "gorg_service/message/error_log"
 class GorgService
   class Message
 
-    attr_accessor :event
+    class DataValidationError < StandardError
+
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors=errors
+      end
+    end
+
     attr_accessor :id
+    attr_accessor :reply_to
+    attr_accessor :correlation_id
+    attr_accessor :sender_id
+    attr_accessor :content_type
+    attr_accessor :content_encoding
+    attr_accessor :headers
+    attr_accessor :type
+
+    attr_accessor :event_id
+    attr_accessor :routing_key
+    attr_accessor :event
     attr_accessor :data
     attr_accessor :errors
     attr_accessor :creation_time
@@ -23,28 +42,56 @@ class GorgService
     end
 
 
-    def initialize(id: generate_id, data: nil, event: nil, creation_time: DateTime.now.iso8601, sender: application_id ,  errors: [])
-      @id=id
-      @event=event
-      @data=data
-      @errors=errors&&errors.map{|e| e.is_a?(GorgService::Message::ErrorLog) ? e : GorgService::Message::ErrorLog.parse(e)}
-      @creation_time=creation_time
-      @sender= sender
+    def initialize(opts={})
+      ##Message payload params
+      @event_id= opts.fetch(:event_id,generate_id)
+      @errors= opts.fetch(:errors,nil)
+      @creation_time= opts.fetch(:creation_time,DateTime.now.iso8601)
+      @sender= opts.fetch(:sender,application_id)
+      @event= opts.fetch(:event,nil)
+      @data= opts.fetch(:data,nil)
+
+      #Message Attributes params
+      @routing_key= opts.fetch(:routing_key,event)
+      @id= opts.fetch(:id,generate_id)
+      @reply_to= opts.fetch(:reply_to,nil)
+      @correlation_id= opts.fetch(:correlation_id,nil)
+      @sender_id= opts.fetch(:sender_id,application_id)
+      @content_type= opts.fetch(:content_type,"application/json")
+      @content_encoding= opts.fetch(:content_encoding,"deflate")
+      @headers= opts.fetch(:headers,{})
+      @type= opts.fetch(:type,"event")
     end
 
-    def to_h
-      body={
-        event_uuid: @id,
+    def body
+      _body={
+        event_uuid: @event_id,
         event_name: @event,
         event_sender_id: @sender,
         event_creation_time: @creation_time,
         data: @data,
       }
       if errors.any?
-        body[:errors_count]=@errors.count
-        body[:errors]=@errors.map{|e| e.to_h}
+        _body[:errors_count]=@errors.count
+        _body[:errors]=@errors.map{|e| e.to_h}
       end
-      body
+      _body
+    end
+    alias_method :to_h, :body
+    alias_method :payload, :body
+
+    def properties
+      {
+          routing_key: routing_key,
+          reply_to: reply_to,
+          correlation_id: correlation_id,
+          content_type: content_type,
+          content_encoding: content_encoding,
+          headers: headers,
+          app_id: sender_id,
+          type: type,
+          message_id: id,
+      }
     end
 
     # Generate RabbitMQ message body
@@ -62,32 +109,60 @@ class GorgService
       errors<<e
     end
 
+    def reply_exchange
+      reply_to
+    end
+
+    def expect_reply?
+      !!reply_to
+    end
+
+    def reply_routing_key
+      event.sub('request','reply')
+    end
+
+    def validate_data_with(schema)
+      errors=JSON::Validator.fully_validate(schema, self.data)
+      if errors.any?
+        raise DataValidationError.new(errors)
+      else
+        return true
+      end
+    end
+
+
+
     ### Class methods
 
-    # Parse RabbitMQ message body
-    # @return Message
-    #   parsed message
-    # Errors
-    #   Hardfail if un-parsable JSON body
-    def self.parse_body(body)
+    def self.parse(delivery_info, properties, body)
       begin
         json_body=JSON.parse(body)
 
         JSON::Validator.validate!(GorgService::Message::JSON_SCHEMA,json_body)
 
-        puts json_body["errors"].inspect
-
         msg=self.new(
-            id: json_body["event_uuid"],
+            routing_key: delivery_info[:routing_key],
+            id: properties[:message_id],
+            reply_to: properties[:reply_to],
+            correlation_id: properties[:correlatio_to],
+            sender_id: properties[:app_id],
+            content_type: properties[:content_type],
+            content_encoding: properties[:content_encoding],
+            headers: properties[:header],
+            type: properties[:type],
+
+            event_id: json_body["event_uuid"],
             event: json_body["event_name"],
             data: convert_keys_to_sym(json_body["data"]),
             creation_time: json_body["event_creation_time"] && DateTime.parse(json_body["event_creation_time"]),
             sender: json_body["event_sender_id"],
             errors: json_body["errors"]&&json_body["errors"].map{|e| GorgService::Message::ErrorLog.parse(e)},
-          )
+        )
         msg
       rescue JSON::ParserError => e
-        raise GorgService::HardfailError.new(e), "Unprocessable message : Unable to parse JSON message body"
+        raise GorgService::Consumer::HardfailError.new("Unprocessable message : Unable to parse JSON message body", e)
+      rescue JSON::Schema::ValidationError => e
+        raise GorgService::Consumer::HardfailError.new("Invalid JSON : This message does not respect Gadz.org JSON Schema",e)
       end
     end
 
@@ -116,7 +191,7 @@ class GorgService
       GorgService.configuration.application_id
     end
 
-   
+
 
   end
 end

data/lib/gorg_service/producer.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+
+class GorgService
+  class Producer
+
+    attr_accessor :default_exchange
+    attr_accessor :environment
+
+    def initialize(environment_: GorgService.environment ,default_exchange_: nil)
+      self.environment=environment_
+      self.default_exchange= default_exchange_ || environment.event_exchange
+    end
+
+
+    def publish_message(message, exchange: default_exchange)
+      x=exchange.is_a?(Bunny::Exchange) ? exchange : environment.find_exchange_by_name(exchange)
+      GorgService.logger.info "Publish to #{x.name} - key : #{message.routing_key}"
+      GorgService.logger.debug "Message content : #{message.body.to_s[0...10000]}"
+
+      x.publish(message.to_json, message.properties)
+    end
+
+  end
+end

data/lib/gorg_service/rabbitmq_env_builder.rb

@@ -1,10 +1,10 @@
 class GorgService
   class RabbitmqEnvBuilder
 
-    def initialize(conn:nil,main_exchange:"", app_id:"", deferred_time: 10000, listened_routing_keys: [], prefetch: 1)
+    def initialize(conn:nil, event_exchange:"", app_id:"", deferred_time: 10000, listened_routing_keys: [], prefetch: 1)
       @_conn=conn
       @app_id=app_id
-      @main_exchange_name=main_exchange
+      @event_exchange_name=event_exchange
       @deferred_time=deferred_time
       @delayed_queues={}
       @listened_routing_keys=listened_routing_keys
@@ -15,6 +15,7 @@ class GorgService
       @_conn.start unless @_conn.connected?
       @_conn
     end
+    alias_method :connection, :conn
 
     def ch
       unless (@_ch && @_ch.status == :open)
@@ -23,11 +24,21 @@ class GorgService
       end
       @_ch
     end
+    alias_method :channel, :ch
 
-    def main_exchange
-      ch.topic(@main_exchange_name, :durable => true)
+    def request_exchange
+      ch.topic("#{@app_id}.request", :durable => true)
     end
 
+    def reply_exchange
+      ch.topic("#{@app_id}.reply", :durable => true)
+    end
+
+    def event_exchange
+      ch.topic(@event_exchange_name, :durable => true)
+    end
+
+
     def delayed_in_exchange
      ch.topic("#{@app_id}_delayed_in_x", :durable => true)
     end
@@ -37,12 +48,14 @@ class GorgService
     end
 
     def job_queue
-      GorgService.logger.debug @listened_routing_keys
+      GorgService.logger.debug "Listened keys :#{@listened_routing_keys}"
       q=ch.queue("#{@app_id}_job_q", :durable => true)
       q.bind delayed_out_exchange
       @listened_routing_keys.each do |rk|
-        q.bind(main_exchange, :routing_key => rk)
+        q.bind(event_exchange, :routing_key => rk)
       end
+      q.bind(reply_exchange, :routing_key => "#")
+      q.bind(request_exchange, :routing_key => "#")
       q
     end
 
@@ -50,11 +63,29 @@ class GorgService
       @delayed_queues[routing_key]||= create_delayed_queue_for(routing_key)
     end
 
+    def find_exchange_by_name(name, type: 'topic', opts: {})
+      begin
+        ch.send(type,name,opts)
+      rescue Bunny::PreconditionFailed => e
+        regex=/PRECONDITION_FAILED - inequivalent arg '(?<arg>.*)' for exchange '(?<exchange>.*)' in vhost '(?<vhost>.*)': received '(?<our>.*)' but current is '(?<their>.*)'/
+        match=regex.match(e.message)
+
+        case match[:arg]
+          when "type"
+            find_exchange_by_name(name,type: match[:their],opts: opts)
+          else
+            find_exchange_by_name(name,type: type,opts: opts.merge({ match[:arg].to_sym =>  match[:their]}))
+        end
+      end
+    end
+
     private
 
     def set_logger
       x=ch.fanout("log", :durable => true)
-      x.bind(main_exchange, :routing_key => "#")
+      x.bind(event_exchange, :routing_key => "#")
+      x.bind(reply_exchange, :routing_key => "#")
+      x.bind(request_exchange, :routing_key => "#")
       x.bind(delayed_in_exchange, :routing_key => "#")
     end
 
@@ -82,6 +113,4 @@ class GorgService
     end
 
   end
-end
-
-#ch.queue(test,  durable: true, arguments: {'x-message-ttl' => 1000,'x-dead-letter-exchange' => "agoram_event_exchange",'x-dead-letter-routing-key' => "test",})
+end

data/lib/gorg_service/version.rb

@@ -2,5 +2,5 @@
 # encoding: utf-8
 
 class GorgService
-  VERSION = "4.1.0"
+  VERSION = "5.0.0"
 end

data/lib/gorg_service.rb

@@ -1,83 +1,43 @@
-require "gorg_message_sender"
+
 require "gorg_service/configuration"
 require "gorg_service/version"
-require "gorg_service/errors"
 require "gorg_service/rabbitmq_env_builder"
-require "gorg_service/listener"
 require "gorg_service/message"
-require "gorg_service/message_handler"
 
-#Duplicate GorgMessageSender to avoid configuration conflict
-RabbitmqProducer=GorgMessageSender.dup
+require "gorg_service/consumer"
+require "gorg_service/producer"
 
 class GorgService
-  def initialize(listener: nil, bunny_session: nil, rabbitmq_env:nil)
-
-    @bunny_session= bunny_session || Bunny.new(
-      :hostname => GorgService.configuration.rabbitmq_host,
-      :port => GorgService.configuration.rabbitmq_port,
-      :user => GorgService.configuration.rabbitmq_user,
-      :pass => GorgService.configuration.rabbitmq_password,
-      :vhost => GorgService.configuration.rabbitmq_vhost
+  class << self
+
+    #Connection shared across Consumers and Producers (thread safe)
+    def connection
+      @bunny_session||=Bunny.new(
+          :hostname => GorgService.configuration.rabbitmq_host,
+          :port => GorgService.configuration.rabbitmq_port,
+          :user => GorgService.configuration.rabbitmq_user,
+          :pass => GorgService.configuration.rabbitmq_password,
+          :vhost => GorgService.configuration.rabbitmq_vhost
       )
+      @bunny_session.start unless @bunny_session.connected?
+      @bunny_session
+    end
 
-    @env=rabbitmq_env || RabbitmqEnvBuilder.new(
-      conn: @bunny_session,
-      main_exchange: GorgService.configuration.rabbitmq_exchange_name,
-      app_id:GorgService.configuration.application_id,
-      deferred_time: GorgService.configuration.rabbitmq_deferred_time.to_i,
-      listened_routing_keys: GorgService.configuration.message_handler_map.keys,
-      prefetch:GorgService.configuration.prefetch_count,
-    )
-
-    @listener= listener || Listener.new(
-      bunny_session: @bunny_session,
-      message_handler_map:GorgService.configuration.message_handler_map,
-      env: @env,
-      max_attempts: GorgService.configuration.rabbitmq_max_attempts.to_i,
-      log_routing_key: GorgService.configuration.log_routing_key
+    #Environment buidler. Don't share across threads since channels are not thread safe
+    def environment
+      RabbitmqEnvBuilder.new(
+          conn: connection,
+          event_exchange: GorgService.configuration.rabbitmq_event_exchange_name,
+          app_id: GorgService.configuration.application_id,
+          deferred_time: GorgService.configuration.rabbitmq_deferred_time.to_i,
+          listened_routing_keys: Consumer::MessageRouter.listened_keys,
+          prefetch: GorgService.configuration.prefetch_count,
       )
-
-    RabbitmqProducer.configure do |c|
-      # Id used to set the event_sender_id
-      c.application_id = GorgService.configuration.application_id
-
-      # RabbitMQ network and authentification
-      c.host = GorgService.configuration.rabbitmq_host
-      c.port = GorgService.configuration.rabbitmq_port
-      c.vhost = GorgService.configuration.rabbitmq_vhost
-      c.user = GorgService.configuration.rabbitmq_user
-      c.password = GorgService.configuration.rabbitmq_password
-
-      # Exchange configuration
-      c.exchange_name = GorgService.configuration.rabbitmq_exchange_name
-      c.durable_exchange= true      
     end
 
-  end
-
-  def run
-    begin
-      self.start
-      puts " [*] Waiting for messages. To exit press CTRL+C"
-      loop do
-        sleep(1)
-      end
-    rescue SystemExit, Interrupt => _
-      self.stop
+    def logger
+      GorgService.configuration.logger
     end
-  end
-
-  def start
-    @bunny_session.start
-    @listener.listen
-  end
-
-  def stop
-    @bunny_session.close
-  end
 
-  def self.logger
-    GorgService.configuration.logger
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gorg_service
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Alexandre Narbonne
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-07 00:00:00.000000000 Z
+date: 2017-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: 1.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -163,12 +163,19 @@ files:
 - gorg_service.gemspec
 - lib/gorg_service.rb
 - lib/gorg_service/configuration.rb
-- lib/gorg_service/errors.rb
-- lib/gorg_service/listener.rb
+- lib/gorg_service/consumer.rb
+- lib/gorg_service/consumer/errors.rb
+- lib/gorg_service/consumer/listener.rb
+- lib/gorg_service/consumer/message_handler.rb
+- lib/gorg_service/consumer/message_handler/base.rb
+- lib/gorg_service/consumer/message_handler/event_handler.rb
+- lib/gorg_service/consumer/message_handler/reply_handler.rb
+- lib/gorg_service/consumer/message_handler/request_handler.rb
+- lib/gorg_service/consumer/message_router.rb
 - lib/gorg_service/message.rb
 - lib/gorg_service/message/error_log.rb
 - lib/gorg_service/message/json_schema.rb
-- lib/gorg_service/message_handler.rb
+- lib/gorg_service/producer.rb
 - lib/gorg_service/rabbitmq_env_builder.rb
 - lib/gorg_service/version.rb
 homepage: https://github.com/Zooip/gorg_service

data/lib/gorg_service/errors.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-class GorgService
-
-  #Common behavior of failling errors
-  class FailError < StandardError
-    attr_reader :error_raised
-
-    def initialize(message = nil, error_raised = nil)
-      @message = message
-      @error_raised = error_raised
-    end
-
-    def message
-      @message
-    end
-
-    def type
-      ""
-    end
-  end
-
-  #Softfail error : This message should be processed again later
-  class SoftfailError < FailError
-    def type
-      "softerror"
-    end
-  end
-
-  #Hardfail error : This message is not processable and will never be
-  class HardfailError < FailError
-    def type
-      "harderror"
-    end
-  end
-end

data/lib/gorg_service/listener.rb

@@ -1,106 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "bunny"
-
-class GorgService
-  class Listener
-
-    def initialize(bunny_session: nil, env: nil, message_handler_map: {default: DefaultMessageHandler}, max_attempts: 48,log_routing_key:nil)
-      @message_handler_map=message_handler_map
-      @max_attempts=max_attempts.to_i
-      @rmq_connection=bunny_session
-      @log_routing_key=log_routing_key
-
-      @env=env
-    end
-
-    def listen  
-      @env.job_queue.subscribe(:manual_ack => true) do |delivery_info, _properties, body|
-        routing_key=delivery_info[:routing_key]
-        GorgService.logger.info "Received message with routing key #{routing_key} containing : #{body}"
-        process_message(body,routing_key)
-        @env.ch.ack(delivery_info.delivery_tag)
-      end
-    end
-
-    protected
-
-    def rmq_connection
-      @rmq_connection.start unless @rmq_connection.connected?
-      @rmq_connection
-    end
-
-    def process_message(body,routing_key)
-      message=nil
-      incomming_message_error_count=0
-      begin 
-        message_handler=message_handler_for routing_key
-        raise HardfailError.new("Routing error : No message handler finded for this routing key") unless message_handler
-
-        begin
-          message=Message.parse_body(body)
-        rescue JSON::ParserError => e
-          raise HardfailError.new("JSON Parse error : Can't parse incoming message",e)
-        rescue JSON::Schema::ValidationError => e
-          raise HardfailError.new("Invalid JSON : This message does not respect Gadz.org JSON Schema",e)
-        end
-        incomming_message_error_count=message.errors.count
-        message_handler.new(message)
-        process_logging(message) if message.errors.count>incomming_message_error_count
-      rescue SoftfailError => e
-        process_softfail(e,message)
-      rescue HardfailError => e
-        process_hardfail(e,message)
-      end
-    end
-
-    def process_softfail(e,message)
-        message.log_error(e)
-        GorgService.logger.error "SOFTFAIL ERROR : #{e.message}"
-        if message.errors.count.to_i >= @max_attempts
-          GorgService.logger.info " DISCARD MESSAGE : #{message.errors.count} errors in message log"
-          process_hardfail(HardfailError.new("Too Much SoftError : This message reached the limit of softerror (max: #{@max_attempts})"),message)
-        else
-          send_to_deferred_queue(message)
-        end
-    end
-
-    def process_hardfail(e,message)
-      GorgService.logger.error "HARDFAIL ERROR : #{e.message}"
-      GorgService.logger.info " DISCARD MESSAGE"
-      if message
-        message.log_error(e)
-        process_logging(message)
-      end
-    end
-
-    def process_logging(message)
-      RabbitmqProducer.new.send_raw(message.to_json,@log_routing_key, verbose: true) if @log_routing_key
-    end
-
-    def send_to_deferred_queue(msg)
-      if @env.delayed_queue_for msg.event
-        @env.delayed_in_exchange.publish(msg.to_json, :routing_key => msg.event)
-        GorgService.logger.info "DEFER MESSAGE : message sent to #{@env.delayed_in_exchange.name} with routing key #{msg.event}"
-      else
-        raise "DelayedQueueNotFound"
-      end
-    end
-
-    def message_handler_for routing_key
-      @message_handler_map.each do |k,mh|
-        return mh if self.class.amqp_key_to_regex(k).match(routing_key)
-      end
-    end
-
-    def self.amqp_key_to_regex(key)
-      regex_base=key.gsub('.','\.')
-                     .gsub('*','([a-zA-Z0-9\-_:]+)')
-                     .gsub(/(\\\.)?#(\\\.)?/,'((\.)?[a-zA-Z0-9\-_:]*(\.)?)*')
-
-      /^#{regex_base}$/
-    end
-
-  end
-end

data/lib/gorg_service/message_handler.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-class GorgService
-  class MessageHandler
-
-    def initialize(message)
-      GorgService.logger.warning "WARNING : Defined your MessageHandler behavior in its 'initialize' method"
-    end
-
-    def raise_hardfail(message, error:nil)
-      raise HardfailError.new(message, error)
-    end
-
-    def raise_softfail(message, error:nil)
-      raise SoftfailError.new(message, error)
-    end
-
-  end
-end