indexing
	description: "Endpoint service message handler"
	license: "MIT license (see ../../license.txt)"
	author: "Beat Strasser <beat@stradax.net>"
	date: "$Date$"
	revision: "$Revision$"

class
	ENDPOINT_MESSAGE_HANDLER

inherit
	L4E_PRIORITY_CONSTANTS
	THREAD_CONTROL
	ARGUMENTS

create
	make

feature {NONE} -- Initialization

	make is
			-- Create endpoint service message handler
		local
			vampeer: P2P_PLATFORM
			failed: BOOLEAN
		do
			if not failed then
				-- Configuration directory path
				if argument_count = 1 then
					config_path := argument (1)
				else
					config_path := ".vampeer_handler"
				end

				-- Create stdout logger
				create_logger

				-- create vampeer platform
				vampeer := configure_platform
				if vampeer.module_status /= vampeer.init_failed then
					-- add reply listener
					npg.endpoint_service.extend_service ("reply", Void, agent reply_listener)
					-- add incoming message filter for catching all messages
					npg.endpoint_service.extend_incoming_message_filter (agent message_listener, Void, Void)

					-- now start platform
					vampeer.start
					if vampeer.module_status = vampeer.start_ok then
						-- stay idle
						idle_loop
					end
				end
			elseif argument_count > 1 then
				io.put_string ("Usage: endpoint_message_handler [ConfigDirectory]")
				io.new_line
			end

			-- stop platform
			if vampeer /= Void and vampeer.module_status = vampeer.start_ok then
				vampeer.stop
			end
		rescue
			failed := True
			retry
		end

feature -- Access

	config_path: STRING
	logger: L4E_LOGGER
	npg: P2P_PEERGROUP

feature {NONE} -- Implementation

	create_logger is
			-- Create log hierarchy and set `logger'
		local
			log_hierarchy: L4E_HIERARCHY
			log_appender: L4E_APPENDER
			log_layout: L4E_DATE_TIME_LAYOUT
		do
			create log_hierarchy.make (info_p)
			logger := log_hierarchy.root
			create {L4E_STDOUT_APPENDER} log_appender.make ("stdoutapp")
			create log_layout
			log_appender.set_layout (log_layout)
			logger.add_appender (log_appender)
		ensure
			Logger_set: logger /= Void
		end

	configure_platform: P2P_PLATFORM is
			-- Configure platform and initialize net peer group
		local
			conf: P2P_CONFIGURATION
			tcpconf: P2P_TCP_CONFIGURATION
			rdvconf: P2P_RENDEZVOUS_CONFIGURATION
		do
			create Result.make (config_path, logger)
			if not Result.is_configured then
				conf := Result.default_configuration
				conf.set_name ("endpoint_message_handler")
				conf.set_description ("Prints out incoming messages and replies to messages sent to service 'reply'")
				create tcpconf.make_auto
				tcpconf.set_port (9710)
				conf.replace_service_parameter (Result.transport_tcp_mcid, tcpconf)
				create rdvconf.make -- no rendezvous seeds
				conf.replace_service_parameter (Result.rendezvous_mcid, rdvconf)
				Result.configure (conf)
			end
			if Result.is_configured then
				npg := Result.standard_net_peergroup
			end
		end

	reply_listener (msg: P2P_MESSAGE; src, dest: P2P_ENDPOINT_ADDRESS) is
			-- Sends message back to source with additional message element
		local
			msgel: P2P_MESSAGE_ELEMENT
			return_addr: P2P_ENDPOINT_ADDRESS
		do
			if msg.element_by_namespace_and_name (msg.namespace_user, "EndpointMessageReplyHandler") = Void then
				create msgel.make_string (msg.namespace_user, "EndpointMessageReplyHandler", Void, "Reply")
				msg.extend (msgel)
				create return_addr.make_with_service (src.protocol_name, src.protocol_address, "SimpleSender", "WaitForReply")
				npg.endpoint_service.send_message (return_addr, msg)
				logger.info ("Replied to last message")
			end
		end

	message_listener (msg: P2P_MESSAGE; src, dest: P2P_ENDPOINT_ADDRESS): P2P_MESSAGE is
			-- Logs incoming message
		do
			Result := msg -- feed message back to other listeners
			logger.info ("Incoming message from: " + src.out + " to: " + dest.out + ", message:%N" + msg.out)
		end

	idle_loop is
			-- Stay idle until exception
		do
			from
			until False
			loop sleep (30000000000)
			end
		end

end