gorg_service 5.3.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a69896ea2caff03c8164b627c8d30879bd97f6e
-  data.tar.gz: e2ae0468acf11367a5de67703597c84e3867b208
+  metadata.gz: 4176b3c8a8689ae7474eaa5420f3b45c96fbc916
+  data.tar.gz: 0b48b75295d30fbeeabd9245cf22e9d97174a02f
 SHA512:
-  metadata.gz: 13d927a1f0079447ec7be9ea188c5dd8808de5d6bd20ad5b1fee2df8bfabfe4cf59caed6b67c71376353545d1b93343fe9286f8de757317a0c6daf606669ab9c
-  data.tar.gz: df30302c0ff854aa61eef2b395e66e290c78cd6699dca0a85dde5cbd9a65fbe70eaf8e50d148c16b7c65614b7fd34a09cad0bef8f4298a21273b5ed7555d87bd
+  metadata.gz: 8fe317544a9bf0a1cb7b5583f0489ba734ff982f9d1142527bfc69147d2779ecde58224720138d816fa8eb4e1fce948f78f89d9672765ee67feb36d880bc0b7d
+  data.tar.gz: cec6262709a87326414100b87707f89382f9344be4345c7147bb8403a1040d5b9d9e7ad3615daac78a812026ccf09d4443ae168d9588df792dcf5efcdd721828

data/gorg_service.gemspec

@@ -32,8 +32,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "yard", "~> 0.8.7"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "codeclimate-test-reporter", "~> 0.5.0"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 1.0"
+  spec.add_development_dependency "simplecov", "~> 0.13"
   spec.add_development_dependency 'bogus', '~> 0.1.6'
   spec.add_development_dependency 'byebug', '~> 9.0'
 end

data/lib/gorg_service/consumer/errors.rb

@@ -6,10 +6,14 @@ class GorgService
     #Common behavior of failling errors
     class FailError < StandardError
       attr_reader :error_raised
+      attr_reader :error_name
+      attr_accessor :gorg_service_message
 
-      def initialize(message = nil, error_raised = nil)
+      def initialize(message = nil, error_raised = nil, gorg_service_message: nil, error_name: nil)
         @message = message
         @error_raised = error_raised
+        @gorg_service_message = gorg_service_message
+        @error_name = error_name
       end
 
       def message
@@ -19,19 +23,41 @@ class GorgService
       def type
         ""
       end
+
+      def to_log_message
+        @gorg_service_message.log_message(
+                                 level: self.log_level,
+                                 error_type: self.type,
+                                 error_name: @error_name
+        )
+      end
     end
 
     #Softfail error : This message should be processed again later
     class SoftfailError < FailError
       def type
-        "softerror"
+        "softfail"
+      end
+
+      def log_level
+        3
+      end
+
+      def to_log_message
+        r=super
+        r.next_try_in=GorgService.configuration.rabbitmq_deferred_time.to_i
+        r
       end
     end
 
     #Hardfail error : This message is not processable and will never be
     class HardfailError < FailError
       def type
-        "harderror"
+        "hardfail"
+      end
+
+      def log_level
+        4
       end
     end
   end

data/lib/gorg_service/consumer/listener.rb

@@ -64,35 +64,38 @@ class GorgService
       end
 
       def process_softfail(e, message)
-        message.log_error(e)
+        e.gorg_service_message ||= message
         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)
+        process_logging(e)
+        message.softfail_count+=1
+        if message.softfail_count.to_i >= @max_attempts
+          GorgService.logger.info " DISCARD MESSAGE : too much soft errors (#{message.softfail_count})"
+          process_hardfail(HardfailError.new("Too Much SoftError : This message reached the limit of softerror (max: #{@max_attempts})", gorg_service_message: message, error_name: e.error_name), message)
         else
           send_to_deferred_queue(message)
         end
       end
 
       def process_hardfail(e, message)
+        e.gorg_service_message ||= 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
+        process_logging(e)
       end
 
-      def process_logging(message)
+      def process_logging(error)
+        message=error.to_log_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}"
+      def send_to_deferred_queue(message)
+
+        if @env.delayed_queue_for message.routing_key
+          GorgService::Producer.new.publish_message(message, exchange: @env.delayed_in_exchange)
+          #
+          # @env.delayed_in_exchange.publish(msg.to_json, :routing_key => msg.routing_key)
+          GorgService.logger.info "DEFER MESSAGE : message sent to #{@env.delayed_in_exchange.name} with routing key #{message.routing_key}"
         else
           raise "DelayedQueueNotFound"
         end

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

@@ -32,28 +32,29 @@ class GorgService
         end
         alias_method :msg, :message
 
-        def reply_with(data)
-          self.class.reply_to(message, data)
+        def reply_with(*_args, **keyword_args)
+          self.class.reply_to(message,**keyword_args)
         end
 
-        def raise_hardfail(error_message, error: nil, data: nil)
-          self.class.raise_hardfail(error_message, error: error, message:message, data:data)
+        def raise_hardfail(*args, **keyword_args)
+          self.class.raise_hardfail(*args, **(keyword_args.merge(message:message)))
         end
 
-        def raise_softfail(error_message, error: nil, data: nil)
-          self.class.raise_softfail(error_message, error: error, message:message, data:data)
+        def raise_softfail(*args, **keyword_args)
+          self.class.raise_softfail(*args, **(keyword_args.merge(message:message)))
         end
 
         class << self
 
-          def reply_to(message,data)
+          def reply_to(message, data: {}, status_code: 200, error_type: nil, error_name: nil, next_try_in: nil)
             if message.expect_reply?
 
-              reply=GorgService::Message.new(
-                  event: message.reply_routing_key,
+              reply=message.reply_message(
                   data: data,
-                  correlation_id: message.id,
-                  type: "reply"
+                  status_code: status_code,
+                  error_type: error_type,
+                  error_name: error_name,
+                  next_try_in: next_try_in,
               )
 
               replier=GorgService::Producer.new
@@ -61,28 +62,38 @@ class GorgService
             end
           end
 
-          def raise_hardfail(error_message,message:nil, error: nil, data: nil)
+          def raise_hardfail(error_message,message:nil, error: nil, data: nil, status_code: 500, error_name: nil)
             if message
               reply_to(message,{
-                  status: 'hardfail',
-                  error_message: error_message,
-                  debug_message: error&&error.inspect,
-                  error_data: data
+                  error_type: 'hardfail',
+                  status_code: status_code,
+                  error_name: error_name,
+                  data:{
+                    error_message: error_message,
+                    debug_message: error&&error.inspect,
+                    error_data: data
+                  },
+
               })
             end
-            raise HardfailError.new(error_message, error)
+            raise HardfailError.new(error_message, error, gorg_service_message: message, error_name: error_name)
           end
 
-          def raise_softfail(error_message,message:nil, error: nil, data: nil)
+          def raise_softfail(error_message,message:nil, error: nil, data: nil, status_code: 500, error_name: nil)
             if message
               reply_to(message,{
-                  status: 'softfail',
-                  error_message: error_message,
-                  debug_message: error&&error.inspect,
-                  error_data: data
+                  error_type: 'softfail',
+                  next_try_in: GorgService.configuration.rabbitmq_deferred_time.to_i,
+                  status_code: status_code,
+                  error_name: error_name,
+                  data:{
+                      error_message: error_message,
+                      debug_message: error&&error.inspect,
+                      error_data: data
+                  },
               })
             end
-            raise SoftfailError.new(error_message, error)
+            raise SoftfailError.new(error_message, error, gorg_service_message: message, error_name: error_name)
           end
 
           def handle_error(*errorClasses,&block)

data/lib/gorg_service/event_message.rb

@@ -0,0 +1,13 @@
+class GorgService
+  class EventMessage<Message
+
+    def type
+      "event"
+    end
+
+    def validate
+      super
+    end
+
+  end
+end

data/lib/gorg_service/log_message.rb

@@ -0,0 +1,46 @@
+class GorgService
+  class LogMessage<Message
+    # @return [String] Level of the log
+    # 0 => DEBUG
+    # 1 => INFO
+    # 2 => WARNING
+    # 3 => SOFTFAIL
+    # 4 => HARDFAIL
+    attr_accessor :level
+
+    # @return [String] Error type ('hardfail','softfail')
+    attr_accessor :error_type
+
+    # @return [Integer] Time until next attempts in milliseconds
+    attr_accessor :next_try_in
+
+    # @return [String] Name identifying the error
+    attr_accessor :error_name
+
+    def type
+      "log"
+    end
+
+    # @param opts [Hash] Attributes of the message
+    # @option opts [String] :level See {#level}. Default : 1
+    # @option opts [String] :error_type See {#error_type}. Default : nil
+    # @option opts [Integer] :next_try_in See {#next_try_in}. Default : nil
+    # @option opts [String] :error_name See {#error_name}. Default : nil
+    # @see GorgService::Message#initialize
+    def initialize(opts={})
+      super
+      self.level= opts.fetch(:level,1)
+      self.error_type=  opts.fetch(:error_type,nil)
+      self.next_try_in= opts.fetch(:next_try_in,nil)
+      self.error_name=  opts.fetch(:error_name,nil)
+    end
+
+    def validate
+      self.validation_errors[:level]+=["is null"] unless self.level
+      self.validation_errors[:level]+=["is not in [0,1,2,3,4]"] unless (0..4).to_a.include?(self.level)
+      self.validation_errors[:error_type]+=["is not in (softfail hardfail)"] unless self.error_type && (%w(softfail hardfail).include? self.error_type)
+      super
+    end
+
+  end
+end

data/lib/gorg_service/message.rb

@@ -8,11 +8,26 @@ require 'securerandom'
 require "gorg_service/message/json_schema"
 require "gorg_service/message/error_log"
 
+require "gorg_service/reply_message"
+require "gorg_service/event_message"
+require "gorg_service/log_message"
+require "gorg_service/request_message"
+
+require "gorg_service/message/formatters"
+
+
+
+# Message transferred through Bunny. Follow Gorg SOA specification v2.0 ans maintain support for v1.0
+#
+# @author Alexandre Narbonne
 class GorgService
   class Message
 
+    DEFAULT_SOA_VERSION="1.0"
+
     class DataValidationError < StandardError
 
+      # @return [Hash] Mapping of invalid data
       attr_reader :errors
 
       def initialize(errors)
@@ -20,81 +35,165 @@ class GorgService
       end
     end
 
+    class MessageValidationError < StandardError
+
+      # @return [Hash] Mapping of invalid data
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors=errors
+      end
+    end
+
+    # @return [String] UUID of  the message
     attr_accessor :id
-    attr_accessor :reply_to
-    attr_accessor :correlation_id
+
+    # @return [String] Id of the app which generated the message
     attr_accessor :sender_id
+    alias_method :sender, :sender_id
+    alias_method :sender=, :sender_id=
+
+    # @return [String] Content type of the payload
+    # @note The only content type officially supported by Gadz.org SOA is 'application/json'
     attr_accessor :content_type
+
+    # @return [String] Content encoding of the payload
+    # @note The only content encoding officially supported by Gadz.org SOA is 'deflate'
     attr_accessor :content_encoding
-    attr_accessor :headers
-    attr_accessor :type
 
-    attr_accessor :event_id
+    # @return [String] The Gadz.org SOA specs version used to generate this message
+    # @note Incomming message without this information should be considered v1.0
+    attr_accessor :soa_version
+
+    # @return [String] Major version of the soa version
+    def soa_version_major
+      (self.soa_version||DEFAULT_SOA_VERSION).split('.')[0]
+    end
+
+    # @return [String] identifier of the library used to generate this message, for debug and compatibility purpose
+    attr_accessor :client_library
+
+    # @return [String] Identifier of the admin who triggered the generation of this message
+    # @note In case of autonomous actions, there is no admin_id
+    attr_accessor :admin_id
+
+    # @return [String] Routing of the message
     attr_accessor :routing_key
-    attr_accessor :event
+
+    # @return [Hash] Data of the payload as an hash
+    # @note for further compatibility, don't assume that data is an hash but check Content-Type
     attr_accessor :data
-    attr_accessor :errors
+
+    # @return [DateTime] Message generation datetime
     attr_accessor :creation_time
-    attr_accessor :sender
 
+    # @return [String] Name of the exchange used to receive reply
+    attr_accessor :reply_to
+    alias_method :reply_exchange, :reply_to
+
+    # @return [String] UUID of the message the this message refer to (reply or log)
+    attr_accessor :correlation_id
+
+    # @return [nil] Type of message (event,log,request,reply). To be overwritten by children classes
+    def type
+      nil
+    end
+
+    # @return [Hash] Additional headers
+    attr_accessor :headers
+
+    # @return [Integer] Number of softfails associated to this message
+    attr_accessor :softfail_count
+
+    # @deprecated In Gadz.org Soa v2.0 errors are not store in messages anymore
+    # @return [Array<Message::ErrorLog>] List of errors associated to this message
+    attr_accessor :errors
+
+    # @return [Hash] Mapping of attributes errors in regard of Gadz.org SOA v2
+    attr_accessor :validation_errors
+    def validation_errors
+      @validation_errors||= Hash.new([].freeze)
+    end
+
+    # @deprecated Use {#routing_key} instead. event is no longer a part of GorgSOA specs
+    # @return [String] the name of the event
+    attr_accessor :event
+    def event
+      warn "[DEPRECATION] Message.event is deprecated and will be removed soon. Use id instead (called from #{caller_locations(1,1)[0]})"
+      self.routing_key
+    end
+    def event=(value)
+      warn "[DEPRECATION] Message.event is deprecated and will be removed soon. Use id instead  (called from #{caller_locations(1,1)[0]})"
+      self.routing_key=value
+    end
+
+
+
+    # @deprecated Use {#id} instead. event_id is no longer a part of GorgSOA specs
+    # @return [String] UUID of  the message
+    attr_accessor :event_id
+    def event_id
+      warn "[DEPRECATION] Message.event_id is deprecated and will be removed soon. Use id instead  (called from #{caller_locations(1,1)[0]})"
+      self.id
+    end
+    def event_id=(value)
+      warn "[DEPRECATION] Message.event_id is deprecated and will be removed soon. Use id instead  (called from #{caller_locations(1,1)[0]})"
+      self.id=value
+    end
+
+    # @deprecated In Gadz.org Soa v2.0 errors are not store in messages anymore
+    # @return [Array<Message::ErrorLog>] List of errors associated to this message
     def errors
       @errors||=[]
     end
 
-
+    # @param opts [Hash] Attributes of the message
+    # @option opts [String] :id See {#id}. Default : Random UUID4
+    # @option opts [Array<Message::ErrorLog>] :errors  See {#errors}. Default : []
+    # @option opts [DateTime] :creation_time See {#creation_time}. Default :  DateTime.now
+    # @option opts [String] :sender See {#sender}. Default : GorgService.configuration.application_id
+    # @option opts [String] :data See {#data}. Default : nil
+    # @option opts [String] :routing_key See {#routing_key}. Default : nil
+    # @option opts [String] :reply_to See {#reply_to}. Default : nil
+    # @option opts [String] :correlation_id See {#correlation_id}. Default : nil
+    # @option opts [String] :content_type See {#content_type}. Default : "application/json"
+    # @option opts [String] :content_encoding See {#content_encoding}. Default : "deflate"
+    # @option opts [String] :headers See {#headers}. Default : {}
     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")
+      self.id= opts.fetch(:event_id,nil)||opts.fetch(:id,generate_id)
+
+      self.errors= opts.fetch(:errors,[])
+      self.creation_time= opts.fetch(:creation_time,DateTime.now)
+      self.sender= opts.fetch(:sender,application_id)
+      self.data= opts.fetch(:data,nil)
+      self.routing_key= opts.fetch(:routing_key,nil)||opts.fetch(:event,nil)
+      self.softfail_count= opts.fetch(:softfail_count,0)
+
+      self.reply_to= opts.fetch(:reply_to,nil)
+      self.correlation_id= opts.fetch(:correlation_id,nil)
+      self.content_type= opts.fetch(:content_type,"application/json")
+      self.content_encoding= opts.fetch(:content_encoding,"deflate")
+      self.headers= opts.fetch(:headers,{})
+      self.soa_version= opts.fetch(:soa_version, DEFAULT_SOA_VERSION)
     end
 
+    # @deprecated Please use directly the rendering interface of the formatter
+    # @param formatter [Message::FormatterV1] The formatter to be used. Default : an instance of Message::FormatterV1
+    # @return [Hash] The un-serialized payload of the RabbitMq message
     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}
-      end
-      _body
+      Message::Formatter.formatter_for_version(self.soa_version).new(self).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
+    # @deprecated Please use directly the rendering interface of the formatter
+    # @param formatter [Message::FormatterV1] The formatter to be used. Default : an instance of Message::FormatterV1
+    # @return [Hash] The properties of the RabbitMq message
+    def properties(formatter: Message::FormatterV1.new(self))
+      Message::Formatter.formatter_for_version(self.soa_version).new(self).properties
+    end
+
+    # @return [String] The serialized (JSON) value of the RabbitMQ payload
     def to_json
       self.to_h.to_json
     end
@@ -109,22 +208,76 @@ class GorgService
       errors<<e
     end
 
-    def reply_exchange
-      reply_to
-    end
-
+    # @return [Boolean] Does this message expect a reply ?
     def expect_reply?
       !!reply_to
     end
 
+    # @return [Stirng] Routing key to use to reply to this message
     def reply_routing_key
-      event.sub('request','reply')
+      routing_key.sub('request','reply')
+    end
+
+    # @return [GorgService::ReplyMessage] the response to send
+
+    def reply_message(opts)
+      args= {
+              routing_key: self.reply_routing_key,
+              correlation_id: self.id,
+              soa_version: self.soa_version
+            }.merge(opts)
+
+      GorgService::ReplyMessage.new(args)
+    end
+
+    def log_message(opts)
+      args= {
+          routing_key: self.reply_routing_key,
+          correlation_id: self.id,
+          soa_version: '2.0' #v1 messages generate v2 logs
+      }.merge(opts)
+
+      GorgService::LogMessage.new(args)
     end
 
+    # Validate the message against rules specified in {https://confluence.gadz.org/display/INFRA/Messages the Gadz.org SOA Message Specification}
+    def validate
+      self.validation_errors= Hash.new([].freeze)
+
+      self.validation_errors[:content_type]+=["is not supported by Gadz.org SOA"] unless ['application/json'].include? self.content_type
+      self.validation_errors[:content_encoding]+=["is not supported by Gadz.org SOA"] unless ['deflate','gzip'].include? self.content_encoding
+      # "gzip" is not officially supported by Gadz.org but I don't feel comfortable blocking it :)
+
+      self.validation_errors[:id]+=["is null"] unless self.id
+      self.validation_errors[:id]+=["is not a UUID"] unless !self.id ||  /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/.match(self.id)
+
+      self.validation_errors[:correlation_id]+=["is not a UUID"] unless !self.correlation_id || /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/.match()
+
+      self.validation_errors[:creation_time]+=["is not DateTime"] unless self.creation_time.is_a? DateTime
+
+      self.validation_errors[:type]+=["is not in (event, log, request, reply)"] unless %w(event log request reply).include? self.type
+
+      self.validation_errors[:sender]+=["is null"] unless self.sender
+
+      self.validation_errors[:soa_version]+=["is null"] unless self.soa_version
+
+      return self.validation_errors.empty?
+    end
+    alias_method :valid?, :validate
+
+    # @see #validate
+    # @raise [MessageValidationError] Raise an exception containing the errors if the message is invalid
+    def validate!
+      raise MessageValidationError.new(self.errors) unless validate
+    end
+
+    # @param [String,Hash] A JSON Schema usable by {JSON::Validator}
+    # @return [Boolean] True if the message is valid against the provided JSON Schema
+    # @raise [DataValidationError] Validation exception containing errors ( See {DataValidationError#errors})
     def validate_data_with(schema)
-      errors=JSON::Validator.fully_validate(schema, self.data)
-      if errors.any?
-        raise DataValidationError.new(errors)
+      data_validation_errors=JSON::Validator.fully_validate(schema, self.data)
+      if data_validation_errors.any?
+        raise DataValidationError.new(data_validation_errors)
       else
         return true
       end
@@ -134,54 +287,17 @@ class GorgService
 
     ### Class methods
 
+    # @param [Hash] delivery_info delivery_info provided by {Bunny}
+    # @param [Hash] properties properties provided by {Bunny}
+    # @param [Hash] body body provided by {Bunny}
+    # @param [Class] formatter_class The formatter to be used to parse the message. Default to {Message::FormatterV1}
+    # @return [GorgService::Message] A kind of GorgService::Message
     def self.parse(delivery_info, properties, body)
-      begin
-        json_body=JSON.parse(body)
-
-        JSON::Validator.validate!(GorgService::Message::JSON_SCHEMA,json_body)
-
-        msg=self.new(
-            routing_key: delivery_info[:routing_key],
-            id: properties[:message_id],
-            reply_to: properties[:reply_to],
-            correlation_id: properties[:correlation_id],
-            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::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
+      formatter_class=Message::Formatter.formatter_for_version(properties.to_h[:headers].to_h["soa-version"]||"1")
+      formatter_class.parse(delivery_info, properties, body)
     end
 
-
-    def self.convert_keys_to_sym input_hash
-      s2s = 
-      lambda do |h| 
-        Hash === h ? 
-          Hash[
-            h.map do |k, v| 
-              [k.respond_to?(:to_sym) ? k.to_sym : k, s2s[v]] 
-            end 
-          ] : h 
-      end
-      s2s[input_hash]
-    end
-
-    private
-
+    protected
     # Generate new id
     def generate_id 
       SecureRandom.uuid()

data/lib/gorg_service/message/formatters.rb

@@ -0,0 +1,313 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+class GorgService::Message
+    class Formatter
+
+      def initialize(message)
+        @message=message
+      end
+
+      def message
+        @message
+      end
+
+      def self.formatter_for_version(version)
+        major_version=version.split('.')[0]
+        case major_version
+          when '1'
+            FormatterV1
+          when '2'
+            FormatterV2
+          else
+            raise "Unknown Gorg SOA version"
+        end
+      end
+
+      def self.convert_keys_to_sym input_hash
+        s2s =
+            lambda do |h|
+              Hash === h ?
+                  Hash[
+                      h.map do |k, v|
+                        [k.respond_to?(:to_sym) ? k.to_sym : k, s2s[v]]
+                      end
+                  ] : h
+            end
+        s2s[input_hash]
+      end
+
+    end
+
+    class FormatterV1 < Formatter
+
+      JSON_SCHEMA_V1 = JSON.parse('{
+          "$schema": "http://json-schema.org/draft-04/schema#",
+          "type": "object",
+          "properties": {
+            "event_name": {
+              "type": "string",
+              "pattern": "^[_a-z]+((\\.)?[_a-z]+)*$",
+              "description": "Event type. Must match the routing key"
+            },
+            "event_uuid": {
+              "type": "string",
+              "description": "The unique identifier of this message as UUID",
+              "pattern": "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
+            },
+            "event_creation_time": {
+              "type": "string",
+              "description": "Creation time in UTC ISO 8601 format",
+              "pattern": "^([\\\+-]?\\\d{4}(?!\\\d{2}\\\b))((-?)((0[1-9]|1[0-2])(\\\3([12]\\\d|0[1-9]|3[01]))?|W([0-4]\\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\\d|[12]\\\d{2}|3([0-5]\\\d|6[1-6])))([T\\\s]((([01]\\\d|2[0-3])((:?)[0-5]\\\d)?|24\\\:?00)([\\\.,]\\\d+(?!:))?)?(\\\17[0-5]\\\d([\\\.,]\\\d+)?)?([zZ]|([\\\+-])([01]\\\d|2[0-3]):?([0-5]\\\d)?)?)?)?$"
+            },
+            "event_sender_id": {
+              "type": "string",
+              "description": "Producer that sent the original message"
+            },
+            "data": {
+              "type": "object",
+              "description": "Data used to process this message"
+            },
+            "errors_count": {
+              "type": "integer",
+              "description": "Helper for counting errors"
+            },
+            "errors": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "error_type": {
+                    "enum": [  "debug", "info", "warning", "softerror", "harderror" ],
+                    "description": "Type of error."
+                  },
+                  "error_sender": {
+                    "type": "string",
+                    "description": "Consummer that sent this error"
+                  },
+                  "error_code":{
+                    "type":"string",
+                    "description": "Optionnal error code from the consummer"
+                  },
+                  "error_uuid":{
+                    "type":"string",
+                    "description": "The unique identifier of this error as UUID",
+                    "pattern": "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
+                  },
+                  "error_message":{
+                    "type":"string",
+                    "description": "Error explanation"
+                  },
+                  "timestamp": {
+                    "type": "string",
+                    "description": "Time of occuring error in UTC ISO 8601",
+                    "pattern": "^([\\\+-]?\\\d{4}(?!\\\d{2}\\\b))((-?)((0[1-9]|1[0-2])(\\\3([12]\\\d|0[1-9]|3[01]))?|W([0-4]\\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\\d|[12]\\\d{2}|3([0-5]\\\d|6[1-6])))([T\\\s]((([01]\\\d|2[0-3])((:?)[0-5]\\\d)?|24\\\:?00)([\\\.,]\\\d+(?!:))?)?(\\\17[0-5]\\\d([\\\.,]\\\d+)?)?([zZ]|([\\\+-])([01]\\\d|2[0-3]):?([0-5]\\\d)?)?)?)?$"
+                  },
+                  "error_debug": {
+                    "type": "object",
+                    "description": "Complementary informations for debugging"
+                  }
+                },
+                "additionalProperties": false,
+                "required": [
+                  "error_type",
+                  "error_sender",
+                  "timestamp",
+                  "error_uuid",
+                  "error_message"
+                ]
+              }
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "event_name",
+            "event_uuid",
+            "event_creation_time",
+            "event_sender_id",
+            "data"
+          ]
+        }')
+
+      DEFAULT_HEADERS={
+          "soa-version" => "1.0",
+          "client-library" => "GorgService #{GorgService::VERSION}",
+      }
+
+      def properties
+        {
+            routing_key: message.routing_key,
+            reply_to: message.reply_to,
+            correlation_id: message.correlation_id,
+            content_type: message.content_type,
+            content_encoding: message.content_encoding,
+            headers: DEFAULT_HEADERS.merge(message.headers.to_h).merge(
+                'softfail-count' => message.softfail_count,
+            ),
+            app_id: message.sender_id,
+            type: message.type,
+            message_id: message.id,
+        }
+      end
+
+      def body
+        b={
+            event_uuid: message.id,
+            event_name: message.routing_key,
+            event_sender_id: message.sender,
+            event_creation_time: message.creation_time.iso8601,
+            data: message.data,
+        }
+        if message.errors.any?
+          b[:errors_count]=message.errors.count
+          b[:errors]=message.errors.map{|e| e.to_h}
+        end
+        b
+      end
+
+      def payload
+        body.to_json
+      end
+
+      def self.parse(delivery_info, properties, body)
+        begin
+          json_body=JSON.parse(body)
+          JSON::Validator.validate!(JSON_SCHEMA_V1, json_body)
+
+          msg=GorgService::Message.new(
+              routing_key: delivery_info[:routing_key],
+              reply_to: properties[:reply_to],
+              correlation_id: properties[:correlation_id],
+              sender_id: properties[:app_id],
+              content_type: properties[:content_type],
+              content_encoding: properties[:content_encoding],
+              headers: properties[:headers],
+              type: properties[:type],
+
+              softfail_count: properties[:headers].to_h.delete('softfail-count'),
+
+              id: json_body["event_uuid"],
+              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::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
+    end
+
+
+    class FormatterV2 < Formatter
+
+      DEFAULT_HEADERS={
+          "soa-version" => "2.0",
+          "client-library" => "GorgService #{GorgService::VERSION}",
+      }
+
+      EXTRA_HEADERS_FOR ={
+          GorgService::ReplyMessage => {
+              'status-code' => :status_code,
+              'error-type' => :error_type,
+              'next-try-in' => :next_try_in,
+              'error-name' => :error_name,
+          },
+          GorgService::LogMessage => {
+              'level' => :level,
+              'error-type' => :error_type,
+              'next-try-in' => :next_try_in,
+              'error-name' => :error_name,
+          },
+
+      }
+
+      def properties
+
+        headers=DEFAULT_HEADERS.merge(message.headers.to_h).merge(
+            'softfail-count' => message.softfail_count,
+        )
+
+        extra_headers=EXTRA_HEADERS_FOR[message.class].to_h.map do|key,method_name|
+          [key,message.public_send(method_name)]
+        end.to_h
+
+
+        headers.merge!(extra_headers)
+
+        {
+            routing_key: message.routing_key,
+            reply_to: message.reply_to,
+            correlation_id: message.correlation_id,
+            content_type: message.content_type,
+            content_encoding: message.content_encoding,
+            headers: headers,
+            app_id: message.sender_id,
+            type: message.type,
+            message_id: message.id,
+        }
+      end
+
+      def body
+        message.data
+      end
+
+      def payload
+        body.to_json
+      end
+
+      def self.parse(delivery_info, properties, body)
+        begin
+
+          type=properties[:type]
+          unless type
+            type=delivery_info[:routing_key].split('.').first
+          end
+
+          type_map={event: GorgService::EventMessage, request: GorgService::RequestMessage, reply: GorgService::ReplyMessage, log: GorgService::LogMessage}
+          klass=type_map[type.to_s.to_sym]
+
+          raise "Unknown type" unless klass
+
+          headers=properties[:headers]||{}
+
+          args={
+              data: convert_keys_to_sym(JSON.parse(body)),
+              id:properties[:message_id],
+
+              creation_time: properties[:timestamp] && DateTime.parse(properties[:timestamp]),
+              sender:properties[:app_id],
+              routing_key: delivery_info[:routing_key],
+
+              reply_to: properties[:reply_to],
+              correlation_id: properties[:correlation_id],
+              content_type: properties[:content_type],
+              content_encoding:properties[:content_encoding],
+              soa_version: headers.delete('soa-version'),
+
+              softfail_count: headers.delete('softfail-count'),
+
+              headers: headers,
+          }
+
+          extra_args=EXTRA_HEADERS_FOR[klass].to_h.map do |key,method_name|
+            [method_name,headers.delete(key)]
+          end.to_h
+
+          args.merge!(extra_args)
+
+          klass.new(args)
+        rescue JSON::ParserError => e
+          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
+
+    end
+end

data/lib/gorg_service/message/json_schema.rb

@@ -6,93 +6,7 @@ require 'json'
 class GorgService
   class Message
 
-    JSON_SCHEMA = JSON.parse('{
-  "$schema": "http://json-schema.org/draft-04/schema#",
-  "type": "object",
-  "properties": {
-    "event_name": {
-      "type": "string",
-      "pattern": "^[_a-z]+((\\.)?[_a-z]+)*$",
-      "description": "Event type. Must match the routing key"
-    },
-    "event_uuid": {
-      "type": "string",
-      "description": "The unique identifier of this message as UUID",
-      "pattern": "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
-    },
-    "event_creation_time": {
-      "type": "string",
-      "description": "Creation time in UTC ISO 8601 format",
-      "pattern": "^([\\\+-]?\\\d{4}(?!\\\d{2}\\\b))((-?)((0[1-9]|1[0-2])(\\\3([12]\\\d|0[1-9]|3[01]))?|W([0-4]\\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\\d|[12]\\\d{2}|3([0-5]\\\d|6[1-6])))([T\\\s]((([01]\\\d|2[0-3])((:?)[0-5]\\\d)?|24\\\:?00)([\\\.,]\\\d+(?!:))?)?(\\\17[0-5]\\\d([\\\.,]\\\d+)?)?([zZ]|([\\\+-])([01]\\\d|2[0-3]):?([0-5]\\\d)?)?)?)?$"
-    },
-    "event_sender_id": {
-      "type": "string",
-      "description": "Producer that sent the original message"
-    }, 
-    "data": {
-      "type": "object",
-      "description": "Data used to process this message"
-    },
-    "errors_count": {
-      "type": "integer",
-      "description": "Helper for counting errors"
-    },
-    "errors": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "properties": {
-          "error_type": {
-            "enum": [  "debug", "info", "warning", "softerror", "harderror" ],
-            "description": "Type of error."
-          },
-          "error_sender": {
-            "type": "string",
-            "description": "Consummer that sent this error"
-          },
-          "error_code":{
-            "type":"string",
-            "description": "Optionnal error code from the consummer"
-          },
-          "error_uuid":{
-            "type":"string",
-            "description": "The unique identifier of this error as UUID",
-            "pattern": "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
-          },
-          "error_message":{
-            "type":"string",
-            "description": "Error explanation"
-          },          
-          "timestamp": {
-            "type": "string",
-            "description": "Time of occuring error in UTC ISO 8601",
-            "pattern": "^([\\\+-]?\\\d{4}(?!\\\d{2}\\\b))((-?)((0[1-9]|1[0-2])(\\\3([12]\\\d|0[1-9]|3[01]))?|W([0-4]\\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\\d|[12]\\\d{2}|3([0-5]\\\d|6[1-6])))([T\\\s]((([01]\\\d|2[0-3])((:?)[0-5]\\\d)?|24\\\:?00)([\\\.,]\\\d+(?!:))?)?(\\\17[0-5]\\\d([\\\.,]\\\d+)?)?([zZ]|([\\\+-])([01]\\\d|2[0-3]):?([0-5]\\\d)?)?)?)?$"
-          },
-          "error_debug": {
-            "type": "object",
-            "description": "Complementary informations for debugging"
-          }
-        },
-        "additionalProperties": false,
-        "required": [
-          "error_type",
-          "error_sender",
-          "timestamp",
-          "error_uuid",
-          "error_message"
-        ]
-      }
-    }
-  },
-  "additionalProperties": false,
-  "required": [
-    "event_name",
-    "event_uuid",
-    "event_creation_time",
-    "event_sender_id",
-    "data"
-  ]
-}')
+
 
 end
 end

data/lib/gorg_service/reply_message.rb

@@ -0,0 +1,41 @@
+class GorgService
+  class ReplyMessage<Message
+
+    # @return [String] Error code, HTTP like
+    attr_accessor :status_code
+
+    # @return [String] Error type ('hardfail','softfail')
+    attr_accessor :error_type
+
+    # @return [Integer] Time until next attempts in milliseconds
+    attr_accessor :next_try_in
+
+    # @return [String] Name identifying the error
+    attr_accessor :error_name
+
+    def type
+      "reply"
+    end
+
+    # @param opts [Hash] Attributes of the message
+    # @option opts [String] :status_code See {#status_code}. Default : nil
+    # @option opts [String] :error_type See {#error_type}. Default : nil
+    # @option opts [Integer] :next_try_in See {#next_try_in}. Default : nil
+    # @option opts [String] :error_name See {#error_name}. Default : nil
+    # @see GorgService::Message#initialize
+    def initialize(opts={})
+      super
+      self.status_code= opts.fetch(:status_code,nil)
+      self.error_type=  opts.fetch(:error_type,nil)
+      self.next_try_in= opts.fetch(:next_try_in,nil)
+      self.error_name=  opts.fetch(:error_name,nil)
+    end
+
+    def validate
+      self.validation_errors[:status_code]+=["is null"] unless self.status_code
+      self.validation_errors[:error_type]+=["is not in (softfail hardfail)"] unless self.error_type && (%w(softfail hardfail).include? self.error_type)
+      super
+    end
+
+  end
+end

data/lib/gorg_service/request_message.rb

@@ -0,0 +1,13 @@
+class GorgService
+  class RequestMessage<Message
+
+    def type
+      "request"
+    end
+
+    def validate
+      super
+    end
+
+  end
+  end

data/lib/gorg_service/rspec/log_message_handler.rb

@@ -9,15 +9,15 @@ class LogMessageHandler < GorgService::Consumer::MessageHandler::Base
   end
 
   def self.has_received_error?(type)
-    messages.any?{|m| m.errors.any?{|x| x.type==type}}
+    messages.any?{|m| m.errors.any?{|x| x.type==type}} || messages.any?{|m| m.type=='log'&&m.error_type=type}
   end
 
   def self.has_received_hardfail?
-    self.has_received_error?("harderror")
+    self.has_received_error?("hardfail")
   end
 
-  def self.has_received_hardfail?
-    self.has_received_error?("softerror")
+  def self.has_received_softfail?
+    self.has_received_error?("softfail")
   end
 
   def self.has_received_a_message_with_routing_key?(routing_key)

data/lib/gorg_service/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gorg_service
 version: !ruby/object:Gem::Version
-  version: 5.3.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Alexandre Narbonne
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-18 00:00:00.000000000 Z
+date: 2017-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -86,6 +86,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -106,14 +120,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '0.13'
 - !ruby/object:Gem::Dependency
   name: bogus
   requirement: !ruby/object:Gem::Requirement
@@ -173,11 +201,16 @@ files:
 - 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/event_message.rb
+- lib/gorg_service/log_message.rb
 - lib/gorg_service/message.rb
 - lib/gorg_service/message/error_log.rb
+- lib/gorg_service/message/formatters.rb
 - lib/gorg_service/message/json_schema.rb
 - lib/gorg_service/producer.rb
 - lib/gorg_service/rabbitmq_env_builder.rb
+- lib/gorg_service/reply_message.rb
+- lib/gorg_service/request_message.rb
 - lib/gorg_service/rspec/bunny_cleaner.rb
 - lib/gorg_service/rspec/log_message_handler.rb
 - lib/gorg_service/version.rb