WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/can/CanDaemon.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 "CanDaemon.h"
 
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string/trim.hpp>
 
#include "net/Manager.h"
#include "broker/Manager.h"
 
#include "Message.h"
 
namespace atom {
namespace can {
   
CanDaemon::CanDaemon(unsigned int port): broker::Subscriber(port), LOG("can::CanDaemon")
{
    try
    {
        this->server_id_ = net::Manager::Instance()->StartServer(net::PROTOCOL_TCP, port);
        LOG.Info("Started TCP server on port " + boost::lexical_cast<std::string>(port) + ".");
        LOG.Debug("Server id is " + boost::lexical_cast<std::string>(this->server_id_) + ".");
    }
    catch (std::runtime_error& e)
    {
        LOG.Error(e.what());
    }
}
 
CanDaemon::~CanDaemon()
{
    net::Manager::Instance()->StopServer(this->server_id_);
    this->server_id_ = 0;
}
 
 
void CanDaemon::SlotOnMessageHandler(broker::Message::Pointer message)
{
    if (message->GetType() == broker::Message::CAN_RAW_MESSAGE)
    {
    std::string* payload_str;
     
    payload_str = static_cast<std::string*>(message->GetPayload().get());
    std::string line = *payload_str;
   
        net::Manager::Instance()->SendToAll(this->server_id_, common::Byteset(line, true));
    }
}
 
void CanDaemon::SlotOnNewDataHandler(net::SocketId id, common::Byteset data)
{
    if (std::find(this->clients_.begin(), this->clients_.end(), id) == this->clients_.end())
    {
      return;
    }
   
    std::string str = data.ToCharString();
   
    boost::algorithm::trim_right_if(str, boost::is_any_of("\r\n"));
   
    LOG.Info("Received: \"" + str + "\" from client " + boost::lexical_cast<std::string>(id) + " on server " + boost::lexical_cast<std::string>(this->server_id_));
   
    std::string* payload_str = new std::string(str);
    broker::Manager::Instance()->Post(broker::Message::Pointer(new broker::Message(broker::Message::CAN_RAW_MESSAGE, broker::Message::PayloadPointer(payload_str), this)));
   
    //LOG.Info("Sent...");
   
    if (str == "q" || str == "quit")
    {
        LOG.Info("Client " + boost::lexical_cast<std::string>(id) + " has requested to be disconnected.");
        net::Manager::Instance()->Disconnect(id);
    }
}
 
void CanDaemon::SlotOnNewClientHandler(net::SocketId id, net::SocketId server_id)
{
  if (server_id == this->server_id_)
  {
    this->clients_.insert(id);
  }
}
 
void CanDaemon::SlotOnNewStateHandler(net::SocketId id, net::ClientState client_state)
{
    if (std::find(this->clients_.begin(), this->clients_.end(), id) == this->clients_.end())
    {
      return;
    }
 
    if (client_state == net::CLIENT_STATE_DISCONNECTED)
    {
        LOG.Info("Client " + boost::lexical_cast<std::string>(id) + " has disconnected.");
        this->clients_.erase(id);
    }
    else if (client_state == net::CLIENT_STATE_CONNECTED)
    {
        LOG.Info("Client " + boost::lexical_cast<std::string>(id) + " has connected.");
    }
    else
    {
        LOG.Debug("Got state: " + boost::lexical_cast<std::string>((int)client_state));
    }
}
   
}; // namespace can
}; // namespace atom
 

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/can/CanDaemon.cpp – Rev 1959 → 1986

Rev 1959		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 "CanDaemon.h"	21	#include "CanDaemon.h"
22		22
23	#include <boost/lexical_cast.hpp>	23	#include <boost/lexical_cast.hpp>
24	#include <boost/algorithm/string/trim.hpp>	24	#include <boost/algorithm/string/trim.hpp>
25		25
26	#include "net/Manager.h"	26	#include "net/Manager.h"
27	#include "broker/Manager.h"	27	#include "broker/Manager.h"
28		28
29	#include "Message.h"	29	#include "Message.h"
30		30
31	namespace atom {	31	namespace atom {
32	namespace can {	32	namespace can {
33		33
34	CanDaemon::CanDaemon(unsigned int port): broker::Subscriber(port), LOG("can::CanDaemon")	34	CanDaemon::CanDaemon(unsigned int port): broker::Subscriber(port), LOG("can::CanDaemon")
35	{	35	{
36	try	36	try
37	{	37	{
38	this->server_id_ = net::Manager::Instance()->StartServer(net::PROTOCOL_TCP, port);	38	this->server_id_ = net::Manager::Instance()->StartServer(net::PROTOCOL_TCP, port);
39	LOG.Info("Started TCP server on port " + boost::lexical_cast<std::string>(port) + ".");	39	LOG.Info("Started TCP server on port " + boost::lexical_cast<std::string>(port) + ".");
40	LOG.Debug("Server id is " + boost::lexical_cast<std::string>(this->server_id_) + ".");	40	LOG.Debug("Server id is " + boost::lexical_cast<std::string>(this->server_id_) + ".");
41	}	41	}
42	catch (std::runtime_error& e)	42	catch (std::runtime_error& e)
43	{	43	{
44	LOG.Error(e.what());	44	LOG.Error(e.what());
45	}	45	}
46	}	46	}
47		47
48	CanDaemon::~CanDaemon()	48	CanDaemon::~CanDaemon()
49	{	49	{
50	net::Manager::Instance()->StopServer(this->server_id_);	50	net::Manager::Instance()->StopServer(this->server_id_);
51	this->server_id_ = 0;	51	this->server_id_ = 0;
52	}	52	}
53		53
54		54
55	void CanDaemon::SlotOnMessageHandler(broker::Message::Pointer message)	55	void CanDaemon::SlotOnMessageHandler(broker::Message::Pointer message)
56	{	56	{
57	if (message->GetType() == broker::Message::CAN_RAW_MESSAGE)	57	if (message->GetType() == broker::Message::CAN_RAW_MESSAGE)
58	{	58	{
59	std::string* payload_str;	59	std::string* payload_str;
60		60
61	payload_str = static_cast<std::string*>(message->GetPayload().get());	61	payload_str = static_cast<std::string*>(message->GetPayload().get());
62	std::string line = *payload_str;	62	std::string line = *payload_str;
63		63
64	net::Manager::Instance()->SendToAll(this->server_id_, common::Byteset(line, true));	64	net::Manager::Instance()->SendToAll(this->server_id_, common::Byteset(line, true));
65	}	65	}
66	}	66	}
67		67
68	void CanDaemon::SlotOnNewDataHandler(net::SocketId ~~client_id, net::SocketId server_id,~~ common::Byteset data)	68	void CanDaemon::SlotOnNewDataHandler(net::SocketId id, common::Byteset data)
69	{	69	{
70	if (~~server_id !=~~ this->~~server_id_~~)	70	if (std::find(this->clients_.begin(), this->clients_.end(), id) == this->clients_.end())
71	{	71	{
72	return;	72	return;
73	}	73	}
74		74
75	std::string str = data.ToCharString();	75	std::string str = data.ToCharString();
76		76
77	boost::algorithm::trim_right_if(str, boost::is_any_of("\r\n"));	77	boost::algorithm::trim_right_if(str, boost::is_any_of("\r\n"));
78		78
79	//LOG.Info("Received: \"" + str + "\" from ~~client " + boost::lexical_cast<std::~~string>~~(client_id) +~~ " on server " + boost::lexical_cast<std::string>~~(server_id))~~;	79	LOG.Info("Received: \"" + str + "\" from client " + boost::lexical_cast<std::string>(id) + " on server " + boost::lexical_cast<std::string>(this->server_id_));
80		80
81	std::string* payload_str = new std::string(str);	81	std::string* payload_str = new std::string(str);
82	broker::Manager::Instance()->Post(broker::Message::Pointer(new broker::Message(broker::Message::CAN_RAW_MESSAGE, broker::Message::PayloadPointer(payload_str), this)));	82	broker::Manager::Instance()->Post(broker::Message::Pointer(new broker::Message(broker::Message::CAN_RAW_MESSAGE, broker::Message::PayloadPointer(payload_str), this)));
83		83
84	//LOG.Info("Sent...");	84	//LOG.Info("Sent...");
85		85
86	if (str == "q" \|\| str == "quit")	86	if (str == "q" \|\| str == "quit")
87	{	87	{
88	LOG.Info("Client " + boost::lexical_cast<std::string>(~~client_id~~) + " has requested to be disconnected.");	88	LOG.Info("Client " + boost::lexical_cast<std::string>(id) + " has requested to be disconnected.");
89	net::Manager::Instance()->Disconnect(~~client_id~~);	89	net::Manager::Instance()->Disconnect(id);
90	}	90	}
91	}	91	}
92		92
93	void CanDaemon::~~SlotOnNewStateHandler~~(net::SocketId ~~client_id,~~ net::SocketId ~~server_id, net::ClientState client_state~~)	93	void CanDaemon::SlotOnNewClientHandler(net::SocketId id, net::SocketId server_id)
94	{	94	{
95	if (server_id != this->server_id_)	95	if (server_id == this->server_id_)
-		96	{
-		97	this->clients_.insert(id);
-		98	}
-		99	}
-		100
-		101	void CanDaemon::SlotOnNewStateHandler(net::SocketId id, net::ClientState client_state)
-		102	{
-		103	if (std::find(this->clients_.begin(), this->clients_.end(), id) == this->clients_.end())
96	{	104	{
97	return;	105	return;
98	}	106	}
99		107
100	if (client_state == net::CLIENT_STATE_DISCONNECTED)	108	if (client_state == net::CLIENT_STATE_DISCONNECTED)
101	{	109	{
102	LOG.Info("Client " + boost::lexical_cast<std::string>(~~client_id~~) + " has disconnected.");	110	LOG.Info("Client " + boost::lexical_cast<std::string>(id) + " has disconnected.");
-		111	this->clients_.erase(id);
103	}	112	}
104	else if (client_state == net::CLIENT_STATE_CONNECTED)	113	else if (client_state == net::CLIENT_STATE_CONNECTED)
105	{	114	{
106	LOG.Info("Client " + boost::lexical_cast<std::string>(~~client_id~~) + " has connected.");	115	LOG.Info("Client " + boost::lexical_cast<std::string>(id) + " has connected.");
107	}	116	}
108	else	117	else
109	{	118	{
110	LOG.Debug("Got state: " + boost::lexical_cast<std::string>((int)client_state));	119	LOG.Debug("Got state: " + boost::lexical_cast<std::string>((int)client_state));
111	}	120	}
112	}	121	}
113		122
114	}; // namespace can	123	}; // namespace can
115	}; // namespace atom	124	}; // namespace atom
116		125