-.-
Connecting with several cells on a remote system using the same port number.

In this example we use the same message exchange as in the previous example, 
but now we let many cells communicate with each other over the same port number.	
-.-------------------------------------------------------------------------------------------------
use Windows, Math, Strings, Editor, System

-- The connection test creates a Talker and a Listener and have them exchange some messages
design ConxTest is

	cell Caller, Callee
	cell Creator
	cell stdout

	constructor is 
		-- Create a window for output
		stdout = create MenuWindow("Connecting to a remote CellSpeak system over Tcp/Ip")
		
		-- send a message to the system to set stdout		
		system <- stdout.Set(stdout)
			
		-- Create the Talker that will connect to a port on a remote system..
		create TalkerDesign("Apollo","27524")
		
		-- There is one listener on port 27524 ..
		create ListenerDesign("27524")
	end
end

--	The Talker connects several times to the remote system using the same address
design TalkerDesign( ansi Remote, ansi Port) is 

	cell ConxMgr			-- The reference to the connection manager
	keep Remote, Port		-- we keep the parameters

	constructor is 	
		-- Ask the system for the Connection Manager
		system <- Service.Get("ConxMgr")
	end
	
	on Service.Provider(ansi Service, cell Provider) do	
		-- check the service
		Service is "ConxMgr" ? ConxMgr = Provider : yield

		-- Let's set up a number of connections using the same port number
(1)		for i=1 to 5 => ConxMgr <- TCPIP.Connect(Remote, Port)			
	end
	
	-- The connection mgr sends this message if the connection was successfuly established
	var Count = 0	-- a variable to tally the nr of connections
(2)	on TCPIP.Connected( ConxClass Conx ) do	
		-- create a new humanoid - this cell will handle the connection
		cell Humanoid = create HumanoidDesign("Humanoid[Count+=1]")
	
		-- set the protocol to be used over the connection.
(3)		ConxMgr <- Set.Protocol( Conx, "CLSPK", Humanoid )
	
		-- print a message on the display
		system <- println("\tconnection to [Remote] port [Port] established.")		
	end
	
end

--	The Humanoid handles the communications on the connection
design HumanoidDesign(ansi Name) is
	keep Name
	cell Avatar, ConxMgr
	
	-- The response of the connnection mgr to the Set.Protocol message
(4)	on CLSPK.Ready( cell Avatar ) do	
		keep Avatar				-- The avatar is the local representative of the remote system
		ConxMgr = sender		-- We received the message from the connection manager
		
		-- inform
		system <- println("[Name]: contacting other system")
		
		-- send a welcome messageto the remote system
(5)		Avatar <- HelloThere(Name)
	end
	
	-- The connection manager sends this message when the connection is disconnected
	on TCPIP.RemoteDisconnected( ConxClass Conx) do
		system <- println("[Name] Remote Disconnected")
	end
	
	-- The response from the callee on the remote system
	on MyNameIs(ansi NameCallee) do
		system <- println("[Name]: my counterpart's name is [NameCallee]")
		
		-- send a nr of messages to my counterpart
		for i=1 to 5000 => sender <- TestMessage("Message [i]:0123456789 abcdefghijklmnopqrstuvwxyz")
		
		-- and ask how many received
		sender <- HowManyReceived
	end
	
	-- The Callee reports the nr of messages received
	on Received(int count, ansi CalleeName) do
		system <- println("[Name]: [CalleeName] received a total of [count] messages")
		
		-- Tell our counterpart we're finished
		sender <- DemoIsOver	

		-- and we autodestroy
		destroy self
	end
	
	-- The destructor for the cell
	destructor is 
		system <- println("[Name] going down")
	
		-- We close the connection (the avatar is destroyed automatically)
		ConxMgr <- TCPIP.Close( Avatar )
	end 
end

--	The listener listens to incoming calls on a port and launches a handler for each incoming connection request
design ListenerDesign(ansi Port) is 
	cell ConxMgr			-- The reference to the connection manager
	keep Port				-- We keep the port number
	
	constructor is 
		-- The callee also needs the connection manager
		system <- Service.Get("ConxMgr")	
	end

	destructor is 
		-- stop listening
		ConxMgr <- TCPIP.Stop.Listening(Port)				
	end

	-- The reply from the system on our request for a service
	on Service.Provider(ansi Service, cell Provider) do
		-- check that we have received the right service - otherwise yield
		Service is "ConxMgr" ? ConxMgr = Provider : yield
		
		-- We tell the connection manager that we want to listen for incoming connections on a port
		ConxMgr <- TCPIP.Listen( Port )
	end
	
	int Count = 0			-- we keep track of the nr of connections
	
	-- The message we get from the connection manager when a remote system wants to connect
	on TCPIP.Accept( ConxClass Conx ) do		
		system <- println("\taccepting connection [Conx].")
		
		-- For each accepted connection we create a new handler
		var NewRobot = create RobotDesign("Robot[Count+=1]")
				
		-- Set the protocol and the handler
		ConxMgr <- Set.Protocol( Conx, "CLSPK", NewRobot)
	end 	
end

--	The robot handles messages on an accepted connection
design RobotDesign(ansi Name) is 

	keep Name
	cell Avatar, ConxMgr
		
	-- The conx mgr informs us about success (or failure) of the Set.Protocol message
	on CLSPK.Ready(cell Avatar) do	
		keep Avatar				-- keep a reference to the avatar..
		ConxMgr = sender		-- ..and the connection manager
		
		system <- println("\tReceived avatar")
	end
	
	-- The connection manager sends this when the remote system disconnects
	on TCPIP.RemoteDisconnected( ConxClass Conx) do	
		system <- println("[Name] Remote has closed the connection")	
	end
	
	-- The connection manager sends this when a protocol is not supported (CLSPK is supported of course !)
	on CLSPK.NotSupported  do
		system <- println("CLSPK is not supported")		
	end
	
	-- The message from our counterpart on the other system
	on HelloThere(ansi RemoteName) do
		system <- println("[Name]: [RemoteName] says hello to me")
		
		-- our reply
		sender <- MyNameIs(Name)
	end
		
	-- The caller will send a series of test messages ..
	int ReceiveCount = 0	
	
	on TestMessage(byte[] Content) do
		-- just count the nr of messages
		ReceiveCount += 1
	end
	
	-- ..and ask how many were received
	on HowManyReceived do 
		-- return the message count
		sender <- Received(ReceiveCount, Name)
	end
	
	on DemoIsOver do
		-- when the demo is over we autodestruct
		destroy self
	end
	
	-- The destructor of the robot
	destructor is 
		system <- println("\t[Name] going down")

		-- ..and we close the connection
		ConxMgr <- TCPIP.Close( Avatar )
	end
end