tcpclient.cpp

C++ patterns设计模式

#include "stdafx.h"
#include "tcpclient.h"

namespace acl
{
	TcpClient::TcpClient()
	{
		m_alive = false;
		m_reconnectInterval = RECONNECT_INTERVAL;
	}

	TcpClient::TcpClient(u_short port, const char *addr)
		: m_comm(SocketAddress(addr, port))
	{		
		m_reconnectInterval = RECONNECT_INTERVAL;		
	}

	TcpClient::~TcpClient()
	{
		stop();
	}

	//start the service
	bool TcpClient::start()
	{	
		if(!m_alive)
		{
			trace(0, "tcp client service started\n");
			bool ret = this->connect();
			startThread();
			m_alive = true;
		}
		return connected();
	}

	bool TcpClient::start(u_short port, const char *addr)
	{	
		if(!m_alive)
		{
			m_comm.setServerAddress(SocketAddress(addr, port));
			return start();
		}
		return connected();
	}

	//stop the service
	void TcpClient::stop(int timeout)
	{
		if(m_alive)
		{
			m_exit_signaled = true;
			m_comm.close();
			waitFinish(timeout);
			stopThread();
			m_alive = false;
		}
	}

	bool TcpClient::connect()
	{
		if(!connected() && m_comm.connect())
		{
			onConnected();
		}
		return m_comm.isConnected();
	}

	bool TcpClient::connect(const SocketAddress &address)
	{
		if(!connected() && m_comm.connect(address))
		{
			onConnected();
		}
		return m_comm.isConnected();
	}
	//main interface for user call :
	int TcpClient::send(const char *buf, int buf_size)
	{
		if(m_comm.isValid() && m_comm.isConnected())
		{
			traceBinary(m_comm, "send buffer :\n", buf, buf_size);
			return m_comm.sendAll(buf, buf_size);
		}
		else
		{
			trace(m_comm, "ERR:socket not ready\n");
			return SOCKET_ERROR;
		}
	}

	// receive procecss
	void TcpClient::threadProcess()
	{
		m_exit_signaled = false;
		int ret;
		timeval tv;
		tv.tv_sec  = 0;
		tv.tv_usec = m_reconnectInterval;
		for(;;)
		{
#ifndef _DEBUG
			try
			{
#endif // _DEBUG
				while(!connected() && !m_exit_signaled)
				{
					Sleep(m_reconnectInterval);
					trace(m_comm, "reconnect...\n");
					connect();
				}
				if(m_exit_signaled)
					break;
				if(m_comm.recvReady(NULL))
				{
					if(m_exit_signaled)
						break;
					//RECV_OK             // recv ok
					//RECV_CLOSE          // connection closed
					//RECV_SOCKET_ERROR   // socket error
					//RECV_USER_ERROR     // user error < 0
					ret = onReceive();
					trace(m_comm, "onReceive return(%d)\n", ret);
					if(ret != RECV_OK)
					{
						handleBroken();
					}
				}
				else
				{
					handleBroken();
				}
#ifndef _DEBUG
			}
			catch(...)
			{
				trace(m_comm, "tcpclient thread catch exception\n");
			}
#endif // _DEBUG
		}
		m_exit_signaled = true;
	}
	void TcpClient::handleBroken()
	{
		m_comm.disconnect();
		onBroken();
	}
}