blob: 9827fa3591e65bff281543ee05c3d3769084a6a0 [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:
Václav Kubernátf5d75152020-12-03 03:52:34 +010025 sysrepo-cli [-d <datastore_target>]
Václav Kubernát715c85c2020-04-14 01:46:08 +020026 sysrepo-cli (-h | --help)
27 sysrepo-cli --version
28
29Options:
Václav Kubernátf5d75152020-12-03 03:52:34 +010030 -d <datastore_target> can be "running", "startup" or "operational" [default: operational])";
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át0c90dd42022-01-18 00:07:29 +010043 yang-cli [--configonly] [--ignore-unknown-data] [-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:
Václav Kubernát0c90dd42022-01-18 00:07:29 +010048 -s <search_dir> Set search for schema lookup
49 -e <enable_features> Feature to enable after modules are loaded. This option can be supplied more than once. Format: <module_name>:<feature>
50 -i <data_file> File to import data from
51 --configonly Disable editing of operational data
52 --ignore-unknown-data Silently ignore data with no available schema file)";
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010053#elif defined(NETCONF_CLI)
54// FIXME: improve usage
55static const auto usage = R"(CLI interface for NETCONF
56
57Usage:
Václav Kubernátf5d75152020-12-03 03:52:34 +010058 netconf-cli [-v] [-d <datastore_target>] [-p <port>] <host>
59 netconf-cli [-v] [-d <datastore_target>] --socket <path>
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010060 netconf-cli (-h | --help)
61 netconf-cli --version
62
63Options:
64 -v enable verbose mode
65 -p <port> port number [default: 830]
Václav Kubernátf5d75152020-12-03 03:52:34 +010066 -d <datastore_target> can be "running", "startup" or "operational" [default: operational])";
Václav Kubernáte2e15ee2020-02-05 17:38:13 +010067#include "cli-netconf.hpp"
Václav Kubernátb4e5b182020-11-16 19:55:09 +010068#include "netconf_access.hpp"
Jan Kundrát9435bc02021-01-04 18:03:01 +010069#define PROGRAM_NAME "netconf-cli"
Václav Kubernátfd261162020-11-12 02:36:29 +010070// FIXME: this should be replaced by C++20 std::jthread at some point
71struct PoorMansJThread {
72 ~PoorMansJThread()
73 {
74 if (thread.joinable()) {
75 thread.join();
76 }
77 }
78 std::thread thread;
79};
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010080#else
81#error "Unknown CLI backend"
82#endif
Jan Kundrátdc2b0722018-03-02 14:13:37 +010083
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010084const auto HISTORY_FILE_NAME = PROGRAM_NAME "_history";
85
Jan Kundrátdc2b0722018-03-02 14:13:37 +010086int main(int argc, char* argv[])
87{
88 auto args = docopt::docopt(usage,
89 {argv + 1, argv + argc},
90 true,
Václav Kubernátb79f3ca2020-02-04 15:56:01 +010091 PROGRAM_NAME " " NETCONF_CLI_VERSION,
Jan Kundrátdc2b0722018-03-02 14:13:37 +010092 true);
Václav Kubernát28cf3362020-06-29 17:52:51 +020093 WritableOps writableOps = WritableOps::No;
Václav Kubernátff2c9f62018-05-16 20:26:31 +020094
Václav Kubernátfd261162020-11-12 02:36:29 +010095 using replxx::Replxx;
96 Replxx lineEditor;
97 std::atomic<int> backendReturnCode = 0;
98
Václav Kubernátf5d75152020-12-03 03:52:34 +010099 // For some reason, GCC10 still needs [[maybe_unused]] because of conditional compilation...
100 [[maybe_unused]] auto datastoreTarget = DatastoreTarget::Operational;
Václav Kubernát715c85c2020-04-14 01:46:08 +0200101 if (const auto& ds = args["-d"]) {
102 if (ds.asString() == "startup") {
Václav Kubernátf5d75152020-12-03 03:52:34 +0100103 datastoreTarget = DatastoreTarget::Startup;
Václav Kubernát715c85c2020-04-14 01:46:08 +0200104 } else if (ds.asString() == "running") {
Václav Kubernátf5d75152020-12-03 03:52:34 +0100105 datastoreTarget = DatastoreTarget::Running;
106 } else if (ds.asString() == "operational") {
107 datastoreTarget = DatastoreTarget::Operational;
Václav Kubernát715c85c2020-04-14 01:46:08 +0200108 } else {
Václav Kubernátf5d75152020-12-03 03:52:34 +0100109 std::cerr << PROGRAM_NAME << ": unknown datastore target: " << ds.asString() << "\n";
Václav Kubernát715c85c2020-04-14 01:46:08 +0200110 return 1;
111 }
112 }
Václav Kubernátf5d75152020-12-03 03:52:34 +0100113
114 auto datastoreTargetString = args["-d"] ? args["-d"].asString() : std::string("operational");
115
116#if defined(SYSREPO_CLI)
117 auto datastore = std::make_shared<SysrepoAccess>();
118 std::cout << "Connected to sysrepo [datastore target: " << datastoreTargetString << "]" << std::endl;
Václav Kubernát74487df2020-06-04 01:29:28 +0200119#elif defined(YANG_CLI)
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200120 auto datastore = std::make_shared<YangAccess>();
Václav Kubernát28cf3362020-06-29 17:52:51 +0200121 if (args["--configonly"].asBool()) {
122 writableOps = WritableOps::No;
123 } else {
124 writableOps = WritableOps::Yes;
125 std::cout << "ops is writable" << std::endl;
126 }
Václav Kubernát74487df2020-06-04 01:29:28 +0200127 if (const auto& search_dir = args["-s"]) {
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200128 datastore->addSchemaDir(search_dir.asString());
Václav Kubernát74487df2020-06-04 01:29:28 +0200129 }
Václav Kubernát619e6542020-06-29 14:13:43 +0200130 for (const auto& schemaFile : args["<schema_file_or_module_name>"].asStringList()) {
131 if (std::filesystem::exists(schemaFile)) {
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200132 datastore->addSchemaFile(schemaFile);
Václav Kubernát619e6542020-06-29 14:13:43 +0200133 } else if (schemaFile.find('/') == std::string::npos) { // Module names cannot have a slash
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200134 datastore->loadModule(schemaFile);
Václav Kubernát619e6542020-06-29 14:13:43 +0200135 } else {
136 std::cerr << "Cannot load YANG module " << schemaFile << "\n";
137 }
Václav Kubernát74487df2020-06-04 01:29:28 +0200138 }
139 if (const auto& enableFeatures = args["-e"]) {
140 namespace x3 = boost::spirit::x3;
Václav Kubernátcfdb9222021-07-07 22:36:24 +0200141 std::map<std::string, std::vector<std::string>> toEnable;
Václav Kubernát74487df2020-06-04 01:29:28 +0200142 auto grammar = +(x3::char_-":") >> ":" >> +(x3::char_-":");
143 for (const auto& enableFeature : enableFeatures.asStringList()) {
144 std::pair<std::string, std::string> parsed;
145 auto it = enableFeature.begin();
146 auto res = x3::parse(it, enableFeature.cend(), grammar, parsed);
147 if (!res || it != enableFeature.cend()) {
148 std::cerr << "Error parsing feature enable flags: " << enableFeature << "\n";
149 return 1;
150 }
Václav Kubernátcfdb9222021-07-07 22:36:24 +0200151 toEnable[parsed.first].emplace_back(parsed.second);
152 }
153 try {
154 for (const auto& [moduleName, features] : toEnable) {
155 datastore->setEnabledFeatures(moduleName, features);
Václav Kubernát74487df2020-06-04 01:29:28 +0200156 }
Václav Kubernátcfdb9222021-07-07 22:36:24 +0200157 } catch (std::runtime_error& ex) {
158 std::cerr << ex.what() << "\n";
159 return 1;
Václav Kubernát74487df2020-06-04 01:29:28 +0200160 }
161 }
Václav Kubernát0c90dd42022-01-18 00:07:29 +0100162
163 auto strict = args.at("--ignore-unknown-data").asBool() ? StrictDataParsing::No : StrictDataParsing::Yes;
164
Václav Kubernát548cb192020-06-26 14:00:42 +0200165 if (const auto& dataFiles = args["-i"]) {
166 for (const auto& dataFile : dataFiles.asStringList()) {
Václav Kubernát0c90dd42022-01-18 00:07:29 +0100167 datastore->addDataFile(dataFile, strict);
Václav Kubernát548cb192020-06-26 14:00:42 +0200168 }
169 }
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100170#elif defined(NETCONF_CLI)
171 auto verbose = args.at("-v").asBool();
172 if (verbose) {
Václav Kubernátbde37ba2022-03-25 15:18:12 +0100173 NetconfAccess::setNcLogLevel(libnetconf::LogLevel::Debug);
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100174 }
175
176 SshProcess process;
Václav Kubernátfd261162020-11-12 02:36:29 +0100177 PoorMansJThread processWatcher;
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100178 std::shared_ptr<NetconfAccess> datastore;
179
Jan Kundrát1ccf0d42021-02-05 09:09:57 +0100180 if (args.at("--socket").asBool()) {
181 try {
182 datastore = std::make_shared<NetconfAccess>(args.at("<path>").asString());
183 } catch (std::runtime_error& ex) {
184 std::cerr << "UNIX socket connection failed: " << ex.what() << std::endl;
185 return 1;
186 }
187 } else {
188 try {
189 process = sshProcess(args.at("<host>").asString(), args.at("-p").asString());
190 processWatcher.thread = std::thread{std::thread{[&process, &lineEditor, &backendReturnCode] () {
191 process.process.wait();
192 backendReturnCode = process.process.exit_code();
193 // CTRL-U clears from the cursor to the start of the line
194 // CTRL-K clears from the cursor to the end of the line
195 // CTRL-D send EOF
196 lineEditor.emulate_key_press(replxx::Replxx::KEY::control('U'));
197 lineEditor.emulate_key_press(replxx::Replxx::KEY::control('K'));
198 lineEditor.emulate_key_press(replxx::Replxx::KEY::control('D'));
199 }}};
200 datastore = std::make_shared<NetconfAccess>(process.std_out.native_source(), process.std_in.native_sink());
201 } catch (std::runtime_error& ex) {
202 std::cerr << "SSH connection failed: " << ex.what() << std::endl;
203 return 1;
204 }
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100205 }
Václav Kubernátf5d75152020-12-03 03:52:34 +0100206 std::cout << "Connected via NETCONF [datastore target: " << datastoreTargetString << "]" << std::endl;
Václav Kubernátb79f3ca2020-02-04 15:56:01 +0100207#else
208#error "Unknown CLI backend"
209#endif
210
Václav Kubernátf5d75152020-12-03 03:52:34 +0100211 datastore->setTarget(datastoreTarget);
212
Václav Kubernáte2e15ee2020-02-05 17:38:13 +0100213#if defined(SYSREPO_CLI) || defined(NETCONF_CLI)
Václav Kubernáte7248b22020-06-26 15:38:59 +0200214 auto createTemporaryDatastore = [](const std::shared_ptr<DatastoreAccess>& datastore) {
215 return std::make_shared<YangAccess>(std::static_pointer_cast<YangSchema>(datastore->schema()));
216 };
217#elif defined(YANG_CLI)
218 auto createTemporaryDatastore = [](const std::shared_ptr<DatastoreAccess>&) {
219 return nullptr;
220 };
221#endif
222
223 ProxyDatastore proxyDatastore(datastore, createTemporaryDatastore);
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200224 auto dataQuery = std::make_shared<DataQuery>(*datastore);
225 Parser parser(datastore->schema(), writableOps, dataQuery);
Václav Kubernát395d92c2020-01-24 12:18:18 +0100226
Václav Kubernátb4e5b182020-11-16 19:55:09 +0100227 lineEditor.bind_key(Replxx::KEY::meta(Replxx::KEY::BACKSPACE), [&lineEditor](const auto& code) {
Václav Kubernát48637292020-07-08 16:54:13 +0200228 return lineEditor.invoke(Replxx::ACTION::KILL_TO_BEGINING_OF_WORD, code);
229 });
Václav Kubernátb4e5b182020-11-16 19:55:09 +0100230 lineEditor.bind_key(Replxx::KEY::control('W'), [&lineEditor](const auto& code) {
Václav Kubernát48637292020-07-08 16:54:13 +0200231 return lineEditor.invoke(Replxx::ACTION::KILL_TO_WHITESPACE_ON_LEFT, code);
232 });
Václav Kubernát395d92c2020-01-24 12:18:18 +0100233
234 lineEditor.set_word_break_characters("\t _[]/:'\"=-%");
235
Václav Kubernát1ed4aa32020-01-23 13:13:28 +0100236 lineEditor.set_completion_callback([&parser](const std::string& input, int& context) {
Václav Kubernáta395d332019-02-13 16:49:20 +0100237 std::stringstream stream;
Václav Kubernát5c4f8a32021-08-24 22:57:41 +0200238 Completions completions;
239 try {
240 completions = parser.completeCommand(input, stream);
241 } catch (std::exception& ex) {
242 std::cerr << "Error while completing: " << ex.what() << "\n";
243 }
Václav Kubernáta395d332019-02-13 16:49:20 +0100244
Jan Kundrát8d8efe82019-10-18 10:21:36 +0200245 std::vector<replxx::Replxx::Completion> res;
Václav Kubernát1ed4aa32020-01-23 13:13:28 +0100246 std::copy(completions.m_completions.begin(), completions.m_completions.end(), std::back_inserter(res));
247 context = completions.m_contextLength;
Václav Kubernáta395d332019-02-13 16:49:20 +0100248 return res;
249 });
Václav Kubernát2b684612018-08-09 18:55:24 +0200250
Václav Kubernát435706e2019-02-20 18:05:59 +0100251 std::optional<std::string> historyFile;
252 if (auto xdgHome = getenv("XDG_DATA_HOME")) {
253 historyFile = std::string(xdgHome) + "/" + HISTORY_FILE_NAME;
254 } else if (auto home = getenv("HOME")) {
255 historyFile = std::string(home) + "/.local/share/" + HISTORY_FILE_NAME;
256 }
257
Václav Kubernát3a433232020-07-08 17:52:50 +0200258 if (historyFile) {
Václav Kubernát435706e2019-02-20 18:05:59 +0100259 lineEditor.history_load(historyFile.value());
Václav Kubernát3a433232020-07-08 17:52:50 +0200260 }
Václav Kubernát435706e2019-02-20 18:05:59 +0100261
Václav Kubernátfd261162020-11-12 02:36:29 +0100262 while (backendReturnCode == 0) {
Václav Kubernát2bed9522020-12-01 03:37:41 +0100263 auto fullContextPath = parser.currentNode();
264 std::string prompt;
265 if (auto activeRpcPath = proxyDatastore.inputDatastorePath()) {
266 auto rpcPrefixLength = activeRpcPath->size();
267 prompt = "(prepare: " + *activeRpcPath + ") " + fullContextPath.substr(rpcPrefixLength);
268 } else {
269 prompt = fullContextPath;
270 }
271
272 prompt += "> ";
273
274 auto line = lineEditor.input(prompt);
Václav Kubernáta395d332019-02-13 16:49:20 +0100275 if (!line) {
Václav Kubernát82bf1312019-11-05 11:19:26 +0100276 // If user pressed CTRL-C to abort the line, errno gets set to EAGAIN.
277 // If user pressed CTRL-D (for EOF), errno doesn't get set to EAGAIN, so we exit the program.
278 // I have no idea why replxx uses errno for this.
279 if (errno == EAGAIN) {
280 continue;
281 } else {
282 break;
283 }
Václav Kubernát5b80e522019-01-25 12:17:03 +0100284 }
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200285
Jan Kundráte3877022018-09-05 15:32:09 +0200286 std::locale C_locale("C");
Václav Kubernáta395d332019-02-13 16:49:20 +0100287 std::string_view view{line};
288 if (std::all_of(view.begin(), view.end(),
Jan Kundráte3877022018-09-05 15:32:09 +0200289 [C_locale](const auto c) { return std::isspace(c, C_locale);})) {
290 continue;
291 }
292
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200293 try {
Václav Kubernát5b80e522019-01-25 12:17:03 +0100294 command_ cmd = parser.parseCommand(line, std::cout);
Václav Kubernát48e9dfa2020-07-08 10:55:12 +0200295 boost::apply_visitor(Interpreter(parser, proxyDatastore), cmd);
Petr Gotthard1c76dea2022-04-13 17:56:58 +0200296 if (cmd.type() == typeid(quit_)) {
297 break;
298 }
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200299 } catch (InvalidCommandException& ex) {
300 std::cerr << ex.what() << std::endl;
Václav Kubernátc58e4aa2019-04-03 18:37:32 +0200301 } catch (DatastoreException& ex) {
302 std::cerr << ex.what() << std::endl;
Václav Kubernáte7248b22020-06-26 15:38:59 +0200303 } catch (std::runtime_error& ex) {
304 std::cerr << ex.what() << std::endl;
Václav Kubernát160e5a22020-12-01 01:11:28 +0100305 } catch (std::logic_error& ex) {
306 std::cerr << ex.what() << std::endl;
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200307 }
Václav Kubernát5b80e522019-01-25 12:17:03 +0100308
Václav Kubernáta395d332019-02-13 16:49:20 +0100309 lineEditor.history_add(line);
Václav Kubernátff2c9f62018-05-16 20:26:31 +0200310 }
311
Václav Kubernát3a433232020-07-08 17:52:50 +0200312 if (historyFile) {
Václav Kubernát435706e2019-02-20 18:05:59 +0100313 lineEditor.history_save(historyFile.value());
Václav Kubernát3a433232020-07-08 17:52:50 +0200314 }
Václav Kubernát435706e2019-02-20 18:05:59 +0100315
Václav Kubernátfd261162020-11-12 02:36:29 +0100316 return backendReturnCode;
Jan Kundrátdc2b0722018-03-02 14:13:37 +0100317}