blob: 3805dbc452a60b311897ab617bde8c8070feab91 [file] [log] [blame]
Jan Kundrátdc2b0722018-03-02 14:13:37 +01001/*
2 * Copyright (C) 2018 CESNET, https://photonics.cesnet.cz/
Jan Kundráta2740442018-03-22 16:56:43 +01003 * Copyright (C) 2018 FIT CVUT, https://fit.cvut.cz/
Jan Kundrátdc2b0722018-03-02 14:13:37 +01004 *
Václav Kubernát624a8872018-03-02 17:28:47 +01005 * Written by Václav Kubernát <kubervac@fit.cvut.cz>
Jan Kundrátdc2b0722018-03-02 14:13:37 +01006 *
7*/
Václav Kubernátfd261162020-11-12 02:36:29 +01008#include <atomic>
Václav Kubernát2bed9522020-12-01 03:37:41 +01009#include <boost/algorithm/string.hpp>
Jan Kundrátdc2b0722018-03-02 14:13:37 +010010#include <docopt.h>
Václav Kubernát624a8872018-03-02 17:28:47 +010011#include <iostream>
Václav Kubernát435706e2019-02-20 18:05:59 +010012#include <optional>
Václav Kubernáta395d332019-02-13 16:49:20 +010013#include <replxx.hxx>
Václav Kubernát90de9502019-11-20 17:19:44 +010014#include <sstream>
Jan Kundrátdc2b0722018-03-02 14:13:37 +010015#include "NETCONF_CLI_VERSION.h"
Václav Kubernát96344a12018-05-28 16:33:39 +020016#include "interpreter.hpp"
Václav Kubernát48e9dfa2020-07-08 10:55:12 +020017#include "proxy_datastore.hpp"
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010018#include "yang_schema.hpp"
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010019#if defined(SYSREPO_CLI)
Václav Kubernát6415b822018-08-22 17:40:01 +020020#include "sysrepo_access.hpp"
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010021#define PROGRAM_NAME "sysrepo-cli"
Václav Kubernát715c85c2020-04-14 01:46:08 +020022static const auto usage = R"(CLI interface to sysrepo
23
24Usage:
25 sysrepo-cli [-d <datastore>]
26 sysrepo-cli (-h | --help)
27 sysrepo-cli --version
28
29Options:
30 -d <datastore> can be "running" or "startup" [default: running])";
Václav Kubernát74487df2020-06-04 01:29:28 +020031#elif defined(YANG_CLI)
32#include <boost/spirit/home/x3.hpp>
Václav Kubernát619e6542020-06-29 14:13:43 +020033#include <filesystem>
Václav Kubernát74487df2020-06-04 01:29:28 +020034#include "yang_access.hpp"
35#define PROGRAM_NAME "yang-cli"
36static const auto usage = R"(CLI interface for creating local YANG data instances
37
Václav Kubernát619e6542020-06-29 14:13:43 +020038 The <schema_file_or_module_name> argument is treated as a file name if a file
39 with such a path exists, otherwise it's treated as a module name. Search dirs
40 will be used to find a schema for that module.
41
Václav Kubernát74487df2020-06-04 01:29:28 +020042Usage:
Václav Kubernát28cf3362020-06-29 17:52:51 +020043 yang-cli [--configonly] [-s <search_dir>] [-e enable_features]... [-i data_file]... <schema_file_or_module_name>...
Václav Kubernát74487df2020-06-04 01:29:28 +020044 yang-cli (-h | --help)
45 yang-cli --version
46
47Options:
48 -s <search_dir> Set search for schema lookup
Václav Kubernát548cb192020-06-26 14:00:42 +020049 -e <enable_features> Feature to enable after modules are loaded. This option can be supplied more than once. Format: <module_name>:<feature>
Václav Kubernát28cf3362020-06-29 17:52:51 +020050 -i <data_file> File to import data from
51 --configonly Disable editing of operational data)";
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010052#elif defined(NETCONF_CLI)
53// FIXME: improve usage
54static const auto usage = R"(CLI interface for NETCONF
55
56Usage:
57 netconf-cli [-v] [-p <port>] <host>
Jan Kundrát1ccf0d42021-02-05 09:09:57 +010058 netconf-cli [-v] --socket <path>
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010059 netconf-cli (-h | --help)
60 netconf-cli --version
61
62Options:
63 -v enable verbose mode
64 -p <port> port number [default: 830]
65)";
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010066#include "cli-netconf.hpp"
Václav Kubernátb4e5b182020-11-16 19:55:09 +010067#include "netconf_access.hpp"
Jan Kundrát9435bc02021-01-04 18:03:01 +010068#define PROGRAM_NAME "netconf-cli"
Václav Kubernátfd261162020-11-12 02:36:29 +010069// FIXME: this should be replaced by C++20 std::jthread at some point
70struct PoorMansJThread {
71 ~PoorMansJThread()
72 {
73 if (thread.joinable()) {
74 thread.join();
75 }
76 }
77 std::thread thread;
78};
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010079#else
80#error "Unknown CLI backend"
81#endif
Jan Kundrátdc2b0722018-03-02 14:13:37 +010082
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010083const auto HISTORY_FILE_NAME = PROGRAM_NAME "_history";
84
Jan Kundrátdc2b0722018-03-02 14:13:37 +010085int main(int argc, char* argv[])
86{
87 auto args = docopt::docopt(usage,
88 {argv + 1, argv + argc},
89 true,
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010090 PROGRAM_NAME " " NETCONF_CLI_VERSION,
Jan Kundrátdc2b0722018-03-02 14:13:37 +010091 true);
Václav Kubernát28cf3362020-06-29 17:52:51 +020092 WritableOps writableOps = WritableOps::No;
Václav Kubernátff2c9f62018-05-16 20:26:31 +020093
Václav Kubernátfd261162020-11-12 02:36:29 +010094 using replxx::Replxx;
95 Replxx lineEditor;
96 std::atomic<int> backendReturnCode = 0;
97
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010098#if defined(SYSREPO_CLI)
Václav Kubernát715c85c2020-04-14 01:46:08 +020099 auto datastoreType = Datastore::Running;
100 if (const auto& ds = args["-d"]) {
101 if (ds.asString() == "startup") {
102 datastoreType = Datastore::Startup;
103 } else if (ds.asString() == "running") {
104 datastoreType = Datastore::Running;
105 } else {
Václav Kubernátb4e5b182020-11-16 19:55:09 +0100106 std::cerr << PROGRAM_NAME << ": unknown datastore: " << ds.asString() << "\n";
Václav Kubernát715c85c2020-04-14 01:46:08 +0200107 return 1;
108 }
109 }
Václav Kubernát654303f2020-07-31 13:16:54 +0200110 auto datastore = std::make_shared<SysrepoAccess>(datastoreType);
Václav Kubernát715c85c2020-04-14 01:46:08 +0200111 std::cout << "Connected to sysrepo [datastore: " << (datastoreType == Datastore::Startup ? "startup" : "running") << "]" << std::endl;
Václav Kubernát74487df2020-06-04 01:29:28 +0200112#elif defined(YANG_CLI)
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200113 auto datastore = std::make_shared<YangAccess>();
Václav Kubernát28cf3362020-06-29 17:52:51 +0200114 if (args["--configonly"].asBool()) {
115 writableOps = WritableOps::No;
116 } else {
117 writableOps = WritableOps::Yes;
118 std::cout << "ops is writable" << std::endl;
119 }
Václav Kubernát74487df2020-06-04 01:29:28 +0200120 if (const auto& search_dir = args["-s"]) {
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200121 datastore->addSchemaDir(search_dir.asString());
Václav Kubernát74487df2020-06-04 01:29:28 +0200122 }
Václav Kubernát619e6542020-06-29 14:13:43 +0200123 for (const auto& schemaFile : args["<schema_file_or_module_name>"].asStringList()) {
124 if (std::filesystem::exists(schemaFile)) {
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200125 datastore->addSchemaFile(schemaFile);
Václav Kubernát619e6542020-06-29 14:13:43 +0200126 } else if (schemaFile.find('/') == std::string::npos) { // Module names cannot have a slash
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200127 datastore->loadModule(schemaFile);
Václav Kubernát619e6542020-06-29 14:13:43 +0200128 } else {
129 std::cerr << "Cannot load YANG module " << schemaFile << "\n";
130 }
Václav Kubernát74487df2020-06-04 01:29:28 +0200131 }
132 if (const auto& enableFeatures = args["-e"]) {
133 namespace x3 = boost::spirit::x3;
134 auto grammar = +(x3::char_-":") >> ":" >> +(x3::char_-":");
135 for (const auto& enableFeature : enableFeatures.asStringList()) {
136 std::pair<std::string, std::string> parsed;
137 auto it = enableFeature.begin();
138 auto res = x3::parse(it, enableFeature.cend(), grammar, parsed);
139 if (!res || it != enableFeature.cend()) {
140 std::cerr << "Error parsing feature enable flags: " << enableFeature << "\n";
141 return 1;
142 }
143 try {
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200144 datastore->enableFeature(parsed.first, parsed.second);
Václav Kubernát74487df2020-06-04 01:29:28 +0200145 } catch (std::runtime_error& ex) {
146 std::cerr << ex.what() << "\n";
147 return 1;
148 }
Václav Kubernát74487df2020-06-04 01:29:28 +0200149 }
150 }
Václav Kubernát548cb192020-06-26 14:00:42 +0200151 if (const auto& dataFiles = args["-i"]) {
152 for (const auto& dataFile : dataFiles.asStringList()) {
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200153 datastore->addDataFile(dataFile);
Václav Kubernát548cb192020-06-26 14:00:42 +0200154 }
155 }
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100156#elif defined(NETCONF_CLI)
157 auto verbose = args.at("-v").asBool();
158 if (verbose) {
159 NetconfAccess::setNcLogLevel(NC_VERB_DEBUG);
160 }
161
162 SshProcess process;
Václav Kubernátfd261162020-11-12 02:36:29 +0100163 PoorMansJThread processWatcher;
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100164 std::shared_ptr<NetconfAccess> datastore;
165
Jan Kundrát1ccf0d42021-02-05 09:09:57 +0100166 if (args.at("--socket").asBool()) {
167 try {
168 datastore = std::make_shared<NetconfAccess>(args.at("<path>").asString());
169 } catch (std::runtime_error& ex) {
170 std::cerr << "UNIX socket connection failed: " << ex.what() << std::endl;
171 return 1;
172 }
173 } else {
174 try {
175 process = sshProcess(args.at("<host>").asString(), args.at("-p").asString());
176 processWatcher.thread = std::thread{std::thread{[&process, &lineEditor, &backendReturnCode] () {
177 process.process.wait();
178 backendReturnCode = process.process.exit_code();
179 // CTRL-U clears from the cursor to the start of the line
180 // CTRL-K clears from the cursor to the end of the line
181 // CTRL-D send EOF
182 lineEditor.emulate_key_press(replxx::Replxx::KEY::control('U'));
183 lineEditor.emulate_key_press(replxx::Replxx::KEY::control('K'));
184 lineEditor.emulate_key_press(replxx::Replxx::KEY::control('D'));
185 }}};
186 datastore = std::make_shared<NetconfAccess>(process.std_out.native_source(), process.std_in.native_sink());
187 } catch (std::runtime_error& ex) {
188 std::cerr << "SSH connection failed: " << ex.what() << std::endl;
189 return 1;
190 }
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100191 }
Václav Kubernátb79f3ca2020-02-04 15:56:01 +0100192#else
193#error "Unknown CLI backend"
194#endif
195
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100196#if defined(SYSREPO_CLI) || defined(NETCONF_CLI)
Václav Kubernáte7248b22020-06-26 15:38:59 +0200197 auto createTemporaryDatastore = [](const std::shared_ptr<DatastoreAccess>& datastore) {
198 return std::make_shared<YangAccess>(std::static_pointer_cast<YangSchema>(datastore->schema()));
199 };
200#elif defined(YANG_CLI)
201 auto createTemporaryDatastore = [](const std::shared_ptr<DatastoreAccess>&) {
202 return nullptr;
203 };
204#endif
205
206 ProxyDatastore proxyDatastore(datastore, createTemporaryDatastore);
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200207 auto dataQuery = std::make_shared<DataQuery>(*datastore);
208 Parser parser(datastore->schema(), writableOps, dataQuery);
Václav Kubernát395d92c2020-01-24 12:18:18 +0100209
Václav Kubernátb4e5b182020-11-16 19:55:09 +0100210 lineEditor.bind_key(Replxx::KEY::meta(Replxx::KEY::BACKSPACE), [&lineEditor](const auto& code) {
Václav Kubernát48637292020-07-08 16:54:13 +0200211 return lineEditor.invoke(Replxx::ACTION::KILL_TO_BEGINING_OF_WORD, code);
212 });
Václav Kubernátb4e5b182020-11-16 19:55:09 +0100213 lineEditor.bind_key(Replxx::KEY::control('W'), [&lineEditor](const auto& code) {
Václav Kubernát48637292020-07-08 16:54:13 +0200214 return lineEditor.invoke(Replxx::ACTION::KILL_TO_WHITESPACE_ON_LEFT, code);
215 });
Václav Kubernát395d92c2020-01-24 12:18:18 +0100216
217 lineEditor.set_word_break_characters("\t _[]/:'\"=-%");
218
Václav Kubernát1ed4aa32020-01-23 13:13:28 +0100219 lineEditor.set_completion_callback([&parser](const std::string& input, int& context) {
Václav Kubernáta395d332019-02-13 16:49:20 +0100220 std::stringstream stream;
Václav Kubernát1ed4aa32020-01-23 13:13:28 +0100221 auto completions = parser.completeCommand(input, stream);
Václav Kubernáta395d332019-02-13 16:49:20 +0100222
Jan Kundrát8d8efe82019-10-18 10:21:36 +0200223 std::vector<replxx::Replxx::Completion> res;
Václav Kubernát1ed4aa32020-01-23 13:13:28 +0100224 std::copy(completions.m_completions.begin(), completions.m_completions.end(), std::back_inserter(res));
225 context = completions.m_contextLength;
Václav Kubernáta395d332019-02-13 16:49:20 +0100226 return res;
227 });
Václav Kubernát2b684612018-08-09 18:55:24 +0200228
Václav Kubernát435706e2019-02-20 18:05:59 +0100229 std::optional<std::string> historyFile;
230 if (auto xdgHome = getenv("XDG_DATA_HOME")) {
231 historyFile = std::string(xdgHome) + "/" + HISTORY_FILE_NAME;
232 } else if (auto home = getenv("HOME")) {
233 historyFile = std::string(home) + "/.local/share/" + HISTORY_FILE_NAME;
234 }
235
Václav Kubernát3a433232020-07-08 17:52:50 +0200236 if (historyFile) {
Václav Kubernát435706e2019-02-20 18:05:59 +0100237 lineEditor.history_load(historyFile.value());
Václav Kubernát3a433232020-07-08 17:52:50 +0200238 }
Václav Kubernát435706e2019-02-20 18:05:59 +0100239
Václav Kubernátfd261162020-11-12 02:36:29 +0100240 while (backendReturnCode == 0) {
Václav Kubernát2bed9522020-12-01 03:37:41 +0100241 auto fullContextPath = parser.currentNode();
242 std::string prompt;
243 if (auto activeRpcPath = proxyDatastore.inputDatastorePath()) {
244 auto rpcPrefixLength = activeRpcPath->size();
245 prompt = "(prepare: " + *activeRpcPath + ") " + fullContextPath.substr(rpcPrefixLength);
246 } else {
247 prompt = fullContextPath;
248 }
249
250 prompt += "> ";
251
252 auto line = lineEditor.input(prompt);
Václav Kubernáta395d332019-02-13 16:49:20 +0100253 if (!line) {
Václav Kubernát82bf1312019-11-05 11:19:26 +0100254 // If user pressed CTRL-C to abort the line, errno gets set to EAGAIN.
255 // If user pressed CTRL-D (for EOF), errno doesn't get set to EAGAIN, so we exit the program.
256 // I have no idea why replxx uses errno for this.
257 if (errno == EAGAIN) {
258 continue;
259 } else {
260 break;
261 }
Václav Kubernát5b80e522019-01-25 12:17:03 +0100262 }
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200263
Jan Kundráte3877022018-09-05 15:32:09 +0200264 std::locale C_locale("C");
Václav Kubernáta395d332019-02-13 16:49:20 +0100265 std::string_view view{line};
266 if (std::all_of(view.begin(), view.end(),
Jan Kundráte3877022018-09-05 15:32:09 +0200267 [C_locale](const auto c) { return std::isspace(c, C_locale);})) {
268 continue;
269 }
270
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200271 try {
Václav Kubernát5b80e522019-01-25 12:17:03 +0100272 command_ cmd = parser.parseCommand(line, std::cout);
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200273 boost::apply_visitor(Interpreter(parser, proxyDatastore), cmd);
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200274 } catch (InvalidCommandException& ex) {
275 std::cerr << ex.what() << std::endl;
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200276 } catch (DatastoreException& ex) {
277 std::cerr << ex.what() << std::endl;
Václav Kubernáte7248b22020-06-26 15:38:59 +0200278 } catch (std::runtime_error& ex) {
279 std::cerr << ex.what() << std::endl;
Václav Kubernát160e5a22020-12-01 01:11:28 +0100280 } catch (std::logic_error& ex) {
281 std::cerr << ex.what() << std::endl;
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200282 }
Václav Kubernát5b80e522019-01-25 12:17:03 +0100283
Václav Kubernáta395d332019-02-13 16:49:20 +0100284 lineEditor.history_add(line);
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200285 }
286
Václav Kubernát3a433232020-07-08 17:52:50 +0200287 if (historyFile) {
Václav Kubernát435706e2019-02-20 18:05:59 +0100288 lineEditor.history_save(historyFile.value());
Václav Kubernát3a433232020-07-08 17:52:50 +0200289 }
Václav Kubernát435706e2019-02-20 18:05:59 +0100290
Václav Kubernátfd261162020-11-12 02:36:29 +0100291 return backendReturnCode;
Jan Kundrátdc2b0722018-03-02 14:13:37 +0100292}