Started to implement server state engine.

src/net/common/clientthread.cpp

@@ -19,7 +19,7 @@
 
 #include <net/clientthread.h>
 #include <net/clientstate.h>
-#include <net/clientdata.h>
+#include <net/clientcontext.h>
 #include <net/senderthread.h>
 #include <net/receiverhelper.h>
 #include <net/clientcallback.h>
@@ -32,10 +32,30 @@
 using namespace std;
 
 
+class ClientSenderCallback : public SenderCallback
+{
+public:
+	ClientSenderCallback(ClientThread &client) : m_client(client) {}
+	virtual ~ClientSenderCallback() {}
+
+	virtual void SignalNetError(SOCKET sock, int errorID, int osErrorID)
+	{
+		// For now, we ignore the socket.
+		// Just signal the error.
+		// We assume that the client thread will be terminated.
+		m_client.GetCallback().SignalNetError(errorID, osErrorID);
+	}
+
+private:
+	ClientThread &m_client;
+};
+
+
 ClientThread::ClientThread(ClientCallback &cb)
 : m_curState(NULL), m_callback(cb)
 {
-	m_data.reset(new ClientData);
+	m_context.reset(new ClientContext);
+	m_senderCallback.reset(new ClientSenderCallback(*this));
 }
 
 ClientThread::~ClientThread()
@@ -48,47 +68,57 @@ ClientThread::Init(const string &serverAddress, unsigned serverPort, bool ipv6,
 	if (IsRunning())
 		return; // TODO: throw exception
 
-	ClientData &data = GetData();
+	ClientContext &context = GetContext();
 
-	data.addrFamily	= ipv6 ? AF_INET6 : AF_INET;
-	data.serverAddr	= serverAddress;
-	data.serverPort	= serverPort;
-	data.password	= pwd;
+	context.SetAddrFamily(ipv6 ? AF_INET6 : AF_INET);
+	context.SetServerAddr(serverAddress);
+	context.SetServerPort(serverPort);
+	context.SetPassword(pwd);
+}
+
+ClientCallback &
+ClientThread::GetCallback()
+{
+	return m_callback;
 }
 
 void
 ClientThread::Main()
 {
-	m_sender.reset(new SenderThread(m_callback));
-	m_receiver.reset(new ReceiverHelper);
 	SetState(CLIENT_INITIAL_STATE::Instance());
-	try {
+
+	m_sender.reset(new SenderThread(GetSenderCallback()));
+	m_receiver.reset(new ReceiverHelper);
+	GetSender().Run();
+
+	try
+	{
 		while (!ShouldTerminate())
 		{
 			int msg = GetState().Process(*this);
 			if (msg != MSG_SOCK_INTERNAL_PENDING)
-				m_callback.SignalNetSuccess(msg);
+				GetCallback().SignalNetSuccess(msg);
 		}
 	} catch (const NetException &e)
 	{
-		m_callback.SignalNetError(e.GetErrorId(), e.GetOsErrorCode());
+		GetCallback().SignalNetError(e.GetErrorId(), e.GetOsErrorCode());
 	}
 	GetSender().SignalTermination();
-	GetSender().Join(100);
+	GetSender().Join(SENDER_THREAD_TERMINATE_TIMEOUT);
 }
 
-const ClientData &
-ClientThread::GetData() const
+const ClientContext &
+ClientThread::GetContext() const
 {
-	assert(m_data.get());
-	return *m_data;
+	assert(m_context.get());
+	return *m_context;
 }
 
-ClientData &
-ClientThread::GetData()
+ClientContext &
+ClientThread::GetContext()
 {
-	assert(m_data.get());
-	return *m_data;
+	assert(m_context.get());
+	return *m_context;
 }
 
 ClientState &
@@ -118,3 +148,10 @@ ClientThread::GetReceiver()
 	return *m_receiver;
 }
 
+ClientSenderCallback &
+ClientThread::GetSenderCallback()
+{
+	assert(m_senderCallback.get());
+	return *m_senderCallback;
+}
+