WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/net/Manager.cpp


/*
 *
 *  Copyright (C) 2010  Mattias Runge
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */
 
#include "Manager.h"
 
#include <iostream>
 
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
#include <boost/cast.hpp>
 
#include "common/log.h"
 
static const std::string log_module_ = "net::manager";
 
namespace atom {
namespace net {
 
Manager::Pointer Manager::instance_;
 
 
Manager::Manager()
{
  LOG_DEBUG_ENTER;
  LOG_DEBUG_EXIT;
}
 
Manager::~Manager()
{
  LOG_DEBUG_ENTER;
 
  this->Stop();
 
  this->clients_.clear();
 
  LOG_DEBUG_EXIT;
}
 
Manager::Pointer Manager::Instance()
{
  LOG_DEBUG_ENTER;
 
  return Manager::instance_;
 
  LOG_DEBUG_EXIT;
}
 
void Manager::Create()
{
  LOG_DEBUG_ENTER;
 
  Manager::instance_ = Manager::Pointer(new Manager());
 
  LOG_DEBUG_EXIT;
}
 
void Manager::Delete()
{
  LOG_DEBUG_ENTER;
 
  Manager::instance_.reset();
 
  LOG_DEBUG_EXIT;
}
 
void Manager::ConnectSlots(const SignalOnNewState::slot_type& slot_on_new_state, const SignalOnNewClient::slot_type& slot_on_new_client, const SignalOnNewData::slot_type& slot_on_new_data)
{
  LOG_DEBUG_ENTER;
 
  this->signal_on_new_state_.connect(slot_on_new_state);
  this->signal_on_new_client_.connect(slot_on_new_client);
  this->signal_on_new_data_.connect(slot_on_new_data);
 
  LOG_DEBUG_EXIT;
}
 
void Manager::SlotOnNewState(SocketId client_id, SocketId server_id, ClientState client_state)
{
  LOG_DEBUG_ENTER;
 
  log::Debug(log_module_, "SlotOnNewState, client_id %d, server_id %d, client_state %d", client_id, server_id, client_state);
 
  if (client_state == CLIENT_STATE_DISCONNECTED)
  {
    this->clients_.erase(client_id);
  }
 
  this->signal_on_new_state_(client_id, client_state);
 
  LOG_DEBUG_EXIT;
}
 
void Manager::SlotOnNewClient(SocketId server_id, TcpSocketPointer socket)
{
  LOG_DEBUG_ENTER;
 
  TcpClient::Pointer client = TcpClient::Pointer(new TcpClient(this->io_service_, socket, this->GetFreeSocketId(), server_id));
 
  client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),
                       Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));
 
  this->clients_[client->GetId()] = client;
 
  log::Info(log_module_, "Client connected on server id %d with client id %d!", server_id, client->GetId());
 
  this->signal_on_new_client_(client->GetId(), server_id);
 
  this->signal_on_new_state_(client->GetId(), CLIENT_STATE_CONNECTED);
 
  LOG_DEBUG_EXIT;
}
 
void Manager::SlotOnNewData(SocketId client_id, SocketId server_id, common::Byteset data)
{
  LOG_DEBUG_ENTER;
 
  log::Debug(log_module_, "data=\"%s\"", std::string(data.begin(), data.end()).data());
 
  this->signal_on_new_data_(client_id, data);
 
  LOG_DEBUG_EXIT;
}
 
SocketId Manager::GetFreeSocketId()
{
  LOG_DEBUG_ENTER;
 
  SocketId id = 1;
 
  while (this->clients_.find(id) != this->clients_.end() || this->servers_.find(id) != this->servers_.end())
  {
    id++;
  }
 
  LOG_DEBUG_EXIT;
 
  return id;
}
 
SocketId Manager::StartServer(Protocol protocol, unsigned int port)
{
  LOG_DEBUG_ENTER;
 
  if (protocol != PROTOCOL_TCP)
  {
    throw std::runtime_error("Can not start server for the Serial or UDP protocol!");
  }
 
  TcpServer::Pointer server = TcpServer::Pointer(new TcpServer(this->io_service_, port, this->GetFreeSocketId()));
 
  server->ConnectSlots(TcpServer::SignalOnNewClient::slot_type(&Manager::SlotOnNewClient, this, _1, _2).track(Manager::instance_));
 
  server->Accept();
 
  this->servers_[server->GetId()] = server;
 
  log::Debug(log_module_, "Started server with id %d!", server->GetId());
 
  LOG_DEBUG_EXIT;
 
  return server->GetId();
}
 
SocketId Manager::Connect(Protocol protocol, std::string address, unsigned int port_or_baud)
{
  LOG_DEBUG_ENTER;
 
  Client::Pointer client;
 
  switch (protocol)
  {
    case PROTOCOL_TCP:
    {
      client = Client::Pointer(new TcpClient(this->io_service_, this->GetFreeSocketId(), 0));
      break;
    }
    case PROTOCOL_UDP:
    {
      client = Client::Pointer(new UdpClient(this->io_service_, this->GetFreeSocketId(), 0));
      break;
    }
    case PROTOCOL_SERIAL:
    {
      client = Client::Pointer(new SerialClient(this->io_service_, this->GetFreeSocketId(), 0));
      break;
    }
    default:
    {
      throw std::runtime_error("Invalid protocol specified!");
    }
  }
 
  client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),
                       Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));
 
  client->Connect(address, port_or_baud);
 
  this->clients_[client->GetId()] = client;
 
  LOG_DEBUG_EXIT;
 
  return client->GetId();
}
 
void Manager::SendToAll(SocketId server_id, common::Byteset data)
{
  LOG_DEBUG_ENTER;
 
  this->io_service_.post(boost::bind(&Manager::SendToAllHandler, this, server_id, data));
 
  LOG_DEBUG_EXIT;
}
 
void Manager::SendTo(SocketId client_id, common::Byteset data)
{
  LOG_DEBUG_ENTER;
 
  log::Debug(log_module_, "SendTo, client_id %d", client_id);
 
  this->io_service_.post(boost::bind(&Manager::SendToHandler, this, client_id, data));
 
  LOG_DEBUG_EXIT;
}
 
void Manager::StopServer(SocketId server_id)
{
  LOG_DEBUG_ENTER;
 
  this->io_service_.post(boost::bind(&Manager::StopServerHandler, this, server_id));
 
  LOG_DEBUG_EXIT;
}
 
void Manager::Disconnect(SocketId client_id)
{
  LOG_DEBUG_ENTER;
 
  log::Debug(log_module_, "Disconnect, client_id %d", client_id);
 
  this->io_service_.post(boost::bind(&Manager::DisconnectHandler, this, client_id));
 
  LOG_DEBUG_EXIT;
}
 
void Manager::SendToAllHandler(SocketId server_id, common::Byteset data)
{
  LOG_DEBUG_ENTER;
 
  for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)
  {
    if (it->second->GetServerId() == server_id)
    {
      it->second->Send(data);
    }
  }
 
  LOG_DEBUG_EXIT;
}
 
void Manager::SendToHandler(SocketId client_id, common::Byteset data)
{
  LOG_DEBUG_ENTER;
 
  log::Debug(log_module_, "SendToHandler, client_id %d, data %s", client_id, std::string(data.begin(), data.end()).data());
 
  ClientList::iterator it = this->clients_.find(client_id);
 
  if (it != this->clients_.end())
  {
    it->second->Send(data);
  }
  else
  {
    log::Error(log_module_, "Failed to find client %d to send data to!", client_id);
  }
 
  LOG_DEBUG_EXIT;
}
 
void Manager::StopServerHandler(SocketId server_id)
{
  LOG_DEBUG_ENTER;
 
  this->clients_.erase(server_id);
 
  LOG_DEBUG_EXIT;
}
 
void Manager::DisconnectHandler(SocketId client_id)
{
  LOG_DEBUG_ENTER;
 
  log::Debug(log_module_, "DisconnectHandler, client_id %d", client_id);
 
  ClientList::iterator it = this->clients_.find(client_id);
 
  if (it != this->clients_.end())
  {
    it->second->Disconnect();
  }
 
  LOG_DEBUG_EXIT;
}
 
 
}; // namespace net
}; // namespace atom
 

Rev 1986	Rev 1987
1	/*	1	/*
2	*	2	*
3	* Copyright (C) 2010 Mattias Runge	3	* Copyright (C) 2010 Mattias Runge
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or	7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.	8	* (at your option) any later version.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License along	15	* You should have received a copy of the GNU General Public License along
16	* with this program; if not, write to the Free Software Foundation, Inc.,	16	* with this program; if not, write to the Free Software Foundation, Inc.,
17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18	*	18	*
19	*/	19	*/
20		20
21	#include "Manager.h"	21	#include "Manager.h"
22		22
23	#include <iostream>	23	#include <iostream>
24		24
25	#include <boost/lexical_cast.hpp>	25	#include <boost/lexical_cast.hpp>
26	#include <boost/bind.hpp>	26	#include <boost/bind.hpp>
27	#include <boost/cast.hpp>	27	#include <boost/cast.hpp>
28		28
29	#include "common/log.h"	29	#include "common/log.h"
30		30
31	static const std::string log_module_ = "net::manager";	31	static const std::string log_module_ = "net::manager";
32		32
33	namespace atom {	33	namespace atom {
34	namespace net {	34	namespace net {
35		35
36	Manager::Pointer Manager::instance_;	36	Manager::Pointer Manager::instance_;
37		37
38		38
39	Manager::Manager()	39	Manager::Manager()
40	{	40	{
41	LOG_DEBUG_ENTER;	41	LOG_DEBUG_ENTER;
42	LOG_DEBUG_EXIT;	42	LOG_DEBUG_EXIT;
43	}	43	}
44		44
45	Manager::~Manager()	45	Manager::~Manager()
46	{	46	{
47	LOG_DEBUG_ENTER;	47	LOG_DEBUG_ENTER;
48		48
49	this->Stop();	49	this->Stop();
50		50
51	this->clients_.clear();	51	this->clients_.clear();
52		52
53	LOG_DEBUG_EXIT;	53	LOG_DEBUG_EXIT;
54	}	54	}
55		55
56	Manager::Pointer Manager::Instance()	56	Manager::Pointer Manager::Instance()
57	{	57	{
58	LOG_DEBUG_ENTER;	58	LOG_DEBUG_ENTER;
59		59
60	return Manager::instance_;	60	return Manager::instance_;
61		61
62	LOG_DEBUG_EXIT;	62	LOG_DEBUG_EXIT;
63	}	63	}
64		64
65	void Manager::Create()	65	void Manager::Create()
66	{	66	{
67	LOG_DEBUG_ENTER;	67	LOG_DEBUG_ENTER;
68		68
69	Manager::instance_ = Manager::Pointer(new Manager());	69	Manager::instance_ = Manager::Pointer(new Manager());
70		70
71	LOG_DEBUG_EXIT;	71	LOG_DEBUG_EXIT;
72	}	72	}
73		73
74	void Manager::Delete()	74	void Manager::Delete()
75	{	75	{
76	LOG_DEBUG_ENTER;	76	LOG_DEBUG_ENTER;
77		77
78	Manager::instance_.reset();	78	Manager::instance_.reset();
79		79
80	LOG_DEBUG_EXIT;	80	LOG_DEBUG_EXIT;
81	}	81	}
82		82
83	void Manager::ConnectSlots(const SignalOnNewState::slot_type& slot_on_new_state, const SignalOnNewClient::slot_type& slot_on_new_client, const SignalOnNewData::slot_type& slot_on_new_data)	83	void Manager::ConnectSlots(const SignalOnNewState::slot_type& slot_on_new_state, const SignalOnNewClient::slot_type& slot_on_new_client, const SignalOnNewData::slot_type& slot_on_new_data)
84	{	84	{
85	LOG_DEBUG_ENTER;	85	LOG_DEBUG_ENTER;
86		86
87	this->signal_on_new_state_.connect(slot_on_new_state);	87	this->signal_on_new_state_.connect(slot_on_new_state);
88	this->signal_on_new_client_.connect(slot_on_new_client);	88	this->signal_on_new_client_.connect(slot_on_new_client);
89	this->signal_on_new_data_.connect(slot_on_new_data);	89	this->signal_on_new_data_.connect(slot_on_new_data);
90		90
91	LOG_DEBUG_EXIT;	91	LOG_DEBUG_EXIT;
92	}	92	}
93		93
94	void Manager::SlotOnNewState(SocketId client_id, SocketId server_id, ClientState client_state)	94	void Manager::SlotOnNewState(SocketId client_id, SocketId server_id, ClientState client_state)
95	{	95	{
96	LOG_DEBUG_ENTER;	96	LOG_DEBUG_ENTER;
97		97
98	log::Debug(log_module_, "SlotOnNewState, client_id %d, server_id %d, client_state %d", client_id, server_id, client_state);	98	log::Debug(log_module_, "SlotOnNewState, client_id %d, server_id %d, client_state %d", client_id, server_id, client_state);
99		99
100	if (client_state == CLIENT_STATE_DISCONNECTED)	100	if (client_state == CLIENT_STATE_DISCONNECTED)
101	{	101	{
102	this->clients_.erase(client_id);	102	this->clients_.erase(client_id);
103	}	103	}
104		104
105	this->signal_on_new_state_(client_id, client_state);	105	this->signal_on_new_state_(client_id, client_state);
106		106
107	LOG_DEBUG_EXIT;	107	LOG_DEBUG_EXIT;
108	}	108	}
109		109
110	void Manager::SlotOnNewClient(SocketId server_id, TcpSocketPointer socket)	110	void Manager::SlotOnNewClient(SocketId server_id, TcpSocketPointer socket)
111	{	111	{
112	LOG_DEBUG_ENTER;	112	LOG_DEBUG_ENTER;
113		113
114	TcpClient::Pointer client = TcpClient::Pointer(new TcpClient(this->io_service_, socket, this->GetFreeSocketId(), server_id));	114	TcpClient::Pointer client = TcpClient::Pointer(new TcpClient(this->io_service_, socket, this->GetFreeSocketId(), server_id));
115		115
116	client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),	116	client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),
117	Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));	117	Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));
118		118
119	this->clients_[client->GetId()] = client;	119	this->clients_[client->GetId()] = client;
120		120
121	log::Info(log_module_, "Client connected on server id %d with client id %d!", server_id, client->GetId());	121	log::Info(log_module_, "Client connected on server id %d with client id %d!", server_id, client->GetId());
122		122
123	this->signal_on_new_client_(client->GetId(), server_id);	123	this->signal_on_new_client_(client->GetId(), server_id);
124		124
125	this->signal_on_new_state_(client->GetId(), CLIENT_STATE_CONNECTED);	125	this->signal_on_new_state_(client->GetId(), CLIENT_STATE_CONNECTED);
126		126
127	LOG_DEBUG_EXIT;	127	LOG_DEBUG_EXIT;
128	}	128	}
129		129
130	void Manager::SlotOnNewData(SocketId client_id, SocketId server_id, common::Byteset data)	130	void Manager::SlotOnNewData(SocketId client_id, SocketId server_id, common::Byteset data)
131	{	131	{
132	LOG_DEBUG_ENTER;	132	LOG_DEBUG_ENTER;
-		133
-		134	log::Debug(log_module_, "data=\"%s\"", std::string(data.begin(), data.end()).data());
133		135
134	this->signal_on_new_data_(client_id, data);	136	this->signal_on_new_data_(client_id, data);
135		137
136	LOG_DEBUG_EXIT;	138	LOG_DEBUG_EXIT;
137	}	139	}
138		140
139	SocketId Manager::GetFreeSocketId()	141	SocketId Manager::GetFreeSocketId()
140	{	142	{
141	LOG_DEBUG_ENTER;	143	LOG_DEBUG_ENTER;
142		144
143	SocketId id = 1;	145	SocketId id = 1;
144		146
145	while (this->clients_.find(id) != this->clients_.end() \|\| this->servers_.find(id) != this->servers_.end())	147	while (this->clients_.find(id) != this->clients_.end() \|\| this->servers_.find(id) != this->servers_.end())
146	{	148	{
147	id++;	149	id++;
148	}	150	}
149		151
150	LOG_DEBUG_EXIT;	152	LOG_DEBUG_EXIT;
151		153
152	return id;	154	return id;
153	}	155	}
154		156
155	SocketId Manager::StartServer(Protocol protocol, unsigned int port)	157	SocketId Manager::StartServer(Protocol protocol, unsigned int port)
156	{	158	{
157	LOG_DEBUG_ENTER;	159	LOG_DEBUG_ENTER;
158		160
159	if (protocol != PROTOCOL_TCP)	161	if (protocol != PROTOCOL_TCP)
160	{	162	{
161	throw std::runtime_error("Can not start server for the Serial or UDP protocol!");	163	throw std::runtime_error("Can not start server for the Serial or UDP protocol!");
162	}	164	}
163		165
164	TcpServer::Pointer server = TcpServer::Pointer(new TcpServer(this->io_service_, port, this->GetFreeSocketId()));	166	TcpServer::Pointer server = TcpServer::Pointer(new TcpServer(this->io_service_, port, this->GetFreeSocketId()));
165		167
166	server->ConnectSlots(TcpServer::SignalOnNewClient::slot_type(&Manager::SlotOnNewClient, this, _1, _2).track(Manager::instance_));	168	server->ConnectSlots(TcpServer::SignalOnNewClient::slot_type(&Manager::SlotOnNewClient, this, _1, _2).track(Manager::instance_));
167		169
168	server->Accept();	170	server->Accept();
169		171
170	this->servers_[server->GetId()] = server;	172	this->servers_[server->GetId()] = server;
171		173
172	log::Debug(log_module_, "Started server with id %d!", server->GetId());	174	log::Debug(log_module_, "Started server with id %d!", server->GetId());
173		175
174	LOG_DEBUG_EXIT;	176	LOG_DEBUG_EXIT;
175		177
176	return server->GetId();	178	return server->GetId();
177	}	179	}
178		180
179	SocketId Manager::Connect(Protocol protocol, std::string address, unsigned int port_or_baud)	181	SocketId Manager::Connect(Protocol protocol, std::string address, unsigned int port_or_baud)
180	{	182	{
181	LOG_DEBUG_ENTER;	183	LOG_DEBUG_ENTER;
182		184
183	Client::Pointer client;	185	Client::Pointer client;
184		186
185	switch (protocol)	187	switch (protocol)
186	{	188	{
187	case PROTOCOL_TCP:	189	case PROTOCOL_TCP:
188	{	190	{
189	client = Client::Pointer(new TcpClient(this->io_service_, this->GetFreeSocketId(), 0));	191	client = Client::Pointer(new TcpClient(this->io_service_, this->GetFreeSocketId(), 0));
190	break;	192	break;
191	}	193	}
192	case PROTOCOL_UDP:	194	case PROTOCOL_UDP:
193	{	195	{
194	client = Client::Pointer(new UdpClient(this->io_service_, this->GetFreeSocketId(), 0));	196	client = Client::Pointer(new UdpClient(this->io_service_, this->GetFreeSocketId(), 0));
195	break;	197	break;
196	}	198	}
197	case PROTOCOL_SERIAL:	199	case PROTOCOL_SERIAL:
198	{	200	{
199	client = Client::Pointer(new SerialClient(this->io_service_, this->GetFreeSocketId(), 0));	201	client = Client::Pointer(new SerialClient(this->io_service_, this->GetFreeSocketId(), 0));
200	break;	202	break;
201	}	203	}
202	default:	204	default:
203	{	205	{
204	throw std::runtime_error("Invalid protocol specified!");	206	throw std::runtime_error("Invalid protocol specified!");
205	}	207	}
206	}	208	}
207		209
208	client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),	210	client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),
209	Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));	211	Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));
210		212
211	client->Connect(address, port_or_baud);	213	client->Connect(address, port_or_baud);
212		214
213	this->clients_[client->GetId()] = client;	215	this->clients_[client->GetId()] = client;
214		216
215	LOG_DEBUG_EXIT;	217	LOG_DEBUG_EXIT;
216		218
217	return client->GetId();	219	return client->GetId();
218	}	220	}
219		221
220	void Manager::SendToAll(SocketId server_id, common::Byteset data)	222	void Manager::SendToAll(SocketId server_id, common::Byteset data)
221	{	223	{
222	LOG_DEBUG_ENTER;	224	LOG_DEBUG_ENTER;
223		225
224	this->io_service_.post(boost::bind(&Manager::SendToAllHandler, this, server_id, data));	226	this->io_service_.post(boost::bind(&Manager::SendToAllHandler, this, server_id, data));
225		227
226	LOG_DEBUG_EXIT;	228	LOG_DEBUG_EXIT;
227	}	229	}
228		230
229	void Manager::SendTo(SocketId client_id, common::Byteset data)	231	void Manager::SendTo(SocketId client_id, common::Byteset data)
230	{	232	{
231	LOG_DEBUG_ENTER;	233	LOG_DEBUG_ENTER;
232		234
233	log::Debug(log_module_, "SendTo, client_id %d", client_id);	235	log::Debug(log_module_, "SendTo, client_id %d", client_id);
234		236
235	this->io_service_.post(boost::bind(&Manager::SendToHandler, this, client_id, data));	237	this->io_service_.post(boost::bind(&Manager::SendToHandler, this, client_id, data));
236		238
237	LOG_DEBUG_EXIT;	239	LOG_DEBUG_EXIT;
238	}	240	}
239		241
240	void Manager::StopServer(SocketId server_id)	242	void Manager::StopServer(SocketId server_id)
241	{	243	{
242	LOG_DEBUG_ENTER;	244	LOG_DEBUG_ENTER;
243		245
244	this->io_service_.post(boost::bind(&Manager::StopServerHandler, this, server_id));	246	this->io_service_.post(boost::bind(&Manager::StopServerHandler, this, server_id));
245		247
246	LOG_DEBUG_EXIT;	248	LOG_DEBUG_EXIT;
247	}	249	}
248		250
249	void Manager::Disconnect(SocketId client_id)	251	void Manager::Disconnect(SocketId client_id)
250	{	252	{
251	LOG_DEBUG_ENTER;	253	LOG_DEBUG_ENTER;
252		254
253	log::Debug(log_module_, "Disconnect, client_id %d", client_id);	255	log::Debug(log_module_, "Disconnect, client_id %d", client_id);
254		256
255	this->io_service_.post(boost::bind(&Manager::DisconnectHandler, this, client_id));	257	this->io_service_.post(boost::bind(&Manager::DisconnectHandler, this, client_id));
256		258
257	LOG_DEBUG_EXIT;	259	LOG_DEBUG_EXIT;
258	}	260	}
259		261
260	void Manager::SendToAllHandler(SocketId server_id, common::Byteset data)	262	void Manager::SendToAllHandler(SocketId server_id, common::Byteset data)
261	{	263	{
262	LOG_DEBUG_ENTER;	264	LOG_DEBUG_ENTER;
263		265
264	for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)	266	for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)
265	{	267	{
266	if (it->second->GetServerId() == server_id)	268	if (it->second->GetServerId() == server_id)
267	{	269	{
268	it->second->Send(data);	270	it->second->Send(data);
269	}	271	}
270	}	272	}
271		273
272	LOG_DEBUG_EXIT;	274	LOG_DEBUG_EXIT;
273	}	275	}
274		276
275	void Manager::SendToHandler(SocketId client_id, common::Byteset data)	277	void Manager::SendToHandler(SocketId client_id, common::Byteset data)
276	{	278	{
277	LOG_DEBUG_ENTER;	279	LOG_DEBUG_ENTER;
278		280
279	log::Debug(log_module_, "SendToHandler, client_id %d, data %s", client_id, ~~data.ToCharString~~().~~c_str~~());	281	log::Debug(log_module_, "SendToHandler, client_id %d, data %s", client_id, std::string(data.begin(), data.end()).data());
280		282
281	ClientList::iterator it = this->clients_.find(client_id);	283	ClientList::iterator it = this->clients_.find(client_id);
282		284
283	if (it != this->clients_.end())	285	if (it != this->clients_.end())
284	{	286	{
285	it->second->Send(data);	287	it->second->Send(data);
286	}	288	}
287	else	289	else
288	{	290	{
289	log::Error(log_module_, "Failed to find client %d to send data to!", client_id);	291	log::Error(log_module_, "Failed to find client %d to send data to!", client_id);
290	}	292	}
291		293
292	LOG_DEBUG_EXIT;	294	LOG_DEBUG_EXIT;
293	}	295	}
294		296
295	void Manager::StopServerHandler(SocketId server_id)	297	void Manager::StopServerHandler(SocketId server_id)
296	{	298	{
297	LOG_DEBUG_ENTER;	299	LOG_DEBUG_ENTER;
298		300
299	this->clients_.erase(server_id);	301	this->clients_.erase(server_id);
300		302
301	LOG_DEBUG_EXIT;	303	LOG_DEBUG_EXIT;
302	}	304	}
303		305
304	void Manager::DisconnectHandler(SocketId client_id)	306	void Manager::DisconnectHandler(SocketId client_id)
305	{	307	{
306	LOG_DEBUG_ENTER;	308	LOG_DEBUG_ENTER;
307		309
308	log::Debug(log_module_, "DisconnectHandler, client_id %d", client_id);	310	log::Debug(log_module_, "DisconnectHandler, client_id %d", client_id);
309		311
310	ClientList::iterator it = this->clients_.find(client_id);	312	ClientList::iterator it = this->clients_.find(client_id);
311		313
312	if (it != this->clients_.end())	314	if (it != this->clients_.end())
313	{	315	{
314	it->second->Disconnect();	316	it->second->Disconnect();
315	}	317	}
316		318
317	LOG_DEBUG_EXIT;	319	LOG_DEBUG_EXIT;
318	}	320	}
319		321
320		322
321	}; // namespace net	323	}; // namespace net
322	}; // namespace atom	324	}; // namespace atom
323		325

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/net/Manager.cpp – Rev 1986 → 1987