eventhub-processor 0.3.1 → 0.4.0

data/lib/eventhub/helper.rb

@@ -1,49 +1,49 @@
-module EventHub
-
-	module Helper
-
-		# converts a class like EventHub::PlateStore::MyClassName to an array ['event_hub','plate_store','my_class_name']
-		def class_to_array(class_name)
-			class_name.to_s.split("::").map{ |m| m.gsub(/[A-Z]/) { |c| "_#{c}"}.gsub(/^_/,"").downcase }
-		end
-
-		# replaces CR, LF, CRLF with ";" and cut's string to requied length by adding "..." if string would be longer
-		def format_string(message,max_characters=80)
-		  max_characters = 5 if max_characters < 5
-		  m = message.gsub(/\r\n|\n|\r/m,";")
-		  return (m[0..max_characters-4] + "...") if m.size > max_characters
-		  return m
-	  end
-
-	  def now_stamp(now=nil)
-	  	now ||= Time.now
-      now.utc.strftime("%Y-%m-%dT%H:%M:%S.#{now.usec}Z")
-	  end
-
-	  def duration(difference)
-	  	negative = difference < 0
-	  	difference = difference.abs
-
-			rest, secs = difference.divmod( 60 )  # self is the time difference t2 - t1
-			rest, mins = rest.divmod( 60 )
-			days, hours = rest.divmod( 24 )
-			secs = secs.truncate
-			milliseconds = ((difference - difference.truncate)*1000).round
-
-			result = []
-			result << "#{days} days" if days > 1
-			result << "#{days} day" if days == 1
-			result << "#{hours} hours" if hours > 1
-			result << "#{hours} hour" if hours == 1
-			result << "#{mins} minutes" if mins > 1
-			result << "#{mins} minute" if mins == 1
-			result << "#{secs} seconds" if secs > 1
-			result << "#{secs} second" if secs == 1
-			result << "#{milliseconds} milliseconds" if milliseconds > 1
-			result << "#{milliseconds} millisecond" if milliseconds == 1
-			return (negative ? "-" : "") + result.join(' ')
-    end
-
-	end
-
-end
+module EventHub
+
+	module Helper
+
+		# converts a class like EventHub::PlateStore::MyClassName to an array ['event_hub','plate_store','my_class_name']
+		def class_to_array(class_name)
+			class_name.to_s.split("::").map{ |m| m.gsub(/[A-Z]/) { |c| "_#{c}"}.gsub(/^_/,"").downcase }
+		end
+
+		# replaces CR, LF, CRLF with ";" and cut's string to requied length by adding "..." if string would be longer
+		def format_string(message,max_characters=80)
+		  max_characters = 5 if max_characters < 5
+		  m = message.gsub(/\r\n|\n|\r/m,";")
+		  return (m[0..max_characters-4] + "...") if m.size > max_characters
+		  return m
+	  end
+
+	  def now_stamp(now=nil)
+	  	now ||= Time.now
+      now.utc.strftime("%Y-%m-%dT%H:%M:%S.#{now.usec}Z")
+	  end
+
+	  def duration(difference)
+	  	negative = difference < 0
+	  	difference = difference.abs
+
+			rest, secs = difference.divmod( 60 )  # self is the time difference t2 - t1
+			rest, mins = rest.divmod( 60 )
+			days, hours = rest.divmod( 24 )
+			secs = secs.truncate
+			milliseconds = ((difference - difference.truncate)*1000).round
+
+			result = []
+			result << "#{days} days" if days > 1
+			result << "#{days} day" if days == 1
+			result << "#{hours} hours" if hours > 1
+			result << "#{hours} hour" if hours == 1
+			result << "#{mins} minutes" if mins > 1
+			result << "#{mins} minute" if mins == 1
+			result << "#{secs} seconds" if secs > 1
+			result << "#{secs} second" if secs == 1
+			result << "#{milliseconds} milliseconds" if milliseconds > 1
+			result << "#{milliseconds} millisecond" if milliseconds == 1
+			return (negative ? "-" : "") + result.join(' ')
+    end
+
+	end
+
+end

data/lib/eventhub/message.rb

@@ -1,138 +1,138 @@
-module EventHub
-
-  class Message
-    include Helper
-
-    VERSION = '1.0.0'
-
-    # Headers that are required (value can be nil) in order to pass valid?
-    REQUIRED_HEADERS = [
-      'message_id',
-      'version',
-      'created_at',
-      'origin.module_id',
-      'origin.type',
-      'origin.site_id',
-      'process.name',
-      'process.step_position',
-      'process.execution_id',
-      'status.retried_count',
-      'status.code',
-      'status.message'
-    ]
-
-    attr_accessor :header, :body, :raw, :vhost, :routing_key
-
-    # Build accessors for all required headers
-    REQUIRED_HEADERS.each do |header|
-      name = header.gsub(/\./,"_")
-
-      define_method(name) do
-        self.header.get(header)
-      end
-
-      define_method("#{name}=") do |value|
-        self.header.set(header,value)
-      end
-    end
-
-    def self.from_json(raw)
-      data = JSON.parse(raw)
-      Message.new(data.get('header'), data.get('body'),raw)
-    rescue => e
-      Message.new({ "status" =>  { "code" => STATUS_INVALID, "message" => "JSON parse error: #{e}" }} ,{ "original_message_base64_encoded" => Base64.encode64(raw)},raw)
-    end
-
-    def initialize(header = nil, body = nil, raw = nil)
-
-      @header = header || {}
-      @body   = body || {}
-      @raw    = raw
-
-      # set message defaults, that we have required headers
-      @header.set('message_id', UUIDTools::UUID.timestamp_create.to_s, false)
-      @header.set('version', VERSION, false)
-      @header.set('created_at', now_stamp, false)
-
-      @header.set('origin.module_id', 'undefined', false)
-      @header.set('origin.type', 'undefined', false)
-      @header.set('origin.site_id', 'undefined', false)
-
-      @header.set('process.name', 'undefined', false)
-      @header.set('process.execution_id', UUIDTools::UUID.timestamp_create.to_s, false)
-      @header.set('process.step_position', 0, false)
-
-      @header.set('status.retried_count', 0, false)
-      @header.set('status.code', STATUS_INITIAL, false)
-      @header.set('status.message', '', false)
-
-    end
-
-    def valid?
-      # check for existence and defined value
-      REQUIRED_HEADERS.all? { |key| @header.all_keys_with_path.include?(key) && !!self.send(key.gsub(/\./,"_").to_sym)}
-    end
-
-    def success?
-      self.status_code == STATUS_SUCCESS
-    end
-
-    def retry?
-      !success?
-    end
-
-    def initial?
-      self.status_code == STATUS_INITIAL
-    end
-
-    def retry_pending?
-      self.status_code == STATUS_RETRY_PENDING
-    end
-
-    def invalid?
-      self.status_code == STATUS_INVALID
-    end
-
-    def to_json
-      {'header' => self.header, 'body' => self.body}.to_json
-    end
-
-    def to_s
-      "Msg: process [#{self.process_name},#{self.process_step_position},#{self.process_execution_id}], status [#{self.status_code},#{self.status_message},#{self.status_retried_count}]"
-    end
-
-    # copies the message and set's provided status code (default: success), actual stamp, and a new message id
-    def copy(status_code = STATUS_SUCCESS)
-
-      # use Marshal dump and load to make a deep object copy
-      copied_header = Marshal.load( Marshal.dump(header))
-      copied_body   = Marshal.load( Marshal.dump(body))
-
-      copied_header.set("message_id",UUIDTools::UUID.timestamp_create.to_s)
-      copied_header.set("created_at",now_stamp)
-      copied_header.set("status.code",status_code)
-
-      Message.new(copied_header, copied_body)
-    end
-
-    def append_to_execution_history(processor_name)
-      unless header.get('execution_history')
-        header.set('execution_history', [])
-      end
-      header.get('execution_history') << {'processor' => processor_name, 'timestamp' => now_stamp}
-    end
-
-    def self.translate_status_code(code)
-      case code
-        when EventHub::STATUS_INITIAL       then return 'STATUS_INITIAL'
-        when EventHub::STATUS_SUCCESS       then return 'STATUS_SUCCESS'
-        when EventHub::STATUS_RETRY         then return 'STATUS_RETRY'
-        when EventHub::STATUS_RETRY_PENDING then return 'STATUS_RETRY_PENDING'
-        when EventHub::STATUS_INVALID       then return 'STATUS_INVALID'
-        when EventHub::STATUS_DEADLETTER    then return 'STATUS_DEADLETTER'
-      end
-    end
-
-  end
-
-end
+module EventHub
+
+  class Message
+    include Helper
+
+    VERSION = '1.0.0'
+
+    # Headers that are required (value can be nil) in order to pass valid?
+    REQUIRED_HEADERS = [
+      'message_id',
+      'version',
+      'created_at',
+      'origin.module_id',
+      'origin.type',
+      'origin.site_id',
+      'process.name',
+      'process.step_position',
+      'process.execution_id',
+      'status.retried_count',
+      'status.code',
+      'status.message'
+    ]
+
+    attr_accessor :header, :body, :raw, :vhost, :routing_key
+
+    # Build accessors for all required headers
+    REQUIRED_HEADERS.each do |header|
+      name = header.gsub(/\./,"_")
+
+      define_method(name) do
+        self.header.get(header)
+      end
+
+      define_method("#{name}=") do |value|
+        self.header.set(header,value)
+      end
+    end
+
+    def self.from_json(raw)
+      data = JSON.parse(raw)
+      Message.new(data.get('header'), data.get('body'),raw)
+    rescue => e
+      Message.new({ "status" =>  { "code" => STATUS_INVALID, "message" => "JSON parse error: #{e}" }} ,{ "original_message_base64_encoded" => Base64.encode64(raw)},raw)
+    end
+
+    def initialize(header = nil, body = nil, raw = nil)
+
+      @header = header || {}
+      @body   = body || {}
+      @raw    = raw
+
+      # set message defaults, that we have required headers
+      @header.set('message_id', UUIDTools::UUID.timestamp_create.to_s, false)
+      @header.set('version', VERSION, false)
+      @header.set('created_at', now_stamp, false)
+
+      @header.set('origin.module_id', 'undefined', false)
+      @header.set('origin.type', 'undefined', false)
+      @header.set('origin.site_id', 'undefined', false)
+
+      @header.set('process.name', 'undefined', false)
+      @header.set('process.execution_id', UUIDTools::UUID.timestamp_create.to_s, false)
+      @header.set('process.step_position', 0, false)
+
+      @header.set('status.retried_count', 0, false)
+      @header.set('status.code', STATUS_INITIAL, false)
+      @header.set('status.message', '', false)
+
+    end
+
+    def valid?
+      # check for existence and defined value
+      REQUIRED_HEADERS.all? { |key| @header.all_keys_with_path.include?(key) && !!self.send(key.gsub(/\./,"_").to_sym)}
+    end
+
+    def success?
+      self.status_code == STATUS_SUCCESS
+    end
+
+    def retry?
+      !success?
+    end
+
+    def initial?
+      self.status_code == STATUS_INITIAL
+    end
+
+    def retry_pending?
+      self.status_code == STATUS_RETRY_PENDING
+    end
+
+    def invalid?
+      self.status_code == STATUS_INVALID
+    end
+
+    def to_json
+      {'header' => self.header, 'body' => self.body}.to_json
+    end
+
+    def to_s
+      "Msg: process [#{self.process_name},#{self.process_step_position},#{self.process_execution_id}], status [#{self.status_code},#{self.status_message},#{self.status_retried_count}]"
+    end
+
+    # copies the message and set's provided status code (default: success), actual stamp, and a new message id
+    def copy(status_code = STATUS_SUCCESS)
+
+      # use Marshal dump and load to make a deep object copy
+      copied_header = Marshal.load( Marshal.dump(header))
+      copied_body   = Marshal.load( Marshal.dump(body))
+
+      copied_header.set("message_id",UUIDTools::UUID.timestamp_create.to_s)
+      copied_header.set("created_at",now_stamp)
+      copied_header.set("status.code",status_code)
+
+      Message.new(copied_header, copied_body)
+    end
+
+    def append_to_execution_history(processor_name)
+      unless header.get('execution_history')
+        header.set('execution_history', [])
+      end
+      header.get('execution_history') << {'processor' => processor_name, 'timestamp' => now_stamp}
+    end
+
+    def self.translate_status_code(code)
+      case code
+        when EventHub::STATUS_INITIAL       then return 'STATUS_INITIAL'
+        when EventHub::STATUS_SUCCESS       then return 'STATUS_SUCCESS'
+        when EventHub::STATUS_RETRY         then return 'STATUS_RETRY'
+        when EventHub::STATUS_RETRY_PENDING then return 'STATUS_RETRY_PENDING'
+        when EventHub::STATUS_INVALID       then return 'STATUS_INVALID'
+        when EventHub::STATUS_DEADLETTER    then return 'STATUS_DEADLETTER'
+      end
+    end
+
+  end
+
+end

data/lib/eventhub/message_processor.rb

@@ -1,31 +1,31 @@
-class EventHub::MessageProcessor
-  attr_reader :processor
-
-  def initialize(processor)
-    @processor = processor
-  end
-
-  def process(params, payload)
-    messages_to_send = []
-
-    # try to convert to EventHub message
-    message = EventHub::Message.from_json(payload)
-    EventHub.logger.info("-> #{message.to_s}")
-
-    message.append_to_execution_history(self.processor.name)
-
-    if message.invalid?
-      messages_to_send << message
-      EventHub.logger.info("-> #{message.to_s} => Put to queue [#{EventHub::EH_X_INBOUND}].")
-    else
-      # pass received message to handler or dervied handler
-      if processor.method(:handle_message).arity == 1
-        messages_to_send = Array(processor.handle_message(message))
-      else
-        messages_to_send = Array(processor.handle_message(message,params))
-      end
-    end
-
-    messages_to_send
-  end
-end
+class EventHub::MessageProcessor
+  attr_reader :processor
+
+  def initialize(processor)
+    @processor = processor
+  end
+
+  def process(params, payload)
+    messages_to_send = []
+
+    # try to convert to EventHub message
+    message = EventHub::Message.from_json(payload)
+    EventHub.logger.info("-> #{message.to_s}")
+
+    message.append_to_execution_history(self.processor.name)
+
+    if message.invalid?
+      messages_to_send << message
+      EventHub.logger.info("-> #{message.to_s} => Put to queue [#{EventHub::EH_X_INBOUND}].")
+    else
+      # pass received message to handler or dervied handler
+      if processor.method(:handle_message).arity == 1
+        messages_to_send = Array(processor.handle_message(message))
+      else
+        messages_to_send = Array(processor.handle_message(message,params))
+      end
+    end
+
+    messages_to_send
+  end
+end

data/lib/eventhub/no_deadletter_exception.rb

@@ -1,2 +1,2 @@
-class EventHub::NoDeadletterException < EventHub::BaseException
+class EventHub::NoDeadletterException < EventHub::BaseException
 end

data/lib/eventhub/processor.rb

@@ -1,268 +1,269 @@
-module EventHub
-	class Processor
-		attr_reader :statistics, :name, :pidfile
-
-		include Helper
-
-		def version
-			"1.0.0"
-		end
-
-		def initialize(name=nil)
-			@name = name || class_to_array(self.class)[1..-1].join(".")
-			@pidfile = EventHub::Pidfile.new(File.join(Dir.pwd, 'pids', "#{name}.pid"))
-			@statistics = EventHub::Statistics.new
-			@heartbeat = EventHub::Heartbeat.new(self)
-			@message_processor = EventHub::MessageProcessor.new(self)
-
-			@channel_receiver = nil
-			@channel_sender		= nil
-			@restart = true
-		end
-
-		def configuration
-			EventHub::Configuration.instance.data
-		end
-
-		def server_host
-			configuration.get('server.host') || 'localhost'
-		end
-
-		def server_user
-			configuration.get('server.user') || 'admin'
-		end
-
-		def server_password
-			configuration.get('server.password') || 'admin'
-		end
-
-		def server_management_port
-			configuration.get('server.management_port') || 15672
-		end
-
-		def server_vhost
-			configuration.get('server.vhost') || 'event_hub'
-		end
-
-		def connection_settings
-			{ user: server_user, password: server_password, host: server_host, vhost: server_vhost }
-		end
-
-		def listener_queues
-			Array(
-				configuration.get('processor.listener_queue') ||
-				configuration.get('processor.listener_queues') ||
-				'undefined_listener_queues'
-			)
-		end
-
-		def watchdog_cycle_in_s
-			configuration.get('processor.watchdog_cycle_is_s') || 15
-		end
-
-		def restart_in_s
-			configuration.get('processor.restart_in_s') || 15
-		end
-
-		def heartbeat_cycle_in_s
-			configuration.get('processor.heartbeat_cycle_in_s') || 300
-		end
-
-		def start(detached = false)
-			daemonize if detached
-
-			EventHub.logger.info("Processor [#{@name}] base folder [#{Dir.pwd}]")
-
-			# use timer here to have last heartbeat message working
-			Signal.trap("TERM") { EventMachine.add_timer(0) { about_to_stop } }
-		  Signal.trap("INT")  { EventMachine.add_timer(0) { about_to_stop } }
-
-			while @restart
-				begin
-					handle_start_internal
-
-					# custom post start method to be overwritten
-					post_start
-
-				rescue => e
-					id = EventHub.logger.save_detailed_error(e)
-					EventHub.logger.error("Unexpected exception: #{e}, see => #{id}. Trying to restart in #{self.restart_in_s} seconds...")
-					sleep_break self.restart_in_s
-				end
-			end # while
-
-			# custon post stop method to be overwritten
-			post_stop
-
-			EventHub.logger.info("Processor [#{@name}] has been stopped")
-		ensure
-			pidfile.delete
-		end
-
-		def handle_message(metadata, payload)
-			raise "Please implement method in derived class"
-		end
-
-		def watchdog
-			self.listener_queues.each do |queue_name|
-				begin
-					response = RestClient.get "http://#{self.server_user}:#{self.server_password}@#{self.server_host}:#{self.server_management_port}/api/queues/#{self.server_vhost}/#{queue_name}/bindings", { :content_type => :json}
-	  			data = JSON.parse(response.body)
-
-	  			if response.code != 200
-	  				EventHub.logger.warn("Watchdog: Server did not answered properly. Trying to restart in #{self.restart_in_s} seconds...")
-	  				EventMachine.add_timer(self.restart_in_s) { stop_processor(true) }
-	  			elsif data.size == 0
-	  				EventHub.logger.warn("Watchdog: Something is wrong with the vhost, queue [#{queue_name}], and/or bindings. Trying to restart in #{self.restart_in_s} seconds...")
-	  				EventMachine.add_timer(self.restart_in_s) { stop_processor(true) }
-	  				# does it make sence ? Needs maybe more checks in future
-	  			else
-	  				# Watchdog is happy :-)
-						# add timer for next check
-						EventMachine.add_timer(self.watchdog_cycle_in_s) { watchdog }
-					end
-
-				rescue => e
-					EventHub.logger.error("Watchdog: Unexpected exception: #{e}. Trying to restart in #{self.restart_in_s} seconds...")
-					stop_processor
-				end
-			end
-		end
-
-		# send message
-		def send_message(message, exchange_name = EventHub::EH_X_INBOUND)
-
-			if @channel_sender.nil? || !@channel_sender.open?
-				@channel_sender = AMQP::Channel.new(@connection, prefetch: 1)
-
-				# use publisher confirm
-				@channel_sender.confirm_select
-
-				# @channel.on_error { |ch, channel_close| EventHub.logger.error "Oops! a channel-level exception: #{channel_close.reply_text}" }
-        # @channel.on_ack   { |basic_ack| EventHub.logger.info "Received basic_ack: multiple = #{basic_ack.multiple}, delivery_tag = #{basic_ack.delivery_tag}" }
-			end
-
-			exchange = @channel_sender.direct(exchange_name, :durable => true, :auto_delete => false)
-   		exchange.publish(message.to_json, :persistent => true)
-		end
-
-  	def sleep_break(seconds) # breaks after n seconds or after interrupt
-  		while (seconds > 0)
-    		sleep(1)
-    		seconds -= 1
-    		break unless @restart
-  		end
-		end
-
-		private
-
-		def handle_start_internal
-			AMQP.start(self.connection_settings) do |connection, open_ok|
-				@connection = connection
-
-				handle_connection_loss
-
-				# create channel
-				@channel_receiver = AMQP::Channel.new(@connection, prefetch: 1)
-
-				self.listener_queues.each do |queue_name|
-
-			  	# connect to queue
-			  	queue = @channel_receiver.queue(queue_name, durable: true, auto_delete: false)
-
-			  	# subscribe to queue
-				  queue.subscribe(:ack => true) do |metadata, payload|
-				  	begin
-				  		statistics.measure(payload.size) do
-					  		messages_to_send = @message_processor.process({ metadata: metadata, queue_name: queue_name}, payload)
-
-					  		# forward invalid or returned messages to dispatcher
-						    messages_to_send.each do |message|
-						      send_message(message)
-						    end if messages_to_send
-
-		    				@channel_receiver.acknowledge(metadata.delivery_tag)
-		    			end
-
-		    		rescue EventHub::NoDeadletterException => e
-				  		@channel_receiver.reject(metadata.delivery_tag, true)
-				  		EventHub.logger.error("Unexpected exception in handle_message method: #{e}. Message will be requeued.")
-							EventHub.logger.save_detailed_error(e)
-							sleep_break self.restart_in_s
-				  	rescue => e
-				  		@channel_receiver.reject(metadata.delivery_tag, false)
-				  		EventHub.logger.error("Unexpected exception in handle_message method: #{e}. Message dead lettered.")
-							EventHub.logger.save_detailed_error(e,payload)
-				  	end
-				  end
-
-				end
-
-			  EventHub.logger.info("Processor [#{@name}] is listening to vhost [#{self.server_vhost}], queues [#{self.listener_queues.join(", ")}]")
-
-				register_timers
-
-				# send first heartbeat
-				heartbeat
-			end
-		end
-
-		def handle_connection_loss
-			@connection.on_tcp_connection_loss do |conn, settings|
-	  		EventHub.logger.warn("Processor lost tcp connection. Trying to restart in #{self.restart_in_s} seconds...")
-	  		stop_processor(true)
-	  	end
-		end
-
-		def register_timers
-		  EventMachine.add_timer(watchdog_cycle_in_s) { watchdog }
-		  EventMachine.add_periodic_timer(heartbeat_cycle_in_s) { heartbeat }
-		end
-
-		def heartbeat(action="running")
-			message = @heartbeat.build_message(action)
-			message.append_to_execution_history(@name)
-		  send_message(message)
-		end
-
-		def about_to_stop
-			heartbeat("stopped")
-			stop_processor
-		end
-
-		def stop_processor(restart=false)
-			@restart = restart
-
-			# close channels
-			[@channel_receiver,@channel_sender].each do |channel|
-				if channel
-					channel.close if channel.open?
-				end
-			end
-
-			# stop connection and event loop
-			if @connection
-				@connection.disconnect if @connection.connected?
-				EventMachine.stop if EventMachine.reactor_running?
-			end
-		end
-
-		def daemonize
-			EventHub.logger.info("Processor [#{@name}] is going to start as daemon")
-
-			# daemonize
-			Process.daemon
-
-			pidfile.write(Process.pid.to_s)
-		end
-
-		def post_start
-			# method which can be overwritten to call a code sequence after reactor start
-		end
-
-		def post_stop
-			# method which can be overwritten to call a code sequence after reactor stop
-		end
-
-	end
-end
+module EventHub
+	class Processor
+		attr_reader :statistics, :name, :pidfile, :exception_writer
+
+		include Helper
+
+		def version
+			"1.0.0"
+		end
+
+		def initialize(name=nil)
+			@name = name || class_to_array(self.class)[1..-1].join(".")
+			@pidfile = EventHub::Components::Pidfile.new(File.join(Dir.pwd, 'pids', "#{name}.pid"))
+			@exception_writer = EventHub::Components::ExceptionWriter.new
+			@statistics = EventHub::Statistics.new
+			@heartbeat = EventHub::Heartbeat.new(self)
+			@message_processor = EventHub::MessageProcessor.new(self)
+
+			@channel_receiver = nil
+			@channel_sender		= nil
+			@restart = true
+		end
+
+		def configuration
+			EventHub::Configuration.instance.data
+		end
+
+		def server_host
+			configuration.get('server.host') || 'localhost'
+		end
+
+		def server_user
+			configuration.get('server.user') || 'admin'
+		end
+
+		def server_password
+			configuration.get('server.password') || 'admin'
+		end
+
+		def server_management_port
+			configuration.get('server.management_port') || 15672
+		end
+
+		def server_vhost
+			configuration.get('server.vhost') || 'event_hub'
+		end
+
+		def connection_settings
+			{ user: server_user, password: server_password, host: server_host, vhost: server_vhost }
+		end
+
+		def listener_queues
+			Array(
+				configuration.get('processor.listener_queue') ||
+				configuration.get('processor.listener_queues') ||
+				'undefined_listener_queues'
+			)
+		end
+
+		def watchdog_cycle_in_s
+			configuration.get('processor.watchdog_cycle_is_s') || 15
+		end
+
+		def restart_in_s
+			configuration.get('processor.restart_in_s') || 15
+		end
+
+		def heartbeat_cycle_in_s
+			configuration.get('processor.heartbeat_cycle_in_s') || 300
+		end
+
+		def start(detached = false)
+			daemonize if detached
+
+			EventHub.logger.info("Processor [#{@name}] base folder [#{Dir.pwd}]")
+
+			# use timer here to have last heartbeat message working
+			Signal.trap("TERM") { EventMachine.add_timer(0) { about_to_stop } }
+		  Signal.trap("INT")  { EventMachine.add_timer(0) { about_to_stop } }
+
+			while @restart
+				begin
+					handle_start_internal
+
+					# custom post start method to be overwritten
+					post_start
+
+				rescue => e
+					id = exception_writer.write(e)
+					EventHub.logger.error("Unexpected exception: #{e}, see => #{id}. Trying to restart in #{self.restart_in_s} seconds...")
+					sleep_break self.restart_in_s
+				end
+			end # while
+
+			# custon post stop method to be overwritten
+			post_stop
+
+			EventHub.logger.info("Processor [#{@name}] has been stopped")
+		ensure
+			pidfile.delete
+		end
+
+		def handle_message(metadata, payload)
+			raise "Please implement method in derived class"
+		end
+
+		def watchdog
+			self.listener_queues.each do |queue_name|
+				begin
+					response = RestClient.get "http://#{self.server_user}:#{self.server_password}@#{self.server_host}:#{self.server_management_port}/api/queues/#{self.server_vhost}/#{queue_name}/bindings", { :content_type => :json}
+	  			data = JSON.parse(response.body)
+
+	  			if response.code != 200
+	  				EventHub.logger.warn("Watchdog: Server did not answered properly. Trying to restart in #{self.restart_in_s} seconds...")
+	  				EventMachine.add_timer(self.restart_in_s) { stop_processor(true) }
+	  			elsif data.size == 0
+	  				EventHub.logger.warn("Watchdog: Something is wrong with the vhost, queue [#{queue_name}], and/or bindings. Trying to restart in #{self.restart_in_s} seconds...")
+	  				EventMachine.add_timer(self.restart_in_s) { stop_processor(true) }
+	  				# does it make sence ? Needs maybe more checks in future
+	  			else
+	  				# Watchdog is happy :-)
+						# add timer for next check
+						EventMachine.add_timer(self.watchdog_cycle_in_s) { watchdog }
+					end
+
+				rescue => e
+					EventHub.logger.error("Watchdog: Unexpected exception: #{e}. Trying to restart in #{self.restart_in_s} seconds...")
+					stop_processor
+				end
+			end
+		end
+
+		# send message
+		def send_message(message, exchange_name = EventHub::EH_X_INBOUND)
+
+			if @channel_sender.nil? || !@channel_sender.open?
+				@channel_sender = AMQP::Channel.new(@connection, prefetch: 1)
+
+				# use publisher confirm
+				@channel_sender.confirm_select
+
+				# @channel.on_error { |ch, channel_close| EventHub.logger.error "Oops! a channel-level exception: #{channel_close.reply_text}" }
+        # @channel.on_ack   { |basic_ack| EventHub.logger.info "Received basic_ack: multiple = #{basic_ack.multiple}, delivery_tag = #{basic_ack.delivery_tag}" }
+			end
+
+			exchange = @channel_sender.direct(exchange_name, :durable => true, :auto_delete => false)
+   		exchange.publish(message.to_json, :persistent => true)
+		end
+
+  	def sleep_break(seconds) # breaks after n seconds or after interrupt
+  		while (seconds > 0)
+    		sleep(1)
+    		seconds -= 1
+    		break unless @restart
+  		end
+		end
+
+		private
+
+		def handle_start_internal
+			AMQP.start(self.connection_settings) do |connection, open_ok|
+				@connection = connection
+
+				handle_connection_loss
+
+				# create channel
+				@channel_receiver = AMQP::Channel.new(@connection, prefetch: 1)
+
+				self.listener_queues.each do |queue_name|
+
+			  	# connect to queue
+			  	queue = @channel_receiver.queue(queue_name, durable: true, auto_delete: false)
+
+			  	# subscribe to queue
+				  queue.subscribe(:ack => true) do |metadata, payload|
+				  	begin
+				  		statistics.measure(payload.size) do
+					  		messages_to_send = @message_processor.process({ metadata: metadata, queue_name: queue_name}, payload)
+
+					  		# forward invalid or returned messages to dispatcher
+						    messages_to_send.each do |message|
+						      send_message(message)
+						    end if messages_to_send
+
+		    				@channel_receiver.acknowledge(metadata.delivery_tag)
+		    			end
+
+		    		rescue EventHub::NoDeadletterException => e
+				  		@channel_receiver.reject(metadata.delivery_tag, true)
+				  		EventHub.logger.error("Unexpected exception in handle_message method: #{e}. Message will be requeued.")
+							exception_writer.write(e)
+							sleep_break self.restart_in_s
+				  	rescue => e
+				  		@channel_receiver.reject(metadata.delivery_tag, false)
+				  		EventHub.logger.error("Unexpected exception in handle_message method: #{e}. Message dead lettered.")
+							exception_writer.write(e)
+				  	end
+				  end
+
+				end
+
+			  EventHub.logger.info("Processor [#{@name}] is listening to vhost [#{self.server_vhost}], queues [#{self.listener_queues.join(", ")}]")
+
+				register_timers
+
+				# send first heartbeat
+				heartbeat
+			end
+		end
+
+		def handle_connection_loss
+			@connection.on_tcp_connection_loss do |conn, settings|
+	  		EventHub.logger.warn("Processor lost tcp connection. Trying to restart in #{self.restart_in_s} seconds...")
+	  		stop_processor(true)
+	  	end
+		end
+
+		def register_timers
+		  EventMachine.add_timer(watchdog_cycle_in_s) { watchdog }
+		  EventMachine.add_periodic_timer(heartbeat_cycle_in_s) { heartbeat }
+		end
+
+		def heartbeat(action="running")
+			message = @heartbeat.build_message(action)
+			message.append_to_execution_history(@name)
+		  send_message(message)
+		end
+
+		def about_to_stop
+			heartbeat("stopped")
+			stop_processor
+		end
+
+		def stop_processor(restart=false)
+			@restart = restart
+
+			# close channels
+			[@channel_receiver,@channel_sender].each do |channel|
+				if channel
+					channel.close if channel.open?
+				end
+			end
+
+			# stop connection and event loop
+			if @connection
+				@connection.disconnect if @connection.connected?
+				EventMachine.stop if EventMachine.reactor_running?
+			end
+		end
+
+		def daemonize
+			EventHub.logger.info("Processor [#{@name}] is going to start as daemon")
+
+			# daemonize
+			Process.daemon
+
+			pidfile.write(Process.pid.to_s)
+		end
+
+		def post_start
+			# method which can be overwritten to call a code sequence after reactor start
+		end
+
+		def post_stop
+			# method which can be overwritten to call a code sequence after reactor stop
+		end
+
+	end
+end