monero/contrib/epee/include/console_handler.h

575 lines
16 KiB
C
Raw Normal View History

// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
2014-03-03 23:07:58 +01:00
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the Andrey N. Sabelnikov nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
2014-03-03 23:07:58 +01:00
#pragma once
#include "misc_log_ex.h"
2014-03-20 12:46:11 +01:00
#include <atomic>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <thread>
#include <iostream>
2016-01-21 19:18:26 +01:00
#ifdef __OpenBSD__
#include <stdio.h>
#endif
#include <boost/thread.hpp>
2014-03-20 12:46:11 +01:00
#ifdef HAVE_READLINE
#include "readline_buffer.h"
#endif
2014-03-03 23:07:58 +01:00
namespace epee
{
2014-03-20 12:46:11 +01:00
class async_stdin_reader
{
public:
async_stdin_reader()
: m_run(true)
, m_has_read_request(false)
, m_read_status(state_init)
{
m_reader_thread = boost::thread(std::bind(&async_stdin_reader::reader_thread_func, this));
#ifdef HAVE_READLINE
m_readline_buffer.start();
m_readline_thread = boost::thread(std::bind(&async_stdin_reader::readline_thread_func, this));
#endif
2014-03-20 12:46:11 +01:00
}
2014-03-03 23:07:58 +01:00
2014-03-20 12:46:11 +01:00
~async_stdin_reader()
{
stop();
}
2014-03-03 23:07:58 +01:00
#ifdef HAVE_READLINE
rdln::readline_buffer& get_readline_buffer()
{
return m_readline_buffer;
}
#endif
2014-03-20 12:46:11 +01:00
// Not thread safe. Only one thread can call this method at once.
bool get_line(std::string& line)
{
if (!start_read())
return false;
2014-03-03 23:07:58 +01:00
if (state_eos == m_read_status)
return false;
boost::unique_lock<boost::mutex> lock(m_response_mutex);
2014-03-20 12:46:11 +01:00
while (state_init == m_read_status)
{
m_response_cv.wait(lock);
}
2014-03-03 23:07:58 +01:00
2014-03-20 12:46:11 +01:00
bool res = false;
if (state_success == m_read_status)
{
line = m_line;
res = true;
}
2014-03-03 23:07:58 +01:00
if (!eos())
m_read_status = state_init;
2014-03-20 12:46:11 +01:00
return res;
}
bool eos() const { return m_read_status == state_eos; }
2014-03-20 12:46:11 +01:00
void stop()
{
if (m_run)
{
m_run.store(false, std::memory_order_relaxed);
#if defined(WIN32)
::CloseHandle(::GetStdHandle(STD_INPUT_HANDLE));
#endif
m_request_cv.notify_one();
m_reader_thread.join();
#ifdef HAVE_READLINE
m_readline_buffer.stop();
m_readline_thread.join();
#endif
2014-03-20 12:46:11 +01:00
}
}
private:
bool start_read()
{
boost::unique_lock<boost::mutex> lock(m_request_mutex);
2014-03-20 12:46:11 +01:00
if (!m_run.load(std::memory_order_relaxed) || m_has_read_request)
return false;
m_has_read_request = true;
m_request_cv.notify_one();
return true;
}
bool wait_read()
2014-03-03 23:07:58 +01:00
{
boost::unique_lock<boost::mutex> lock(m_request_mutex);
2014-03-20 12:46:11 +01:00
while (m_run.load(std::memory_order_relaxed) && !m_has_read_request)
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
m_request_cv.wait(lock);
2014-03-03 23:07:58 +01:00
}
2014-03-20 12:46:11 +01:00
if (m_has_read_request)
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
m_has_read_request = false;
return true;
}
return false;
}
bool wait_stdin_data()
{
#if !defined(WIN32)
2017-01-05 02:11:05 +01:00
#if defined(__OpenBSD__) || defined(__ANDROID__)
2016-01-21 19:18:26 +01:00
int stdin_fileno = fileno(stdin);
#else
2014-03-20 12:46:11 +01:00
int stdin_fileno = ::fileno(stdin);
2016-01-21 19:18:26 +01:00
#endif
2014-03-20 12:46:11 +01:00
while (m_run.load(std::memory_order_relaxed))
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
fd_set read_set;
FD_ZERO(&read_set);
FD_SET(stdin_fileno, &read_set);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100 * 1000;
int retval = ::select(stdin_fileno + 1, &read_set, NULL, NULL, &tv);
if (retval < 0)
return false;
else if (0 < retval)
return true;
}
#else
while (m_run.load(std::memory_order_relaxed))
{
int retval = ::WaitForSingleObject(::GetStdHandle(STD_INPUT_HANDLE), 100);
switch (retval)
{
case WAIT_FAILED:
return false;
case WAIT_OBJECT_0:
return true;
default:
break;
}
}
2014-03-20 12:46:11 +01:00
#endif
return true;
}
#ifdef HAVE_READLINE
void readline_thread_func()
{
while (m_run.load(std::memory_order_relaxed))
{
m_readline_buffer.process();
}
}
#endif
2014-03-20 12:46:11 +01:00
void reader_thread_func()
{
while (true)
{
if (!wait_read())
break;
std::string line;
bool read_ok = true;
if (wait_stdin_data())
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
if (m_run.load(std::memory_order_relaxed))
{
#ifdef HAVE_READLINE
m_readline_buffer.get_line(line);
#else
2014-03-20 12:46:11 +01:00
std::getline(std::cin, line);
#endif
2014-03-20 12:46:11 +01:00
read_ok = !std::cin.eof() && !std::cin.fail();
}
2014-03-03 23:07:58 +01:00
}
2014-03-20 12:46:11 +01:00
else
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
read_ok = false;
}
if (std::cin.eof()) {
m_read_status = state_eos;
m_response_cv.notify_one();
break;
}
else
2014-03-20 12:46:11 +01:00
{
boost::unique_lock<boost::mutex> lock(m_response_mutex);
2014-03-20 12:46:11 +01:00
if (m_run.load(std::memory_order_relaxed))
{
m_line = std::move(line);
m_read_status = read_ok ? state_success : state_error;
}
else
{
m_read_status = state_cancelled;
}
m_response_cv.notify_one();
2014-03-03 23:07:58 +01:00
}
}
}
2014-03-20 12:46:11 +01:00
enum t_state
{
state_init,
state_success,
state_error,
state_cancelled,
state_eos
2014-03-20 12:46:11 +01:00
};
private:
boost::thread m_reader_thread;
2014-03-20 12:46:11 +01:00
std::atomic<bool> m_run;
#ifdef HAVE_READLINE
boost::thread m_readline_thread;
rdln::readline_buffer m_readline_buffer;
#endif
2014-03-20 12:46:11 +01:00
std::string m_line;
bool m_has_read_request;
t_state m_read_status;
boost::mutex m_request_mutex;
boost::mutex m_response_mutex;
boost::condition_variable m_request_cv;
boost::condition_variable m_response_cv;
2014-03-20 12:46:11 +01:00
};
template<class t_server>
bool empty_commands_handler(t_server* psrv, const std::string& command)
{
2014-03-03 23:07:58 +01:00
return true;
}
2014-03-20 12:46:11 +01:00
class async_console_handler
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
public:
async_console_handler()
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
}
2014-03-03 23:07:58 +01:00
2014-03-20 12:46:11 +01:00
template<class t_server, class chain_handler>
bool run(t_server* psrv, chain_handler ch_handler, std::function<std::string(void)> prompt, const std::string& usage = "")
2014-03-20 12:46:11 +01:00
{
return run(prompt, usage, [&](const std::string& cmd) { return ch_handler(psrv, cmd); }, [&] { psrv->send_stop_signal(); });
}
2014-03-03 23:07:58 +01:00
2014-03-20 12:46:11 +01:00
template<class chain_handler>
bool run(chain_handler ch_handler, std::function<std::string(void)> prompt, const std::string& usage = "", std::function<void(void)> exit_handler = NULL)
2014-03-20 12:46:11 +01:00
{
return run(prompt, usage, [&](const std::string& cmd) { return ch_handler(cmd); }, exit_handler);
2014-03-20 12:46:11 +01:00
}
void stop()
{
m_running = false;
2014-03-20 12:46:11 +01:00
m_stdin_reader.stop();
}
void print_prompt()
{
std::string prompt = m_prompt();
if (!prompt.empty())
{
#ifdef HAVE_READLINE
std::string color_prompt = "\001\033[1;33m\002" + prompt;
if (' ' != prompt.back())
color_prompt += " ";
color_prompt += "\001\033[0m\002";
m_stdin_reader.get_readline_buffer().set_prompt(color_prompt);
#else
Change logging to easylogging++ This replaces the epee and data_loggers logging systems with a single one, and also adds filename:line and explicit severity levels. Categories may be defined, and logging severity set by category (or set of categories). epee style 0-4 log level maps to a sensible severity configuration. Log files now also rotate when reaching 100 MB. To select which logs to output, use the MONERO_LOGS environment variable, with a comma separated list of categories (globs are supported), with their requested severity level after a colon. If a log matches more than one such setting, the last one in the configuration string applies. A few examples: This one is (mostly) silent, only outputting fatal errors: MONERO_LOGS=*:FATAL This one is very verbose: MONERO_LOGS=*:TRACE This one is totally silent (logwise): MONERO_LOGS="" This one outputs all errors and warnings, except for the "verify" category, which prints just fatal errors (the verify category is used for logs about incoming transactions and blocks, and it is expected that some/many will fail to verify, hence we don't want the spam): MONERO_LOGS=*:WARNING,verify:FATAL Log levels are, in decreasing order of priority: FATAL, ERROR, WARNING, INFO, DEBUG, TRACE Subcategories may be added using prefixes and globs. This example will output net.p2p logs at the TRACE level, but all other net* logs only at INFO: MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE Logs which are intended for the user (which Monero was using a lot through epee, but really isn't a nice way to go things) should use the "global" category. There are a few helper macros for using this category, eg: MGINFO("this shows up by default") or MGINFO_RED("this is red"), to try to keep a similar look and feel for now. Existing epee log macros still exist, and map to the new log levels, but since they're used as a "user facing" UI element as much as a logging system, they often don't map well to log severities (ie, a log level 0 log may be an error, or may be something we want the user to see, such as an important info). In those cases, I tried to use the new macros. In other cases, I left the existing macros in. When modifying logs, it is probably best to switch to the new macros with explicit levels. The --log-level options and set_log commands now also accept category settings, in addition to the epee style log levels.
2017-01-01 17:34:23 +01:00
epee::set_console_color(epee::console_color_yellow, true);
std::cout << prompt;
if (' ' != prompt.back())
std::cout << ' ';
Change logging to easylogging++ This replaces the epee and data_loggers logging systems with a single one, and also adds filename:line and explicit severity levels. Categories may be defined, and logging severity set by category (or set of categories). epee style 0-4 log level maps to a sensible severity configuration. Log files now also rotate when reaching 100 MB. To select which logs to output, use the MONERO_LOGS environment variable, with a comma separated list of categories (globs are supported), with their requested severity level after a colon. If a log matches more than one such setting, the last one in the configuration string applies. A few examples: This one is (mostly) silent, only outputting fatal errors: MONERO_LOGS=*:FATAL This one is very verbose: MONERO_LOGS=*:TRACE This one is totally silent (logwise): MONERO_LOGS="" This one outputs all errors and warnings, except for the "verify" category, which prints just fatal errors (the verify category is used for logs about incoming transactions and blocks, and it is expected that some/many will fail to verify, hence we don't want the spam): MONERO_LOGS=*:WARNING,verify:FATAL Log levels are, in decreasing order of priority: FATAL, ERROR, WARNING, INFO, DEBUG, TRACE Subcategories may be added using prefixes and globs. This example will output net.p2p logs at the TRACE level, but all other net* logs only at INFO: MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE Logs which are intended for the user (which Monero was using a lot through epee, but really isn't a nice way to go things) should use the "global" category. There are a few helper macros for using this category, eg: MGINFO("this shows up by default") or MGINFO_RED("this is red"), to try to keep a similar look and feel for now. Existing epee log macros still exist, and map to the new log levels, but since they're used as a "user facing" UI element as much as a logging system, they often don't map well to log severities (ie, a log level 0 log may be an error, or may be something we want the user to see, such as an important info). In those cases, I tried to use the new macros. In other cases, I left the existing macros in. When modifying logs, it is probably best to switch to the new macros with explicit levels. The --log-level options and set_log commands now also accept category settings, in addition to the epee style log levels.
2017-01-01 17:34:23 +01:00
epee::reset_console_color();
std::cout.flush();
#endif
}
}
2014-03-20 12:46:11 +01:00
private:
template<typename t_cmd_handler>
bool run(std::function<std::string(void)> prompt, const std::string& usage, const t_cmd_handler& cmd_handler, std::function<void(void)> exit_handler)
2014-03-20 12:46:11 +01:00
{
bool continue_handle = true;
m_prompt = prompt;
2014-03-20 12:46:11 +01:00
while(continue_handle)
2014-03-03 23:07:58 +01:00
{
try
{
if (!m_running)
{
break;
}
print_prompt();
2014-03-20 12:46:11 +01:00
std::string command;
bool get_line_ret = m_stdin_reader.get_line(command);
if (!m_running || m_stdin_reader.eos())
{
break;
}
if (!get_line_ret)
{
Change logging to easylogging++ This replaces the epee and data_loggers logging systems with a single one, and also adds filename:line and explicit severity levels. Categories may be defined, and logging severity set by category (or set of categories). epee style 0-4 log level maps to a sensible severity configuration. Log files now also rotate when reaching 100 MB. To select which logs to output, use the MONERO_LOGS environment variable, with a comma separated list of categories (globs are supported), with their requested severity level after a colon. If a log matches more than one such setting, the last one in the configuration string applies. A few examples: This one is (mostly) silent, only outputting fatal errors: MONERO_LOGS=*:FATAL This one is very verbose: MONERO_LOGS=*:TRACE This one is totally silent (logwise): MONERO_LOGS="" This one outputs all errors and warnings, except for the "verify" category, which prints just fatal errors (the verify category is used for logs about incoming transactions and blocks, and it is expected that some/many will fail to verify, hence we don't want the spam): MONERO_LOGS=*:WARNING,verify:FATAL Log levels are, in decreasing order of priority: FATAL, ERROR, WARNING, INFO, DEBUG, TRACE Subcategories may be added using prefixes and globs. This example will output net.p2p logs at the TRACE level, but all other net* logs only at INFO: MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE Logs which are intended for the user (which Monero was using a lot through epee, but really isn't a nice way to go things) should use the "global" category. There are a few helper macros for using this category, eg: MGINFO("this shows up by default") or MGINFO_RED("this is red"), to try to keep a similar look and feel for now. Existing epee log macros still exist, and map to the new log levels, but since they're used as a "user facing" UI element as much as a logging system, they often don't map well to log severities (ie, a log level 0 log may be an error, or may be something we want the user to see, such as an important info). In those cases, I tried to use the new macros. In other cases, I left the existing macros in. When modifying logs, it is probably best to switch to the new macros with explicit levels. The --log-level options and set_log commands now also accept category settings, in addition to the epee style log levels.
2017-01-01 17:34:23 +01:00
MERROR("Failed to read line.");
}
string_tools::trim(command);
2014-03-20 12:46:11 +01:00
LOG_PRINT_L2("Read command: " << command);
if (command.empty())
{
continue;
}
else if(cmd_handler(command))
{
continue;
}
else if(0 == command.compare("exit") || 0 == command.compare("q"))
{
continue_handle = false;
}
else
{
#ifdef HAVE_READLINE
rdln::suspend_readline pause_readline;
#endif
std::cout << "unknown command: " << command << std::endl;
std::cout << usage;
}
}
catch (const std::exception &ex)
2014-03-20 12:46:11 +01:00
{
LOG_ERROR("Exception at [console_handler], what=" << ex.what());
2014-03-03 23:07:58 +01:00
}
}
if (exit_handler)
exit_handler();
2014-03-20 12:46:11 +01:00
return true;
2014-03-03 23:07:58 +01:00
}
2014-03-20 12:46:11 +01:00
private:
async_stdin_reader m_stdin_reader;
std::atomic<bool> m_running = {true};
std::function<std::string(void)> m_prompt;
2014-03-20 12:46:11 +01:00
};
2014-03-03 23:07:58 +01:00
template<class t_server, class t_handler>
2014-03-20 12:46:11 +01:00
bool start_default_console(t_server* ptsrv, t_handler handlr, const std::string& prompt, const std::string& usage = "")
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
std::shared_ptr<async_console_handler> console_handler = std::make_shared<async_console_handler>();
2014-04-07 17:02:15 +02:00
boost::thread([=](){console_handler->run<t_server, t_handler>(ptsrv, handlr, prompt, usage);}).detach();
2014-03-03 23:07:58 +01:00
return true;
}
template<class t_server>
2014-03-20 12:46:11 +01:00
bool start_default_console(t_server* ptsrv, const std::string& prompt, const std::string& usage = "")
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
return start_default_console(ptsrv, empty_commands_handler<t_server>, prompt, usage);
2014-03-03 23:07:58 +01:00
}
template<class t_server, class t_handler>
bool no_srv_param_adapter(t_server* ptsrv, const std::string& cmd, t_handler handlr)
{
return handlr(cmd);
}
template<class t_server, class t_handler>
2014-03-20 12:46:11 +01:00
bool run_default_console_handler_no_srv_param(t_server* ptsrv, t_handler handlr, const std::string& prompt, const std::string& usage = "")
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
async_console_handler console_handler;
return console_handler.run(ptsrv, boost::bind<bool>(no_srv_param_adapter<t_server, t_handler>, _1, _2, handlr), prompt, usage);
2014-03-03 23:07:58 +01:00
}
template<class t_server, class t_handler>
2014-03-20 12:46:11 +01:00
bool start_default_console_handler_no_srv_param(t_server* ptsrv, t_handler handlr, const std::string& prompt, const std::string& usage = "")
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
boost::thread( boost::bind(run_default_console_handler_no_srv_param<t_server, t_handler>, ptsrv, handlr, prompt, usage) );
2014-03-03 23:07:58 +01:00
return true;
}
/*template<class a>
bool f(int i, a l)
{
return true;
}*/
/*
template<class chain_handler>
bool default_console_handler2(chain_handler ch_handler, const std::string usage)
*/
/*template<class t_handler>
bool start_default_console2(t_handler handlr, const std::string& usage = "")
{
//std::string usage_local = usage;
boost::thread( boost::bind(default_console_handler2<t_handler>, handlr, usage) );
//boost::function<bool ()> p__ = boost::bind(f<t_handler>, 1, handlr);
//boost::function<bool ()> p__ = boost::bind(default_console_handler2<t_handler>, handlr, usage);
//boost::thread tr(p__);
return true;
}*/
class command_handler {
2014-03-20 12:46:11 +01:00
public:
typedef boost::function<bool (const std::vector<std::string> &)> callback;
typedef std::map<std::string, std::pair<callback, std::string> > lookup;
2014-03-03 23:07:58 +01:00
std::string get_usage()
{
std::stringstream ss;
size_t max_command_len = 0;
for(auto& x:m_command_handlers)
if(x.first.size() > max_command_len)
max_command_len = x.first.size();
2014-03-20 12:46:11 +01:00
2014-03-03 23:07:58 +01:00
for(auto& x:m_command_handlers)
{
ss.width(max_command_len + 3);
ss << std::left << x.first << x.second.second << ENDL;
}
return ss.str();
}
void set_handler(const std::string& cmd, const callback& hndlr, const std::string& usage = "")
2014-03-03 23:07:58 +01:00
{
lookup::mapped_type & vt = m_command_handlers[cmd];
2014-03-03 23:07:58 +01:00
vt.first = hndlr;
vt.second = usage;
#ifdef HAVE_READLINE
rdln::readline_buffer::add_completion(cmd);
#endif
2014-03-03 23:07:58 +01:00
}
2014-03-03 23:07:58 +01:00
bool process_command_vec(const std::vector<std::string>& cmd)
{
if(!cmd.size())
return false;
auto it = m_command_handlers.find(cmd.front());
if(it == m_command_handlers.end())
return false;
std::vector<std::string> cmd_local(cmd.begin()+1, cmd.end());
return it->second.first(cmd_local);
}
bool process_command_str(const std::string& cmd)
{
std::vector<std::string> cmd_v;
boost::split(cmd_v,cmd,boost::is_any_of(" "), boost::token_compress_on);
return process_command_vec(cmd_v);
}
private:
lookup m_command_handlers;
};
2014-03-03 23:07:58 +01:00
/************************************************************************/
/* */
/************************************************************************/
class console_handlers_binder : public command_handler
{
typedef command_handler::callback console_command_handler;
typedef command_handler::lookup command_handlers_map;
std::unique_ptr<boost::thread> m_console_thread;
async_console_handler m_console_handler;
public:
bool start_handling(std::function<std::string(void)> prompt, const std::string& usage_string = "", std::function<void(void)> exit_handler = NULL)
2014-03-03 23:07:58 +01:00
{
m_console_thread.reset(new boost::thread(boost::bind(&console_handlers_binder::run_handling, this, prompt, usage_string, exit_handler)));
2014-03-20 12:46:11 +01:00
m_console_thread->detach();
2014-03-03 23:07:58 +01:00
return true;
}
bool start_handling(const std::string &prompt, const std::string& usage_string = "", std::function<void(void)> exit_handler = NULL)
{
return start_handling([prompt](){ return prompt; }, usage_string, exit_handler);
}
2014-03-03 23:07:58 +01:00
2014-03-20 12:46:11 +01:00
void stop_handling()
2014-03-03 23:07:58 +01:00
{
2014-03-20 12:46:11 +01:00
m_console_handler.stop();
2014-03-03 23:07:58 +01:00
}
bool run_handling(std::function<std::string(void)> prompt, const std::string& usage_string, std::function<void(void)> exit_handler = NULL)
2014-03-03 23:07:58 +01:00
{
return m_console_handler.run(boost::bind(&console_handlers_binder::process_command_str, this, _1), prompt, usage_string, exit_handler);
2014-03-03 23:07:58 +01:00
}
void print_prompt()
{
m_console_handler.print_prompt();
}
2014-03-03 23:07:58 +01:00
};
///* work around because of broken boost bind */
//template<class t_server>
//class srv_console_handlers_binder: public command_handler
//{
// async_console_handler m_console_handler;
//public:
// bool start_handling(t_server* psrv, const std::string& prompt, const std::string& usage_string = "")
// {
// boost::thread(boost::bind(&srv_console_handlers_binder<t_server>::run_handling, this, psrv, prompt, usage_string)).detach();
// return true;
// }
// bool run_handling(t_server* psrv, const std::string& prompt, const std::string& usage_string)
// {
// return m_console_handler.run(psrv, boost::bind(&srv_console_handlers_binder<t_server>::process_command_str, this, _1, _2), prompt, usage_string);
// }
// void stop_handling()
// {
// m_console_handler.stop();
// }
//private:
// bool process_command_str(t_server* /*psrv*/, const std::string& cmd)
// {
// return console_handlers_binder::process_command_str(cmd);
// }
//};
2014-03-03 23:07:58 +01:00
}