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;
 
  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, data.ToCharString().c_str());
 
  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 1971	Rev 1986
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 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_data_.connect(slot_on_new_data);	89	this->signal_on_new_data_.connect(slot_on_new_data);
89		90
90	LOG_DEBUG_EXIT;	91	LOG_DEBUG_EXIT;
91	}	92	}
92		93
93	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)
94	{	95	{
95	LOG_DEBUG_ENTER;	96	LOG_DEBUG_ENTER;
96		97
97	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);
98		99
99	if (client_state == CLIENT_STATE_DISCONNECTED)	100	if (client_state == CLIENT_STATE_DISCONNECTED)
100	{	101	{
101	this->clients_.erase(client_id);	102	this->clients_.erase(client_id);
102	}	103	}
103		104
104	this->signal_on_new_state_(client_id, ~~server_id,~~ client_state);	105	this->signal_on_new_state_(client_id, client_state);
105		106
106	LOG_DEBUG_EXIT;	107	LOG_DEBUG_EXIT;
107	}	108	}
108		109
109	void Manager::SlotOnNewClient(SocketId server_id, TcpSocketPointer socket)	110	void Manager::SlotOnNewClient(SocketId server_id, TcpSocketPointer socket)
110	{	111	{
111	LOG_DEBUG_ENTER;	112	LOG_DEBUG_ENTER;
112		113
113	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));
114		115
115	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_),
116	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_));
117		118
118	this->clients_[client->GetId()] = client;	119	this->clients_[client->GetId()] = client;
119		120
120	log::~~Debug~~(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());
121		122
-		123	this->signal_on_new_client_(client->GetId(), server_id);
-		124
122	this->signal_on_new_state_(client->GetId(), ~~server_id,~~ CLIENT_STATE_CONNECTED);	125	this->signal_on_new_state_(client->GetId(), CLIENT_STATE_CONNECTED);
123		126
124	LOG_DEBUG_EXIT;	127	LOG_DEBUG_EXIT;
125	}	128	}
126		129
127	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)
128	{	131	{
129	LOG_DEBUG_ENTER;	132	LOG_DEBUG_ENTER;
130		133
131	this->signal_on_new_data_(client_id, ~~server_id,~~ data);	134	this->signal_on_new_data_(client_id, data);
132		135
133	LOG_DEBUG_EXIT;	136	LOG_DEBUG_EXIT;
134	}	137	}
135		138
136	SocketId Manager::GetFreeSocketId()	139	SocketId Manager::GetFreeSocketId()
137	{	140	{
138	LOG_DEBUG_ENTER;	141	LOG_DEBUG_ENTER;
139		142
140	SocketId id = 1;	143	SocketId id = 1;
141		144
142	while (this->clients_.find(id) != this->clients_.end() \|\| this->servers_.find(id) != this->servers_.end())	145	while (this->clients_.find(id) != this->clients_.end() \|\| this->servers_.find(id) != this->servers_.end())
143	{	146	{
144	id++;	147	id++;
145	}	148	}
146		149
147	LOG_DEBUG_EXIT;	150	LOG_DEBUG_EXIT;
148		151
149	return id;	152	return id;
150	}	153	}
151		154
152	SocketId Manager::StartServer(Protocol protocol, unsigned int port)	155	SocketId Manager::StartServer(Protocol protocol, unsigned int port)
153	{	156	{
154	LOG_DEBUG_ENTER;	157	LOG_DEBUG_ENTER;
155		158
156	if (protocol != PROTOCOL_TCP)	159	if (protocol != PROTOCOL_TCP)
157	{	160	{
158	throw std::runtime_error("Can not start server for the Serial or UDP protocol!");	161	throw std::runtime_error("Can not start server for the Serial or UDP protocol!");
159	}	162	}
160		163
161	TcpServer::Pointer server = TcpServer::Pointer(new TcpServer(this->io_service_, port, this->GetFreeSocketId()));	164	TcpServer::Pointer server = TcpServer::Pointer(new TcpServer(this->io_service_, port, this->GetFreeSocketId()));
162		165
163	server->ConnectSlots(TcpServer::SignalOnNewClient::slot_type(&Manager::SlotOnNewClient, this, _1, _2).track(Manager::instance_));	166	server->ConnectSlots(TcpServer::SignalOnNewClient::slot_type(&Manager::SlotOnNewClient, this, _1, _2).track(Manager::instance_));
164		167
165	server->Accept();	168	server->Accept();
166		169
167	this->servers_[server->GetId()] = server;	170	this->servers_[server->GetId()] = server;
168		171
169	log::Debug(log_module_, "Started server with id %d!", server->GetId());	172	log::Debug(log_module_, "Started server with id %d!", server->GetId());
170		173
171	LOG_DEBUG_EXIT;	174	LOG_DEBUG_EXIT;
172		175
173	return server->GetId();	176	return server->GetId();
174	}	177	}
175		178
176	SocketId Manager::Connect(Protocol protocol, std::string address, unsigned int port_or_baud)	179	SocketId Manager::Connect(Protocol protocol, std::string address, unsigned int port_or_baud)
177	{	180	{
178	LOG_DEBUG_ENTER;	181	LOG_DEBUG_ENTER;
179		182
180	Client::Pointer client;	183	Client::Pointer client;
181		184
182	switch (protocol)	185	switch (protocol)
183	{	186	{
184	case PROTOCOL_TCP:	187	case PROTOCOL_TCP:
185	{	188	{
186	client = Client::Pointer(new TcpClient(this->io_service_, this->GetFreeSocketId(), 0));	189	client = Client::Pointer(new TcpClient(this->io_service_, this->GetFreeSocketId(), 0));
187	break;	190	break;
188	}	191	}
189	case PROTOCOL_UDP:	192	case PROTOCOL_UDP:
190	{	193	{
191	client = Client::Pointer(new UdpClient(this->io_service_, this->GetFreeSocketId(), 0));	194	client = Client::Pointer(new UdpClient(this->io_service_, this->GetFreeSocketId(), 0));
192	break;	195	break;
193	}	196	}
194	case PROTOCOL_SERIAL:	197	case PROTOCOL_SERIAL:
195	{	198	{
196	client = Client::Pointer(new SerialClient(this->io_service_, this->GetFreeSocketId(), 0));	199	client = Client::Pointer(new SerialClient(this->io_service_, this->GetFreeSocketId(), 0));
197	break;	200	break;
198	}	201	}
199	default:	202	default:
200	{	203	{
201	throw std::runtime_error("Invalid protocol specified!");	204	throw std::runtime_error("Invalid protocol specified!");
202	}	205	}
203	}	206	}
204		207
205	client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),	208	client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),
206	Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));	209	Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));
207		210
208	client->Connect(address, port_or_baud);	211	client->Connect(address, port_or_baud);
209		212
210	this->clients_[client->GetId()] = client;	213	this->clients_[client->GetId()] = client;
211		214
212	LOG_DEBUG_EXIT;	215	LOG_DEBUG_EXIT;
213		216
214	return client->GetId();	217	return client->GetId();
215	}	218	}
216		219
217	void Manager::SendToAll(SocketId server_id, common::Byteset data)	220	void Manager::SendToAll(SocketId server_id, common::Byteset data)
218	{	221	{
219	LOG_DEBUG_ENTER;	222	LOG_DEBUG_ENTER;
220		223
221	this->io_service_.post(boost::bind(&Manager::SendToAllHandler, this, server_id, data));	224	this->io_service_.post(boost::bind(&Manager::SendToAllHandler, this, server_id, data));
222		225
223	LOG_DEBUG_EXIT;	226	LOG_DEBUG_EXIT;
224	}	227	}
225		228
226	void Manager::SendTo(SocketId client_id, common::Byteset data)	229	void Manager::SendTo(SocketId client_id, common::Byteset data)
227	{	230	{
228	LOG_DEBUG_ENTER;	231	LOG_DEBUG_ENTER;
229		232
230	log::Debug(log_module_, "SendTo, client_id %d", client_id);	233	log::Debug(log_module_, "SendTo, client_id %d", client_id);
231		234
232	this->io_service_.post(boost::bind(&Manager::SendToHandler, this, client_id, data));	235	this->io_service_.post(boost::bind(&Manager::SendToHandler, this, client_id, data));
233		236
234	LOG_DEBUG_EXIT;	237	LOG_DEBUG_EXIT;
235	}	238	}
236		239
237	void Manager::StopServer(SocketId server_id)	240	void Manager::StopServer(SocketId server_id)
238	{	241	{
239	LOG_DEBUG_ENTER;	242	LOG_DEBUG_ENTER;
240		243
241	this->io_service_.post(boost::bind(&Manager::StopServerHandler, this, server_id));	244	this->io_service_.post(boost::bind(&Manager::StopServerHandler, this, server_id));
242		245
243	LOG_DEBUG_EXIT;	246	LOG_DEBUG_EXIT;
244	}	247	}
245		248
246	void Manager::Disconnect(SocketId client_id)	249	void Manager::Disconnect(SocketId client_id)
247	{	250	{
248	LOG_DEBUG_ENTER;	251	LOG_DEBUG_ENTER;
249		252
250	log::Debug(log_module_, "Disconnect, client_id %d", client_id);	253	log::Debug(log_module_, "Disconnect, client_id %d", client_id);
251		254
252	this->io_service_.post(boost::bind(&Manager::DisconnectHandler, this, client_id));	255	this->io_service_.post(boost::bind(&Manager::DisconnectHandler, this, client_id));
253		256
254	LOG_DEBUG_EXIT;	257	LOG_DEBUG_EXIT;
255	}	258	}
256		259
257	void Manager::SendToAllHandler(SocketId server_id, common::Byteset data)	260	void Manager::SendToAllHandler(SocketId server_id, common::Byteset data)
258	{	261	{
259	LOG_DEBUG_ENTER;	262	LOG_DEBUG_ENTER;
260		263
261	for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)	264	for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)
262	{	265	{
263	if (it->second->GetServerId() == server_id)	266	if (it->second->GetServerId() == server_id)
264	{	267	{
265	it->second->Send(data);	268	it->second->Send(data);
266	}	269	}
267	}	270	}
268		271
269	LOG_DEBUG_EXIT;	272	LOG_DEBUG_EXIT;
270	}	273	}
271		274
272	void Manager::SendToHandler(SocketId client_id, common::Byteset data)	275	void Manager::SendToHandler(SocketId client_id, common::Byteset data)
273	{	276	{
274	LOG_DEBUG_ENTER;	277	LOG_DEBUG_ENTER;
275		278
276	log::Debug(log_module_, "SendToHandler, client_id %d, data %s", client_id, data.ToCharString().c_str());	279	log::Debug(log_module_, "SendToHandler, client_id %d, data %s", client_id, data.ToCharString().c_str());
277		280
278	ClientList::iterator it = this->clients_.find(client_id);	281	ClientList::iterator it = this->clients_.find(client_id);
279		282
280	if (it != this->clients_.end())	283	if (it != this->clients_.end())
281	{	284	{
282	it->second->Send(data);	285	it->second->Send(data);
-		286	}
-		287	else
-		288	{
-		289	log::Error(log_module_, "Failed to find client %d to send data to!", client_id);
283	}	290	}
284		291
285	LOG_DEBUG_EXIT;	292	LOG_DEBUG_EXIT;
286	}	293	}
287		294
288	void Manager::StopServerHandler(SocketId server_id)	295	void Manager::StopServerHandler(SocketId server_id)
289	{	296	{
290	LOG_DEBUG_ENTER;	297	LOG_DEBUG_ENTER;
291		298
292	this->clients_.erase(server_id);	299	this->clients_.erase(server_id);
293		300
294	LOG_DEBUG_EXIT;	301	LOG_DEBUG_EXIT;
295	}	302	}
296		303
297	void Manager::DisconnectHandler(SocketId client_id)	304	void Manager::DisconnectHandler(SocketId client_id)
298	{	305	{
299	LOG_DEBUG_ENTER;	306	LOG_DEBUG_ENTER;
300		307
301	log::Debug(log_module_, "DisconnectHandler, client_id %d", client_id);	308	log::Debug(log_module_, "DisconnectHandler, client_id %d", client_id);
302		309
303	ClientList::iterator it = this->clients_.find(client_id);	310	ClientList::iterator it = this->clients_.find(client_id);
304		311
305	if (it != this->clients_.end())	312	if (it != this->clients_.end())
306	{	313	{
307	it->second->Disconnect();	314	it->second->Disconnect();
308	}	315	}
309		316
310	LOG_DEBUG_EXIT;	317	LOG_DEBUG_EXIT;
311	}	318	}
312		319
313		320
314	}; // namespace net	321	}; // namespace net
315	}; // namespace atom	322	}; // namespace atom
316		323

Subversion Repositories HomeAutomation

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