indexing
	description: "General Origo node starter"
	license: "MIT license (see ../../license.txt)"
	author: "Beat Strasser <beat@stradax.net>"
	date: "$Date$"
	revision: "$Revision$"

deferred class
	O_NODE

inherit
	L4E_PRIORITY_CONSTANTS
		export
			{NONE} all
		end
	THREAD_CONTROL
		export
			{NONE} all
		end
	ARGUMENTS
		export
			{NONE} all
		end
	P2P_CONSTANTS
		export
			{NONE} all
		end
	O_CONSTANTS

feature {NONE} -- Initialization

	make is
			-- Start node
		do
			if argument_count = expected_argument_count then
				create_loggers
				logger.info ("Starting Origo node")
				make_node
			else
				io.put_string ("Usage: " + argument (0) + " ConfigDirectory Port")
				io.new_line
			end
		end

	make_node is
			-- Create specific node
		do
			load_services
			peer_start
		end

	load_services is
			-- Load Origo services components
		do
		end

	peer_start is
			-- Start vamPeer platform
		local
			failed: BOOLEAN
		do
			if not failed then
				-- create vampeer platform
				logger.info ("Loading/configuring peer platform")
				configure_platform
				if vampeer.module_status = vampeer.initializing then
					logger.info ("Peer platform successfully initialized")
					-- additional configuration to loaded vampeer modules
					configure_loaded_peer_platform
					-- now start platform
					logger.info ("Starting peer network now")
					vampeer.start
					if vampeer.module_status = vampeer.start_ok then
						-- peer platform is started
						logger.info ("Origo network successfully started")
						main

						-- stop node and peer platform
						logger.debugging ("Stopping Origo node")
						stop
					else
						logger.error ("Error starting peer platform")
					end
				else
					logger.error ("Error configuring peer platform")
				end
			end
		rescue
			failed := True
			retry
		end

	configure_loaded_peer_platform is
			-- Additional configuration steps after platform has been loaded
		require
			Vampeer_loaded: vampeer /= Void and vampeer.module_status = vampeer.initializing
		do
		ensure
			Vampeer_not_started: vampeer.module_status = vampeer.initializing
		end

	main is
			-- Main routine after peer platform is successfully started (main event loop)
		require
			Vampeer_started: vampeer /= Void and vampeer.module_status = vampeer.start_ok
		local
			failed: BOOLEAN
		do
			from
			until failed
			loop
				sleep (main_loop_sleep_interval)
			end
		rescue
			failed := True
			retry
		end

	stop is
			-- Stop node
		local
			failed: BOOLEAN
		do
			if not failed then
				-- shutdown peer platform, if started
				if vampeer /= Void and vampeer.module_status = vampeer.start_ok or vampeer.module_status = vampeer.suspended then
					vampeer.stop
				end
				-- Unreference it
				vampeer := Void
				opg := Void
			end
		rescue
			failed := True
			retry
		end

feature -- Access

	log_hierarchy: L4E_HIERARCHY
	vampeer_logger, logger: L4E_LOGGER

	vampeer: P2P_PLATFORM
	opg: P2P_PEERGROUP

	is_core: BOOLEAN is
			-- Is current node a Origo core?
		deferred
		end

	Peer_name: STRING is
			-- Node's peer name
		deferred
		ensure
			Result_set: Result /= Void and not Result.is_empty
		end

	Peer_description: STRING is
			-- Node's peer description
		deferred
		end

	expected_argument_count: INTEGER is
			-- Number of expected arguments
		deferred
		end

	configuration_directory: STRING is
			-- Vampeers configuration directory
		do
			Result := argument (1)
		ensure
			Result_set: Result /= Void
		end

feature {NONE} -- Implementation

	Main_loop_sleep_interval: INTEGER_64 is 60000000000 -- 60s

	create_loggers is
			-- Create log hierarchy and set `logger'
		local
			main_appender, vampeer_appender: L4E_FILE_APPENDER
			log_layout: L4E_DATE_TIME_LAYOUT
		do
			-- create log hierarchy
			create log_hierarchy.make (info_p)
			create log_layout
			-- create node logger
			logger := log_hierarchy.logger ("node")
			create main_appender.make ("node.log", true)
			main_appender.set_layout (log_layout)
			logger.add_appender (main_appender)
			-- create vampeer logger
			vampeer_logger := log_hierarchy.logger ("vampeer")
			vampeer_logger.set_priority (debug_p)
			create vampeer_appender.make ("vampeer.log", false)
			vampeer_appender.set_layout (log_layout)
			vampeer_logger.add_appender (vampeer_appender)
		end

	configure_platform is
			-- Configure platform and initialize net peer group
		require
			Configuration_directory_valid: configuration_directory /= Void
		local
			opg_mia: P2P_MODULE_IMPLEMENTATION_ADVERTISEMENT
		do
			create vampeer.make (configuration_directory, vampeer_logger)
			if not vampeer.is_configured or not vampeer.peer_name.is_equal (peer_name) then
				-- configure vampeer platform
				vampeer.configure (platform_configuration)
			end
			-- now create our private net peer group, the Origo Peer Group (OPG)
			if not vampeer.cache_manager.has_module_implementation_advertisement (origo_peergroup_msid) then
				vampeer_logger.info ("vampeer_platform: Creating new Origo peer group module implementation advertisement")
				opg_mia := peergroup_implementation_advertisement
				vampeer.cache_manager.store_module_implementation_advertisement (opg_mia)
			end
			opg ?= vampeer.load_net_peergroup (origo_peergroup_id, origo_peergroup_msid, agent peergroup_loader)
			if opg /= Void and opg.module_status /= opg.init_failed then
				opg.group_advertisement.set_name (group_name)
				opg.group_advertisement.set_description (group_description)
				vampeer.cache_manager.store_peergroup_advertisement (opg.group_advertisement)
				vampeer_logger.info ("vampeer_platform: Origo peer group initialized")
			end
		end

	peergroup_loader (a_pg: P2P_PEERGROUP; an_id: P2P_ID; a_mia: P2P_MODULE_IMPLEMENTATION_ADVERTISEMENT): P2P_MODULE is
			-- Load OPG
		require
			Peergroup_valid: a_pg /= Void
			Id_valid: an_id /= Void and an_id.is_valid
			Mia_valid: a_mia /= Void and a_mia.is_valid
		do
			if a_pg = vampeer and an_id.is_equal (origo_peergroup_id) and origo_peergroup_msid.is_equal (a_mia.specification_id) then
				create {O_PEERGROUP} Result.init (a_pg, an_id, a_mia)
			end
		end

	platform_configuration: P2P_CONFIGURATION is
			-- Create platform configuration
		local
			opg_id: P2P_PEERGROUP_UUID
			pid: P2P_PEER_ID
			tcp_conf: P2P_TCP_CONFIGURATION
			rdv_conf: P2P_RENDEZVOUS_CONFIGURATION
			seed_ea: P2P_ENDPOINT_ADDRESS
		do
			-- create peer id
			opg_id ?= origo_peergroup_id
			create pid.make_new_with_group (opg_id.uuid)
			-- create configuration with peer id
			create Result.make_with_id (pid)
			Result.set_name (peer_name)
			if peer_description /= Void then
				Result.set_description (peer_description)
			end
			-- add tcp configuration
			create tcp_conf.make_auto
			tcp_conf.set_multicast_enabled (False)
			Result.add_service_parameter (transport_tcp_mcid, tcp_conf)
			-- add rendezvous configuration
			create rdv_conf.make
			create seed_ea.make_from_uri (rdv_seed_address)
			rdv_conf.add_seed_address (seed_ea)
			Result.add_service_parameter (rendezvous_mcid, rdv_conf)
		ensure
			Result_set: Result /= Void and Result.is_valid
		end

	peergroup_implementation_advertisement: P2P_MODULE_IMPLEMENTATION_ADVERTISEMENT is
			-- The Origo peer group impl adv
		require
			Vampeer_valid: vampeer /= Void
		local
			params_doc: P2P_XML_DOCUMENT
			mia: P2P_MODULE_IMPLEMENTATION_ADVERTISEMENT
		do
			Result := vampeer.peergroup_implementation_advertisement (origo_peergroup_msid, group_code_name, group_description)
			params_doc := Result.parameter.document

			-- Add origo core service
			mia := vampeer.default_implementation_advertisement (origo_core_msid, p2p_module_code_name, p2p_module_description)
			params_doc.create_root_child_element ("Svc", namespace_empty)
			params_doc.add_child_element (params_doc.last_element, mia.document.document.root_element)
		end

invariant
	Loggers_set: log_hierarchy /= Void and logger /= Void and vampeer_logger /= Void

end