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

+ *
  */
 #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 "net/Manager.h"
 #include "net/Subscriber.h"
 #include "net/types.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);
-common::StringList autocomplete_list;
-char* buffer = NULL;
-bool waiting_for_autocomplete = false;
-boost::condition on_message_condition;
-boost::mutex guard_mutex;
-std::string prompt;
+std::string GetCwd()
+{
-int prompt_id = -1;
+    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->identifier_ = address + ":" + boost::lexical_cast<std::string>(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();
     }
-    void Send(std::string data)
+    std::string GetPrompt()
     {
-        net::Manager::Instance()->SendTo(this->client_id_, data);
+        return this->prompt_;
     }
-    bool IsConnected()
+    void SendResponse(std::string payload)
     {
-        return this->client_id_ != 0;
+        std::string packet = "RESP";
+        packet += common::PadNumber(payload.length() + 1, 4);
-    }
+        packet += payload;
-    std::string GetIdentifier()
-    {
-        return this->identifier_;
+        net::Manager::Instance()->SendTo(this->client_id_, packet);
+    }
+    void AutoCompleteRequest(unsigned int arg_index, std::string commandline)
-private:
+    {
-    net::ClientId client_id_;
+        std::string payload = common::PadNumber(arg_index, 4);
-    std::string identifier_;
+        payload += commandline;
+        std::string packet = "COMP";
+        packet += common::PadNumber(payload.length() + 1, 4);
+        packet += payload;
-    void SlotOnNewStateHandler(net::ClientId client_id, net::ServerId server_id, net::ClientState client_state)
-    {
-        if (client_state == net::CLIENT_STATE_CONNECTED)
+        net::Manager::Instance()->SendTo(this->client_id_, packet);
-        {
-            printf("Connected to Atom Daemon!\n");
+    }
+private:
+    net::ClientId client_id_;
+    std::string prompt_;
+    void SlotOnNewStateHandler(net::ClientId client_id, net::ServerId server_id, net::ClientState client_state)
-        else
+    {
+        if (client_state != net::CLIENT_STATE_CONNECTED)
         {
-            printf("\nDisconnected!\n");
+            std::cout << "Disconnected from server" << std::endl;
             this->client_id_ = 0;
+            finish = true;
             kill(getpid(), SIGTERM);
         }
     }
-    void SlotOnNewDataHandler(net::ClientId client_id, net::ServerId server_id, common::Byteset data)
-    {
-        prompt_id = -1;
+    void SlotOnNewDataHandler(net::ClientId client_id, net::ServerId server_id, common::Byteset data)
+    {
         std::string s(data.ToCharString());
+        while (s.length() > 0)
+        {
+            std::string command = s.substr(0, 4);
+            unsigned int payload_length = boost::lexical_cast<unsigned int>(s.substr(4, 4));
+            if (command == "TEXT")
+            {
+                std::cout << s.substr(8, payload_length - 1) << std::flush;
+            }
+            else if (command == "PROM")
+            {
+                this->prompt_ = s.substr(8, payload_length - 1);
+                on_message_condition.notify_all();
+            }
-        if (waiting_for_autocomplete)
+            else if (command == "COMP")
-        {
+            {
-            autocomplete_list.clear();
+                autocomplete_list.clear();
-            boost::algorithm::trim_if(s, boost::is_any_of("\n"));
+                if (payload_length > 0)
+                {
-            boost::algorithm::trim_if(s, boost::is_any_of(" "));
+                    std::string payload = s.substr(8, payload_length - 1);
-            if (s != "")
+                    if (payload.length() > 0)
+                    {
-                boost::algorithm::split(autocomplete_list, s, boost::is_any_of("\n"), boost::algorithm::token_compress_on);
+                        boost::algorithm::split(autocomplete_list, payload, boost::is_any_of("\n"), boost::algorithm::token_compress_on);
+                    }
+                }
-        else
-        {
-            common::StringList lines;
-            boost::algorithm::split(lines, s, boost::is_any_of("\n"), boost::algorithm::token_compress_on);
-            for (unsigned int n = 0; n < lines.size(); n++)
+                on_message_condition.notify_all();
-            {
+            }
-                common::StringList parts;
-                boost::algorithm::split(parts, lines[n], boost::is_any_of(";"), boost::algorithm::token_compress_off);
+            else
-                if (parts[0].length() == 1 && parts[0] == "P")
-                {
-                    prompt_id = boost::lexical_cast<unsigned int>(parts[1]);
-                    prompt = "";
-                    for (unsigned int c = 2; c < parts.size(); c++)
-                    {
-                        prompt += parts[c] + " ";
-                    }
-                }
-                else
-                {
-                    boost::algorithm::trim_if(lines[n], boost::is_any_of(" "));
-                    if (lines[n] != "")
+            {
-                        printf("%s\n", lines[n].data());
+                std::cerr << "Unknown data received: " << s << std::endl;
-                    }
+                finish = true;
-                }
-            }
-        }
-        on_message_condition.notify_all();
+                on_message_condition.notify_all();
+                break;
+            }
+            if (8 + payload_length >= s.length())
+            {
+                break;
+            }
+            s = s.substr(8 + payload_length);
+        }
+    }
 };
 ConsoleClient::Pointer cc;
-struct termios original_flags;
-std::string history_filename;
 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 = GetCwd() + "/.atomic_history";
+    read_history(history_filename.data());
+    rl_attempted_completion_function = AutoComplete;
+    // Save command line state
     tcgetattr(fileno(stdin), &original_flags);
+    // Parse commandline
-    printf("Atom Interactive Console, version 1.5.0 starting...\n");
+    boost::program_options::options_description command_line;
-    printf("Written by Mattias Runge 2010.\n");
+    boost::program_options::variables_map variable_map;
+    command_line.add_options()
-    printf("Released under GPL version 2.\n");
+    ("help,h",    "produce help message")
+    ("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;
-    net::Manager::Create();
+        CleanUp();
+        return EXIT_FAILURE;
+    }
+    if (variable_map.count("help") != 0)
+    {
-    std::string address = "localhost";
+        std::cout << command_line << std::endl;
+        CleanUp();
-    unsigned int port = 1202;
+        return EXIT_SUCCESS;
+    }
+    std::cout << "Atom Interactive Console, version 1.5.0 starting..." << std::endl;
+    std::cout << "Written by Mattias Runge 2010." << std::endl;
+    std::cout << "Released under GPL version 2." << std::endl;
+    net::Manager::Create();
-    printf("Connecting to %s:%d...", address.data(), port);
+    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(address, port));
+        cc = ConsoleClient::Pointer(new ConsoleClient(variable_map["server"].as<std::string>(), variable_map["port"].as<unsigned int>()));
+    }
     catch (std::runtime_error& e)
+    {
+        std::cout << "error!" << std::endl;
-        printf("%s\n", e.what());
+        std::cerr << e.what() << std::endl;
         CleanUp();
         return EXIT_FAILURE;
+    }
-    printf("success!\n");
+    while (true)
+    {
-    prompt = cc->GetIdentifier() + "] ";
+        boost::mutex::scoped_lock guard(guard_mutex);
-    passwd* user_struct = getpwuid(getuid());
+        on_message_condition.wait(guard);
-    history_filename = std::string(user_struct->pw_dir) + "/.atomic_history";
+        if (finish)
+        {
-    read_history(history_filename.data());
+            break;
+        }
-    rl_attempted_completion_function = AutoComplete;
-    while ((buffer = readline(prompt.data())) != NULL)
+        while ((buffer = readline(cc->GetPrompt().data())) != NULL)
-    {
+        {
-        if (strlen(buffer) == 0)
+            if (strlen(buffer) == 0)
+            {
-            continue;
+                continue;
-        }
+            }
-        if (strcmp(buffer, "quit") == 0)
-        {
             break;
+        }
-        waiting_for_autocomplete = false;
-        prompt = cc->GetIdentifier() + "] ";
-        if (prompt_id == -1)
-        {
-            cc->Send("E;" + std::string(buffer));
+        cc->SendResponse(buffer);
-            add_history(buffer);
+        add_history(buffer);
-        }
-        else
-        {
-            cc->Send("R;" + boost::lexical_cast<std::string>(prompt_id) + ";" + std::string(buffer));
-            prompt_id = -1;
-        }
-        boost::mutex::scoped_lock guard(guard_mutex);
-        on_message_condition.wait(guard);
+    }
     CleanUp();
     return EXIT_SUCCESS;
 }
 static char** AutoComplete(const char* text, int start, int end)
 {
     unsigned int count = 0;
-    //printf("\nAutoComplete:start=%d, end=%d\n", start, end);
+    boost::mutex guard_mutex;
     for (unsigned int n = 0; n < start; n++)
+    {
         if (rl_line_buffer[n] == ' ')
+        {
             count++;
+        }
     }
-    waiting_for_autocomplete = true;
-    std::string request = "A;"+ boost::lexical_cast<std::string>(count) + ";" + std::string(rl_line_buffer);
-    //printf("\nSending request:%s\n", request.data());
+    cc->AutoCompleteRequest(count, rl_line_buffer);
-    cc->Send(request);
     boost::mutex::scoped_lock guard(guard_mutex);
     on_message_condition.wait(guard);
-    if (autocomplete_list.size() == 0)
+    /*if (autocomplete_list.size() == 0)
     {
         return NULL;
-    }
+    }*/
-    //printf("processing response\n");
     return rl_completion_matches(text, &AutoCompleteGet);
+}
 char* AutoCompleteGet(const char* text, int state)
+{
     static int index = 0;
     int length = strlen(text);
     std::string name;
-    //printf("run, %s, %d, %d\n", text, state, autocomplete_list.size());
     if (!state) // First run
+    {
         index = 0;
+    }
     while (autocomplete_list.size() > index)
+    {
         name = autocomplete_list[index];
-        //printf("testing name = %s\n", name.data());
         index++;
         if (strncmp(name.data(), text, length) == 0)
+        {
     return NULL;
+}
 void CleanUp()
+{
-    printf("Cleaning up...\n");
+    std::cout << "Cleaning up..." << std::endl;
     write_history(history_filename.data());
     cc.reset();
     if (buffer != NULL)
+    {
         free(buffer);
+    }
-    printf("Thank you for using Atom. Goodbye!\n");
+    std::cout << "Thank you for using Atom. Goodbye!" << std::endl;
     tcsetattr(fileno(stdin), TCSANOW, &original_flags); // Restore
+}
 void Handler(int status)
     if (status != SIGPIPE)
+    {
         CleanUp();
         exit(0);
-        //on_message_condition.notify_all();
+    }
+}

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/atomic.cpp – Rev 1642 → 1647