WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/atomic.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 <string>
#include <vector>
#include <iostream>
 
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <pwd.h>
 
#include <boost/lexical_cast.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/locks.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/program_options.hpp>
 
#include "config.h"
 
#include "net/Manager.h"
#include "net/Subscriber.h"
#include "net/types.h"
 
#include "common/common.h"
 
#include <readline/readline.h>
#include <readline/history.h>
 
using namespace atom;
 
bool finish = false;
common::StringList autocomplete_list;
char* buffer = NULL;
boost::condition on_message_condition;
struct termios original_flags;
std::string history_filename;
 
void Handler(int status);
void CleanUp();
 
char* AutoCompleteGet(const char* text, int state);
static char** AutoComplete(const char* text, int start, int end);
 
std::string GetUserHomeDirectory()
{
    return std::string(getpwuid(getuid())->pw_dir);
}
 
class ConsoleClient : public net::Subscriber
{
public:
    typedef boost::shared_ptr<ConsoleClient> Pointer;
   
    ConsoleClient(std::string address, unsigned int port)
    {
        this->client_id_ = net::Manager::Instance()->Connect(net::PROTOCOL_TCP, address, port);
    }
   
    virtual ~ConsoleClient()
    {
        net::Manager::Instance()->Disconnect(this->client_id_);
 
        this->io_service_.stop();
    }
   
    std::string GetPrompt()
    {
        return this->prompt_;
    }
   
    void SendResponse(std::string payload)
    {
        std::string packet = "RESP";
        packet += common::PadNumber(payload.length() + 1, 4);
        packet += payload;
       
        net::Manager::Instance()->SendTo(this->client_id_, packet);
    }
   
    void AutoCompleteRequest(unsigned int arg_index, std::string commandline)
    {
        std::string payload = common::PadNumber(arg_index, 4);
        payload += commandline;
       
        std::string packet = "COMP";
        packet += common::PadNumber(payload.length() + 1, 4);
        packet += payload;
       
        net::Manager::Instance()->SendTo(this->client_id_, packet);
    }
   
private:
    net::ClientId client_id_;
    std::string prompt_;
    std::vector<unsigned char> buffer_;
   
    void SlotOnNewStateHandler(net::ClientId client_id, net::ServerId server_id, net::ClientState client_state)
    {
        if (client_state != net::CLIENT_STATE_CONNECTED)
        {
            std::cout << "Disconnected from server." << std::endl;
           
            this->client_id_ = 0;
            finish = true;
            on_message_condition.notify_all();
        }
    }
   
    void SlotOnNewDataHandler(net::ClientId client_id, net::ServerId server_id, common::Byteset data)
    {
        for (unsigned int n = 0; n < data.GetSize(); n++)
        {
            this->buffer_.push_back(data[n]);
        }
 
        while (this->buffer_.size() >= 8)
        {
            std::string command = "";
            command += (char)this->buffer_[0];
            command += (char)this->buffer_[1];
            command += (char)this->buffer_[2];
            command += (char)this->buffer_[3];
 
            std::string payload_length_str = "";
            payload_length_str += (char)this->buffer_[4];
            payload_length_str += (char)this->buffer_[5];
            payload_length_str += (char)this->buffer_[6];
            payload_length_str += (char)this->buffer_[7];
           
            unsigned int payload_length = boost::lexical_cast<unsigned int>(payload_length_str);
           
            if (this->buffer_.size() - 8 < payload_length)
            {
                return;
            }
         
            std::string payload = "";
            for (unsigned int n = 8; n < payload_length + 8; n++)
            {
                payload += (char)this->buffer_[n];
            }
           
            this->buffer_.erase(this->buffer_.begin(), this->buffer_.begin() + payload_length + 8);
           
            if (command == "TEXT")
            {
                std::cout << payload << std::flush;
            }
            else if (command == "PROM")
            {
                this->prompt_ = payload;
                on_message_condition.notify_all();
            }
            else if (command == "COMP")
            {
                autocomplete_list.clear();
               
                if (payload.length() > 0)
                {
                    boost::algorithm::split(autocomplete_list, payload, boost::is_any_of("\n"), boost::algorithm::token_compress_on);
                }
               
                on_message_condition.notify_all();
            }
            else
            {
                std::cerr << "Could not parse package." << std::endl;
                finish = true;
                on_message_condition.notify_all();
                break;
            }
        }
    }
};
 
ConsoleClient::Pointer cc;
 
 
int main(int argc, char **argv)
{
    // Signal handlers
    signal(SIGTERM, Handler);
    signal(SIGINT, Handler);
    signal(SIGQUIT, Handler);
    signal(SIGABRT, Handler);
    signal(SIGPIPE, Handler);
   
    boost::mutex guard_mutex;
   
    // Setup readline
    history_filename = GetUserHomeDirectory() + "/.atomic_history";
    read_history(history_filename.data());
   
    rl_attempted_completion_function = AutoComplete;
   
    // Save command line state
    tcgetattr(fileno(stdin), &original_flags);
   
    // Parse commandline
    boost::program_options::options_description command_line;
    boost::program_options::variables_map variable_map;
   
    command_line.add_options()
    ("help,h",    "produce help message")
    ("command,c", boost::program_options::value<std::string>()->default_value(""), "command")
    ("server,s",  boost::program_options::value<std::string>()->default_value("localhost"), "server address")
    ("port,p",    boost::program_options::value<unsigned int>()->default_value(1202), "server port");
   
    try
    {
        boost::program_options::store(boost::program_options::command_line_parser(argc, argv).options(command_line).run(), variable_map);
    }
    catch (boost::program_options::unknown_option e)
    {
        std::cerr << e.what() << std::endl;
        std::cout << command_line << std::endl;
        CleanUp();
        return EXIT_FAILURE;
    }
    catch (boost::program_options::invalid_syntax e)
    {
        std::cerr << e.what() << std::endl;
        std::cout << command_line << std::endl;
        CleanUp();
        return EXIT_FAILURE;
    }
   
    if (variable_map.count("help") != 0)
    {
        std::cout << command_line << std::endl;
        CleanUp();
        return EXIT_SUCCESS;
    }
   
    net::Manager::Create();
 
    if (variable_map["command"].as<std::string>() == "")
    {
        std::cout << "\033[29;1mAtom Interactive Console, version " + std::string(VERSION) + " starting...\033[0m" << std::endl;
        std::cout << "\033[29;1mReleased under GPL version 2.\033[0m" << std::endl;
        std::cout << "Written by Mattias Runge 2010." << std::endl;
       
        std::cout << "Connecting to " << variable_map["server"].as<std::string>().data() << ":" << variable_map["port"].as<unsigned int>() << "..." << std::endl;
    }
   
    try
    {
        cc = ConsoleClient::Pointer(new ConsoleClient(variable_map["server"].as<std::string>(), variable_map["port"].as<unsigned int>()));
    }
    catch (std::runtime_error& e)
    {
        std::cerr << "Connection error: " << e.what() << std::endl;
        CleanUp();
        return EXIT_FAILURE;
    }
   
    if (variable_map["command"].as<std::string>() != "")
    {
        boost::mutex::scoped_lock guard(guard_mutex);
        on_message_condition.wait(guard);
       
        if (!finish)
        {
            cc->SendResponse(variable_map["command"].as<std::string>());
           
            if (!finish)
            {
                on_message_condition.wait(guard);
            }
        }
    }
    else
    {
        while (true)
        {
            boost::mutex::scoped_lock guard(guard_mutex);
            on_message_condition.wait(guard);
           
            if (finish)
            {
                break;
            }
           
            while ((buffer = readline(cc->GetPrompt().data())) != NULL)
            {
                if (finish)
                {
                    break;
                }
               
                if (strlen(buffer) == 0)
                {
                    continue;
                }
               
                break;
            }
           
            if (finish)
            {
                break;
            }
           
            cc->SendResponse(buffer);
            add_history(buffer);
        }
    }
   
    CleanUp();
   
    return EXIT_SUCCESS;
}
 
static char** AutoComplete(const char* text, int start, int end)
{
    unsigned int count = 0;
    boost::mutex guard_mutex;
 
    for (unsigned int n = 0; n < start; n++)
    {
        if (rl_line_buffer[n] == ' ')
        {
            count++;
        }
    }
   
    cc->AutoCompleteRequest(count, rl_line_buffer);
   
    boost::mutex::scoped_lock guard(guard_mutex);
    on_message_condition.wait(guard);
   
    /*if (autocomplete_list.size() == 0)
    {
        return NULL;
    }*/
   
    return rl_completion_matches(text, &AutoCompleteGet);
}
 
char* AutoCompleteGet(const char* text, int state)
{
    static int index = 0;
    int length = strlen(text);
    std::string name;
   
    if (!state) // First run
    {
        index = 0;
    }
   
    while (autocomplete_list.size() > index)
    {
        name = autocomplete_list[index];
       
        index++;
       
        if (strncmp(name.data(), text, length) == 0)
        {
            char *result = (char*)malloc(name.size() + 1);
            strcpy(result, name.data());
           
            return result;
        }
    }
   
    return NULL;
}
 
void CleanUp()
{
    std::cout << std::endl;
    //std::cout << "Cleaning up..." << std::endl;
 
    write_history(history_filename.data());
   
    cc.reset();
   
    net::Manager::Delete();
   
    if (buffer != NULL)
    {
        free(buffer);
    }
   
    //std::cout << "Thank you for using Atom. Goodbye!" << std::endl;
   
    tcsetattr(fileno(stdin), TCSANOW, &original_flags); // Restore
}
 
void Handler(int status)
{
    std::string signal_name = "Unknown";
   
    switch (status)
    {
        case SIGTERM:
        {
            signal_name = "Terminate";
            break;
        }  
        case SIGINT:
        {
            signal_name = "Interupt";
            break;
        }  
        case SIGQUIT:
        {
            signal_name = "Quit";
            break;
        }  
        case SIGABRT:
        {
            signal_name = "Abort";
            break;
        }  
        case SIGIO:
        {
            signal_name = "I/O";
            break;
        }  
        case SIGPIPE:
        {
            signal_name = "Pipe";
            break;
        }
    }
   
   
    if (status != SIGPIPE)
    {
        CleanUp();
        exit(0);
    }
}
 
 

Rev 1674	Rev 1675
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 <string>	21	#include <string>
22	#include <vector>	22	#include <vector>
23	#include <iostream>	23	#include <iostream>
24		24
25	#include <signal.h>	25	#include <signal.h>
26	#include <stdio.h>	26	#include <stdio.h>
27	#include <stdlib.h>	27	#include <stdlib.h>
28	#include <pwd.h>	28	#include <pwd.h>
29		29
30	#include <boost/lexical_cast.hpp>	30	#include <boost/lexical_cast.hpp>
31	#include <boost/thread/mutex.hpp>	31	#include <boost/thread/mutex.hpp>
32	#include <boost/thread/condition.hpp>	32	#include <boost/thread/condition.hpp>
33	#include <boost/thread/locks.hpp>	33	#include <boost/thread/locks.hpp>
34	#include <boost/algorithm/string.hpp>	34	#include <boost/algorithm/string.hpp>
35	#include <boost/program_options.hpp>	35	#include <boost/program_options.hpp>
36		36
37	#include "config.h"	37	#include "config.h"
38		38
39	#include "net/Manager.h"	39	#include "net/Manager.h"
40	#include "net/Subscriber.h"	40	#include "net/Subscriber.h"
41	#include "net/types.h"	41	#include "net/types.h"
42		42
43	#include "common/common.h"	43	#include "common/common.h"
44		44
45	#include <readline/readline.h>	45	#include <readline/readline.h>
46	#include <readline/history.h>	46	#include <readline/history.h>
47		47
48	using namespace atom;	48	using namespace atom;
49		49
50	bool finish = false;	50	bool finish = false;
51	common::StringList autocomplete_list;	51	common::StringList autocomplete_list;
52	char* buffer = NULL;	52	char* buffer = NULL;
53	boost::condition on_message_condition;	53	boost::condition on_message_condition;
54	struct termios original_flags;	54	struct termios original_flags;
55	std::string history_filename;	55	std::string history_filename;
56		56
57	void Handler(int status);	57	void Handler(int status);
58	void CleanUp();	58	void CleanUp();
59		59
60	char* AutoCompleteGet(const char* text, int state);	60	char* AutoCompleteGet(const char* text, int state);
61	static char** AutoComplete(const char* text, int start, int end);	61	static char** AutoComplete(const char* text, int start, int end);
62		62
63	std::string GetUserHomeDirectory()	63	std::string GetUserHomeDirectory()
64	{	64	{
65	return std::string(getpwuid(getuid())->pw_dir);	65	return std::string(getpwuid(getuid())->pw_dir);
66	}	66	}
67		67
68	class ConsoleClient : public net::Subscriber	68	class ConsoleClient : public net::Subscriber
69	{	69	{
70	public:	70	public:
71	typedef boost::shared_ptr<ConsoleClient> Pointer;	71	typedef boost::shared_ptr<ConsoleClient> Pointer;
72		72
73	ConsoleClient(std::string address, unsigned int port)	73	ConsoleClient(std::string address, unsigned int port)
74	{	74	{
75	this->client_id_ = net::Manager::Instance()->Connect(net::PROTOCOL_TCP, address, port);	75	this->client_id_ = net::Manager::Instance()->Connect(net::PROTOCOL_TCP, address, port);
76	}	76	}
77		77
78	virtual ~ConsoleClient()	78	virtual ~ConsoleClient()
79	{	79	{
80	net::Manager::Instance()->Disconnect(this->client_id_);	80	net::Manager::Instance()->Disconnect(this->client_id_);
81		81
82	this->io_service_.stop();	82	this->io_service_.stop();
83	}	83	}
84		84
85	std::string GetPrompt()	85	std::string GetPrompt()
86	{	86	{
87	return this->prompt_;	87	return this->prompt_;
88	}	88	}
89		89
90	void SendResponse(std::string payload)	90	void SendResponse(std::string payload)
91	{	91	{
92	std::string packet = "RESP";	92	std::string packet = "RESP";
93	packet += common::PadNumber(payload.length() + 1, 4);	93	packet += common::PadNumber(payload.length() + 1, 4);
94	packet += payload;	94	packet += payload;
95		95
96	net::Manager::Instance()->SendTo(this->client_id_, packet);	96	net::Manager::Instance()->SendTo(this->client_id_, packet);
97	}	97	}
98		98
99	void AutoCompleteRequest(unsigned int arg_index, std::string commandline)	99	void AutoCompleteRequest(unsigned int arg_index, std::string commandline)
100	{	100	{
101	std::string payload = common::PadNumber(arg_index, 4);	101	std::string payload = common::PadNumber(arg_index, 4);
102	payload += commandline;	102	payload += commandline;
103		103
104	std::string packet = "COMP";	104	std::string packet = "COMP";
105	packet += common::PadNumber(payload.length() + 1, 4);	105	packet += common::PadNumber(payload.length() + 1, 4);
106	packet += payload;	106	packet += payload;
107		107
108	net::Manager::Instance()->SendTo(this->client_id_, packet);	108	net::Manager::Instance()->SendTo(this->client_id_, packet);
109	}	109	}
110		110
111	private:	111	private:
112	net::ClientId client_id_;	112	net::ClientId client_id_;
113	std::string prompt_;	113	std::string prompt_;
114	std::vector<unsigned char> buffer_;	114	std::vector<unsigned char> buffer_;
115		115
116	void SlotOnNewStateHandler(net::ClientId client_id, net::ServerId server_id, net::ClientState client_state)	116	void SlotOnNewStateHandler(net::ClientId client_id, net::ServerId server_id, net::ClientState client_state)
117	{	117	{
118	if (client_state != net::CLIENT_STATE_CONNECTED)	118	if (client_state != net::CLIENT_STATE_CONNECTED)
119	{	119	{
120	std::cout << "Disconnected from server." << std::endl;	120	std::cout << "Disconnected from server." << std::endl;
121		121
122	this->client_id_ = 0;	122	this->client_id_ = 0;
123	finish = true;	123	finish = true;
124	on_message_condition.notify_all();	124	on_message_condition.notify_all();
125	}	125	}
126	}	126	}
127		127
128	void SlotOnNewDataHandler(net::ClientId client_id, net::ServerId server_id, common::Byteset data)	128	void SlotOnNewDataHandler(net::ClientId client_id, net::ServerId server_id, common::Byteset data)
129	{	129	{
130	for (unsigned int n = 0; n < data.GetSize(); n++)	130	for (unsigned int n = 0; n < data.GetSize(); n++)
131	{	131	{
132	this->buffer_.push_back(data[n]);	132	this->buffer_.push_back(data[n]);
133	}	133	}
134		134
135	while (this->buffer_.size() >= 8)	135	while (this->buffer_.size() >= 8)
136	{	136	{
137	std::string command = "";	137	std::string command = "";
138	command += (char)this->buffer_[0];	138	command += (char)this->buffer_[0];
139	command += (char)this->buffer_[1];	139	command += (char)this->buffer_[1];
140	command += (char)this->buffer_[2];	140	command += (char)this->buffer_[2];
141	command += (char)this->buffer_[3];	141	command += (char)this->buffer_[3];
142		142
143	std::string payload_length_str = "";	143	std::string payload_length_str = "";
144	payload_length_str += (char)this->buffer_[4];	144	payload_length_str += (char)this->buffer_[4];
145	payload_length_str += (char)this->buffer_[5];	145	payload_length_str += (char)this->buffer_[5];
146	payload_length_str += (char)this->buffer_[6];	146	payload_length_str += (char)this->buffer_[6];
147	payload_length_str += (char)this->buffer_[7];	147	payload_length_str += (char)this->buffer_[7];
148		148
149	unsigned int payload_length = boost::lexical_cast<unsigned int>(payload_length_str);	149	unsigned int payload_length = boost::lexical_cast<unsigned int>(payload_length_str);
150		150
151	if (this->buffer_.size() - 8 < payload_length)	151	if (this->buffer_.size() - 8 < payload_length)
152	{	152	{
153	return;	153	return;
154	}	154	}
155		155
156	std::string payload = "";	156	std::string payload = "";
157	for (unsigned int n = 8; n < payload_length + 8; n++)	157	for (unsigned int n = 8; n < payload_length + 8; n++)
158	{	158	{
159	payload += (char)this->buffer_[n];	159	payload += (char)this->buffer_[n];
160	}	160	}
161		161
162	this->buffer_.erase(this->buffer_.begin(), this->buffer_.begin() + payload_length + 8);	162	this->buffer_.erase(this->buffer_.begin(), this->buffer_.begin() + payload_length + 8);
163		163
164	if (command == "TEXT")	164	if (command == "TEXT")
165	{	165	{
166	std::cout << payload << std::flush;	166	std::cout << payload << std::flush;
167	}	167	}
168	else if (command == "PROM")	168	else if (command == "PROM")
169	{	169	{
170	this->prompt_ = payload;	170	this->prompt_ = payload;
171	on_message_condition.notify_all();	171	on_message_condition.notify_all();
172	}	172	}
173	else if (command == "COMP")	173	else if (command == "COMP")
174	{	174	{
175	autocomplete_list.clear();	175	autocomplete_list.clear();
176		176
177	if (payload.length() > 0)	177	if (payload.length() > 0)
178	{	178	{
179	boost::algorithm::split(autocomplete_list, payload, boost::is_any_of("\n"), boost::algorithm::token_compress_on);	179	boost::algorithm::split(autocomplete_list, payload, boost::is_any_of("\n"), boost::algorithm::token_compress_on);
180	}	180	}
181		181
182	on_message_condition.notify_all();	182	on_message_condition.notify_all();
183	}	183	}
184	else	184	else
185	{	185	{
186	std::cerr << "Could not parse package." << std::endl;	186	std::cerr << "Could not parse package." << std::endl;
187	finish = true;	187	finish = true;
188	on_message_condition.notify_all();	188	on_message_condition.notify_all();
189	break;	189	break;
190	}	190	}
191	}	191	}
192	}	192	}
193	};	193	};
194		194
195	ConsoleClient::Pointer cc;	195	ConsoleClient::Pointer cc;
196		196
197		197
198	int main(int argc, char **argv)	198	int main(int argc, char **argv)
199	{	199	{
200	// Signal handlers	200	// Signal handlers
201	signal(SIGTERM, Handler);	201	signal(SIGTERM, Handler);
202	signal(SIGINT, Handler);	202	signal(SIGINT, Handler);
203	signal(SIGQUIT, Handler);	203	signal(SIGQUIT, Handler);
204	signal(SIGABRT, Handler);	204	signal(SIGABRT, Handler);
205	signal(SIGPIPE, Handler);	205	signal(SIGPIPE, Handler);
206		206
207	boost::mutex guard_mutex;	207	boost::mutex guard_mutex;
208		208
209	// Setup readline	209	// Setup readline
210	history_filename = GetUserHomeDirectory() + "/.atomic_history";	210	history_filename = GetUserHomeDirectory() + "/.atomic_history";
211	read_history(history_filename.data());	211	read_history(history_filename.data());
212		212
213	rl_attempted_completion_function = AutoComplete;	213	rl_attempted_completion_function = AutoComplete;
214		214
215	// Save command line state	215	// Save command line state
216	tcgetattr(fileno(stdin), &original_flags);	216	tcgetattr(fileno(stdin), &original_flags);
217		217
218	// Parse commandline	218	// Parse commandline
219	boost::program_options::options_description command_line;	219	boost::program_options::options_description command_line;
220	boost::program_options::variables_map variable_map;	220	boost::program_options::variables_map variable_map;
221		221
222	command_line.add_options()	222	command_line.add_options()
223	("help,h", "produce help message")	223	("help,h", "produce help message")
224	("command,c", boost::program_options::value<std::string>()->default_value(""), "command")	224	("command,c", boost::program_options::value<std::string>()->default_value(""), "command")
225	("server,s", boost::program_options::value<std::string>()->default_value("localhost"), "server address")	225	("server,s", boost::program_options::value<std::string>()->default_value("localhost"), "server address")
226	("port,p", boost::program_options::value<unsigned int>()->default_value(1202), "server port");	226	("port,p", boost::program_options::value<unsigned int>()->default_value(1202), "server port");
227		227
228	try	228	try
229	{	229	{
230	boost::program_options::store(boost::program_options::command_line_parser(argc, argv).options(command_line).run(), variable_map);	230	boost::program_options::store(boost::program_options::command_line_parser(argc, argv).options(command_line).run(), variable_map);
231	}	231	}
232	catch (boost::program_options::unknown_option e)	232	catch (boost::program_options::unknown_option e)
233	{	233	{
234	std::cerr << e.what() << std::endl;	234	std::cerr << e.what() << std::endl;
235	std::cout << command_line << std::endl;	235	std::cout << command_line << std::endl;
236	CleanUp();	236	CleanUp();
237	return EXIT_FAILURE;	237	return EXIT_FAILURE;
238	}	238	}
239	catch (boost::program_options::invalid_syntax e)	239	catch (boost::program_options::invalid_syntax e)
240	{	240	{
241	std::cerr << e.what() << std::endl;	241	std::cerr << e.what() << std::endl;
242	std::cout << command_line << std::endl;	242	std::cout << command_line << std::endl;
243	CleanUp();	243	CleanUp();
244	return EXIT_FAILURE;	244	return EXIT_FAILURE;
245	}	245	}
246		246
247	if (variable_map.count("help") != 0)	247	if (variable_map.count("help") != 0)
248	{	248	{
249	std::cout << command_line << std::endl;	249	std::cout << command_line << std::endl;
250	CleanUp();	250	CleanUp();
251	return EXIT_SUCCESS;	251	return EXIT_SUCCESS;
252	}	252	}
253		253
254	net::Manager::Create();	254	net::Manager::Create();
255		255
256	if (variable_map["command"].as<std::string>() == "")	256	if (variable_map["command"].as<std::string>() == "")
257	{	257	{
258	std::cout << "\033[29;1mAtom Interactive Console, version " + std::string(VERSION) + " starting...\033[0m" << std::endl;	258	std::cout << "\033[29;1mAtom Interactive Console, version " + std::string(VERSION) + " starting...\033[0m" << std::endl;
259	std::cout << "\033[29;1mReleased under GPL version 2.\033[0m" << std::endl;	259	std::cout << "\033[29;1mReleased under GPL version 2.\033[0m" << std::endl;
260	std::cout << "Written by Mattias Runge 2010." << std::endl;	260	std::cout << "Written by Mattias Runge 2010." << std::endl;
261		261
262	std::cout << "Connecting to " << variable_map["server"].as<std::string>().data() << ":" << variable_map["port"].as<unsigned int>() << "..." << std::endl;	262	std::cout << "Connecting to " << variable_map["server"].as<std::string>().data() << ":" << variable_map["port"].as<unsigned int>() << "..." << std::endl;
263	}	263	}
264		264
265	try	265	try
266	{	266	{
267	cc = ConsoleClient::Pointer(new ConsoleClient(variable_map["server"].as<std::string>(), variable_map["port"].as<unsigned int>()));	267	cc = ConsoleClient::Pointer(new ConsoleClient(variable_map["server"].as<std::string>(), variable_map["port"].as<unsigned int>()));
268	}	268	}
269	catch (std::runtime_error& e)	269	catch (std::runtime_error& e)
270	{	270	{
271	std::cerr << "Connection error: " << e.what() << std::endl;	271	std::cerr << "Connection error: " << e.what() << std::endl;
272	CleanUp();	272	CleanUp();
273	return EXIT_FAILURE;	273	return EXIT_FAILURE;
274	}	274	}
275		275
276	if (variable_map["command"].as<std::string>() != "")	276	if (variable_map["command"].as<std::string>() != "")
277	{	277	{
278	boost::mutex::scoped_lock guard(guard_mutex);	278	boost::mutex::scoped_lock guard(guard_mutex);
279	on_message_condition.wait(guard);	279	on_message_condition.wait(guard);
280		280
281	if (!finish)	281	if (!finish)
282	{	282	{
283	cc->SendResponse(variable_map["command"].as<std::string>());	283	cc->SendResponse(variable_map["command"].as<std::string>());
284		284
285	if (!finish)	285	if (!finish)
286	{	286	{
287	on_message_condition.wait(guard);	287	on_message_condition.wait(guard);
288	}	288	}
289	}	289	}
290	}	290	}
291	else	291	else
292	{	292	{
293	while (true)	293	while (true)
294	{	294	{
295	boost::mutex::scoped_lock guard(guard_mutex);	295	boost::mutex::scoped_lock guard(guard_mutex);
296	on_message_condition.wait(guard);	296	on_message_condition.wait(guard);
297		297
298	if (finish)	298	if (finish)
299	{	299	{
300	break;	300	break;
301	}	301	}
302		302
303	while ((buffer = readline(cc->GetPrompt().data())) != NULL)	303	while ((buffer = readline(cc->GetPrompt().data())) != NULL)
304	{	304	{
305	if (finish)	305	if (finish)
306	{	306	{
307	break;	307	break;
308	}	308	}
309		309
310	if (strlen(buffer) == 0)	310	if (strlen(buffer) == 0)
311	{	311	{
312	continue;	312	continue;
313	}	313	}
314		314
315	break;	315	break;
316	}	316	}
317		317
318	if (finish)	318	if (finish)
319	{	319	{
320	break;	320	break;
321	}	321	}
322		322
323	cc->SendResponse(buffer);	323	cc->SendResponse(buffer);
324	add_history(buffer);	324	add_history(buffer);
325	}	325	}
326	}	326	}
327		327
328	CleanUp();	328	CleanUp();
329		329
330	return EXIT_SUCCESS;	330	return EXIT_SUCCESS;
331	}	331	}
332		332
333	static char** AutoComplete(const char* text, int start, int end)	333	static char** AutoComplete(const char* text, int start, int end)
334	{	334	{
335	unsigned int count = 0;	335	unsigned int count = 0;
336	boost::mutex guard_mutex;	336	boost::mutex guard_mutex;
337		337
338	for (unsigned int n = 0; n < start; n++)	338	for (unsigned int n = 0; n < start; n++)
339	{	339	{
340	if (rl_line_buffer[n] == ' ')	340	if (rl_line_buffer[n] == ' ')
341	{	341	{
342	count++;	342	count++;
343	}	343	}
344	}	344	}
345		345
346	cc->AutoCompleteRequest(count, rl_line_buffer);	346	cc->AutoCompleteRequest(count, rl_line_buffer);
347		347
348	boost::mutex::scoped_lock guard(guard_mutex);	348	boost::mutex::scoped_lock guard(guard_mutex);
349	on_message_condition.wait(guard);	349	on_message_condition.wait(guard);
350		350
351	/*if (autocomplete_list.size() == 0)	351	/*if (autocomplete_list.size() == 0)
352	{	352	{
353	return NULL;	353	return NULL;
354	}*/	354	}*/
355		355
356	return rl_completion_matches(text, &AutoCompleteGet);	356	return rl_completion_matches(text, &AutoCompleteGet);
357	}	357	}
358		358
359	char* AutoCompleteGet(const char* text, int state)	359	char* AutoCompleteGet(const char* text, int state)
360	{	360	{
361	static int index = 0;	361	static int index = 0;
362	int length = strlen(text);	362	int length = strlen(text);
363	std::string name;	363	std::string name;
364		364
365	if (!state) // First run	365	if (!state) // First run
366	{	366	{
367	index = 0;	367	index = 0;
368	}	368	}
369		369
370	while (autocomplete_list.size() > index)	370	while (autocomplete_list.size() > index)
371	{	371	{
372	name = autocomplete_list[index];	372	name = autocomplete_list[index];
373		373
374	index++;	374	index++;
375		375
376	if (strncmp(name.data(), text, length) == 0)	376	if (strncmp(name.data(), text, length) == 0)
377	{	377	{
378	char result = (char)malloc(name.size() + 1);	378	char result = (char)malloc(name.size() + 1);
379	strcpy(result, name.data());	379	strcpy(result, name.data());
380		380
381	return result;	381	return result;
382	}	382	}
383	}	383	}
384		384
385	return NULL;	385	return NULL;
386	}	386	}
387		387
388	void CleanUp()	388	void CleanUp()
389	{	389	{
390	std::cout << std::endl;	390	std::cout << std::endl;
391	//std::cout << "Cleaning up..." << std::endl;	391	//std::cout << "Cleaning up..." << std::endl;
392		392
393	write_history(history_filename.data());	393	write_history(history_filename.data());
394		394
395	cc.reset();	395	cc.reset();
396		396
397	net::Manager::Delete();	397	net::Manager::Delete();
398		398
399	if (buffer != NULL)	399	if (buffer != NULL)
400	{	400	{
401	free(buffer);	401	free(buffer);
402	}	402	}
403		403
404	//std::cout << "Thank you for using Atom. Goodbye!" << std::endl;	404	//std::cout << "Thank you for using Atom. Goodbye!" << std::endl;
405		405
406	tcsetattr(fileno(stdin), TCSANOW, &original_flags); // Restore	406	tcsetattr(fileno(stdin), TCSANOW, &original_flags); // Restore
407	}	407	}
408		408
409	void Handler(int status)	409	void Handler(int status)
410	{	410	{
411	std::string signal_name = "Unknown";	411	std::string signal_name = "Unknown";
412		412
413	switch (status)	413	switch (status)
414	{	414	{
415	case SIGTERM:	415	case SIGTERM:
416	{	416	{
417	signal_name = "Terminate";	417	signal_name = "Terminate";
418	break;	418	break;
419	}	419	}
420	case SIGINT:	420	case SIGINT:
421	{	421	{
422	signal_name = "Interupt";	422	signal_name = "Interupt";
423	break;	423	break;
424	}	424	}
425	case SIGQUIT:	425	case SIGQUIT:
426	{	426	{
427	signal_name = "Quit";	427	signal_name = "Quit";
428	break;	428	break;
429	}	429	}
430	case SIGABRT:	430	case SIGABRT:
431	{	431	{
432	signal_name = "Abort";	432	signal_name = "Abort";
433	break;	433	break;
434	}	434	}
435	case SIGIO:	435	case SIGIO:
436	{	436	{
437	signal_name = "I/O";	437	signal_name = "I/O";
438	break;	438	break;
439	}	439	}
440	case SIGPIPE:	440	case SIGPIPE:
441	{	441	{
442	signal_name = "Pipe";	442	signal_name = "Pipe";
443	break;	443	break;
444	}	444	}
445	}	445	}
446		446
447		447
448	if (status != SIGPIPE)	448	if (status != SIGPIPE)
449	{	449	{
450	CleanUp();	450	CleanUp();
451	exit(0);	451	exit(0);
452	}	452	}
453	}	453	}
-		454
-		455

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/atomic.cpp – Rev 1674 → 1675