icinga2/lib/cli/consolecommand.cpp

344 lines
8.8 KiB
C++
Raw Normal View History

2014-11-23 12:35:13 +01:00
/******************************************************************************
* Icinga 2 *
2015-01-22 12:00:23 +01:00
* Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
2014-11-23 12:35:13 +01:00
* *
* 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 St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
#include "cli/consolecommand.hpp"
2014-11-23 12:35:13 +01:00
#include "config/configcompiler.hpp"
#include "base/json.hpp"
#include "base/console.hpp"
#include "base/application.hpp"
#include "base/objectlock.hpp"
#include "base/unixsocket.hpp"
#include "base/utility.hpp"
#include "base/networkstream.hpp"
#include "base/exception.hpp"
2014-11-23 12:35:13 +01:00
#include <iostream>
#ifdef HAVE_EDITLINE
#include "cli/editline.hpp"
#endif /* HAVE_EDITLINE */
2014-11-23 12:35:13 +01:00
using namespace icinga;
namespace po = boost::program_options;
static ScriptFrame *l_ScriptFrame;
REGISTER_CLICOMMAND("console", ConsoleCommand);
2014-11-23 12:35:13 +01:00
String ConsoleCommand::GetDescription(void) const
2014-11-23 12:35:13 +01:00
{
return "Interprets Icinga script expressions.";
}
String ConsoleCommand::GetShortDescription(void) const
2014-11-23 12:35:13 +01:00
{
return "Icinga console";
2014-11-23 12:35:13 +01:00
}
ImpersonationLevel ConsoleCommand::GetImpersonationLevel(void) const
{
return ImpersonateNone;
}
void ConsoleCommand::InitParameters(boost::program_options::options_description& visibleDesc,
2014-11-23 12:35:13 +01:00
boost::program_options::options_description& hiddenDesc) const
{
visibleDesc.add_options()
("connect,c", po::value<std::string>(), "connect to an Icinga 2 instance")
("sandbox", "enable sandbox mode")
;
2014-11-23 12:35:13 +01:00
}
#ifdef HAVE_EDITLINE
static void AddSuggestion(std::vector<String>& matches, const String& word, const String& suggestion)
{
if (suggestion.Find(word) != 0)
return;
matches.push_back(suggestion);
}
static char *ConsoleCompleteHelper(const char *word, int state)
{
static std::vector<String> matches;
String aword = word;
if (state == 0) {
matches.clear();
BOOST_FOREACH(const String& keyword, ConfigCompiler::GetKeywords()) {
AddSuggestion(matches, word, keyword);
}
{
ObjectLock olock(l_ScriptFrame->Locals);
BOOST_FOREACH(const Dictionary::Pair& kv, l_ScriptFrame->Locals) {
AddSuggestion(matches, word, kv.first);
}
}
{
ObjectLock olock(ScriptGlobal::GetGlobals());
BOOST_FOREACH(const Dictionary::Pair& kv, ScriptGlobal::GetGlobals()) {
AddSuggestion(matches, word, kv.first);
}
}
String::SizeType cperiod = aword.RFind(".");
if (cperiod != -1) {
String pword = aword.SubStr(0, cperiod);
Value value;
try {
Expression *expr = ConfigCompiler::CompileText("temp", pword);
if (expr)
value = expr->Evaluate(*l_ScriptFrame);
if (value.IsObjectType<Dictionary>()) {
Dictionary::Ptr dict = value;
ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
AddSuggestion(matches, word, pword + "." + kv.first);
}
}
Type::Ptr type = value.GetReflectionType();
for (int i = 0; i < type->GetFieldCount(); i++) {
Field field = type->GetFieldInfo(i);
AddSuggestion(matches, word, pword + "." + field.Name);
}
while (type) {
Object::Ptr prototype = type->GetPrototype();
Dictionary::Ptr dict = dynamic_pointer_cast<Dictionary>(prototype);
if (dict) {
ObjectLock olock(dict);
BOOST_FOREACH(const Dictionary::Pair& kv, dict) {
AddSuggestion(matches, word, pword + "." + kv.first);
}
}
type = type->GetBaseType();
}
} catch (...) { /* Ignore the exception */ }
}
}
if (state >= matches.size())
return NULL;
return strdup(matches[state].CStr());
}
#endif /* HAVE_EDITLINE */
2014-11-23 12:35:13 +01:00
/**
* The entry point for the "console" CLI command.
2014-11-23 12:35:13 +01:00
*
* @returns An exit status.
*/
int ConsoleCommand::Run(const po::variables_map& vm, const std::vector<std::string>& ap) const
2014-11-23 12:35:13 +01:00
{
std::map<String, String> lines;
int next_line = 1;
2014-11-23 12:35:13 +01:00
#ifdef HAVE_EDITLINE
rl_completion_entry_function = ConsoleCompleteHelper;
rl_completion_append_character = '\0';
#endif /* HAVE_EDITLINE */
String addr, session;
ScriptFrame scriptFrame;
l_ScriptFrame = &scriptFrame;
if (vm.count("connect")) {
addr = vm["connect"].as<std::string>();
session = Utility::NewUniqueID();
}
if (vm.count("sandbox")) {
if (vm.count("connect")) {
Log(LogCritical, "ConsoleCommand", "Sandbox mode cannot be used together with --connect.");
return EXIT_FAILURE;
}
scriptFrame.Sandboxed = true;
}
std::cout << "Icinga (version: " << Application::GetAppVersion() << ")\n";
2014-11-23 12:35:13 +01:00
while (std::cin.good()) {
String fileName = "<" + Convert::ToString(next_line) + ">";
next_line++;
bool continuation = false;
std::string command;
incomplete:
#ifdef HAVE_EDITLINE
std::ostringstream promptbuf;
std::ostream& os = promptbuf;
#else /* HAVE_EDITLINE */
std::ostream& os = std::cout;
#endif /* HAVE_EDITLINE */
os << fileName;
if (!continuation)
os << " => ";
else
os << " .. ";
#ifdef HAVE_EDITLINE
String prompt = promptbuf.str();
char *cline;
cline = readline(prompt.CStr());
if (!cline)
break;
add_history(cline);
std::string line = cline;
2014-11-23 12:35:13 +01:00
free(cline);
#else /* HAVE_EDITLINE */
2014-11-23 12:35:13 +01:00
std::string line;
std::getline(std::cin, line);
#endif /* HAVE_EDITLINE */
2014-11-23 12:35:13 +01:00
if (!command.empty())
command += "\n";
command += line;
if (addr.IsEmpty()) {
Expression *expr = NULL;
try {
lines[fileName] = command;
2014-11-23 12:35:13 +01:00
expr = ConfigCompiler::CompileText(fileName, command);
if (expr) {
Value result = expr->Evaluate(scriptFrame);
std::cout << ConsoleColorTag(Console_ForegroundCyan);
if (!result.IsObject() || result.IsObjectType<Array>() || result.IsObjectType<Dictionary>())
std::cout << JsonEncode(result);
else
std::cout << result;
std::cout << ConsoleColorTag(Console_Normal) << "\n";
}
} catch (const ScriptError& ex) {
if (ex.IsIncompleteExpression()) {
continuation = true;
goto incomplete;
}
DebugInfo di = ex.GetDebugInfo();
if (lines.find(di.Path) != lines.end()) {
String text = lines[di.Path];
std::vector<String> ulines;
boost::algorithm::split(ulines, text, boost::is_any_of("\n"));
for (int i = 1; i <= ulines.size(); i++) {
int start, len;
if (i == di.FirstLine)
start = di.FirstColumn;
else
start = 0;
if (i == di.LastLine)
len = di.LastColumn - di.FirstColumn + 1;
else
len = ulines[i - 1].GetLength();
int offset;
if (di.Path != fileName) {
std::cout << di.Path << ": " << ulines[i - 1] << "\n";
offset = 2;
} else
offset = 4;
if (i >= di.FirstLine && i <= di.LastLine) {
std::cout << String(di.Path.GetLength() + offset, ' ');
std::cout << String(start, ' ') << String(len, '^') << "\n";
}
}
} else {
ShowCodeFragment(std::cout, di);
}
std::cout << ex.what() << "\n";
} catch (const std::exception& ex) {
std::cout << "Error: " << DiagnosticInformation(ex) << "\n";
2014-11-23 12:35:13 +01:00
}
delete expr;
} else {
Socket::Ptr socket;
2014-12-16 21:25:58 +01:00
#ifndef _WIN32
if (addr.FindFirstOf("/") != String::NPos) {
UnixSocket::Ptr usocket = new UnixSocket();
usocket->Connect(addr);
socket = usocket;
} else {
2014-12-16 21:25:58 +01:00
#endif /* _WIN32 */
Log(LogCritical, "ConsoleCommand", "Sorry, TCP sockets aren't supported yet.");
return 1;
2014-12-16 21:25:58 +01:00
#ifndef _WIN32
2014-11-23 12:35:13 +01:00
}
2014-12-16 21:25:58 +01:00
#endif /* _WIN32 */
String query = "SCRIPT " + session + "\n" + line + "\n\n";
NetworkStream::Ptr ns = new NetworkStream(socket);
ns->Write(query.CStr(), query.GetLength());
2014-11-23 12:35:13 +01:00
String result;
char buf[1024];
while (!ns->IsEof()) {
size_t rc = ns->Read(buf, sizeof(buf), true);
result += String(buf, buf + rc);
}
if (result.GetLength() < 16) {
Log(LogCritical, "ConsoleCommand", "Received invalid response from Livestatus.");
continue;
}
std::cout << result.SubStr(16) << "\n";
}
2014-11-23 12:35:13 +01:00
}
return 0;
2014-11-23 12:35:13 +01:00
}