Mercurial > irccd

comparison irccdctl/cli.cpp @ 345:006452e4a997

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Irccdctl: unify cli commands
author David Demelier <markand@malikania.fr>
date Sun, 13 Nov 2016 09:45:54 +0100
parents 4665fffff6f2
children 24b1709093e7
comparison
equal deleted inserted replaced
344:4665fffff6f2 345:006452e4a997
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */ 17 */
18 18
19 #include <iostream>
20
19 #include <json.hpp> 21 #include <json.hpp>
20 22
21 #include "cli.hpp" 23 #include "cli.hpp"
24 #include "elapsed-timer.hpp"
22 #include "irccdctl.hpp" 25 #include "irccdctl.hpp"
26 #include "options.hpp"
23 #include "util.hpp" 27 #include "util.hpp"
24 #include "elapsed-timer.hpp"
25 28
26 namespace irccd { 29 namespace irccd {
30
31 /*
32 * Cli.
33 * ------------------------------------------------------------------
34 */
27 35
28 void Cli::check(const nlohmann::json &response) 36 void Cli::check(const nlohmann::json &response)
29 { 37 {
30 if (!util::json::getBool(response, "status", false)) { 38 if (!util::json::getBool(response, "status", false)) {
31 auto error = util::json::getString(response, "error"); 39 auto error = util::json::getString(response, "error");
78 void Cli::call(Irccdctl &irccdctl, nlohmann::json args) 86 void Cli::call(Irccdctl &irccdctl, nlohmann::json args)
79 { 87 {
80 check(request(irccdctl, args)); 88 check(request(irccdctl, args));
81 } 89 }
82 90
91 namespace cli {
92
93 /*
94 * PluginConfigCli.
95 * ------------------------------------------------------------------
96 */
97
98 void PluginConfigCli::set(Irccdctl &irccdctl, const std::vector<std::string> &args)
99 {
100 check(request(irccdctl, nlohmann::json::object({
101 { "plugin", args[0] },
102 { "variable", args[1] },
103 { "value", args[2] }
104 })));
105 }
106
107 void PluginConfigCli::get(Irccdctl &irccdctl, const std::vector<std::string> &args)
108 {
109 auto result = request(irccdctl, nlohmann::json::object({
110 { "plugin", args[0] },
111 { "variable", args[1] }
112 }));
113
114 check(result);
115
116 if (result["variables"].is_object())
117 std::cout << util::json::pretty(result["variables"][args[1]]) << std::endl;
118 }
119
120 void PluginConfigCli::getall(Irccdctl &irccdctl, const std::vector<std::string> &args)
121 {
122 auto result = request(irccdctl, nlohmann::json::object({{ "plugin", args[0] }}));
123
124 check(result);
125
126 auto variables = result["variables"];
127
128 for (auto v = variables.begin(); v != variables.end(); ++v)
129 std::cout << std::setw(16) << std::left << v.key() << " : " << util::json::pretty(v.value()) << std::endl;
130 }
131
132 PluginConfigCli::PluginConfigCli()
133 : Cli("plugin-config",
134 "configure a plugin",
135 "plugin-config plugin [variable] [value]",
136 "Get or set plugin configuration.\n\n"
137 "Examples:\n"
138 "\tirccdctl plugin-config ask")
139 {
140 }
141
142 void PluginConfigCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
143 {
144 switch (args.size()) {
145 case 3:
146 set(irccdctl, args);
147 break;
148 case 2:
149 get(irccdctl, args);
150 break;
151 case 1:
152 getall(irccdctl, args);
153 break;
154 default:
155 throw std::invalid_argument("plugin-config requires at least 1 argument");
156 }
157 }
158
159 /*
160 * PluginInfoCli.
161 * ------------------------------------------------------------------
162 */
163
164 PluginInfoCli::PluginInfoCli()
165 : Cli("plugin-info",
166 "get plugin information",
167 "plugin-info plugin",
168 "Get plugin information\n\n"
169 "Example:\n"
170 "\tirccdctl plugin-info ask"
171 )
172 {
173 }
174
175 void PluginInfoCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
176 {
177 if (args.size() < 1)
178 throw std::invalid_argument("plugin-info requires 1 argument");
179
180 auto result = request(irccdctl, {{ "plugin", args[0] }});
181
182 std::cout << std::boolalpha;
183 std::cout << "Author : " << util::json::getString(result, "author") << std::endl;
184 std::cout << "License : " << util::json::getString(result, "license") << std::endl;
185 std::cout << "Summary : " << util::json::getString(result, "summary") << std::endl;
186 std::cout << "Version : " << util::json::getString(result, "version") << std::endl;
187 }
188
189 /*
190 * PluginListCli.
191 * ------------------------------------------------------------------
192 */
193
194 PluginListCli::PluginListCli()
195 : Cli("plugin-list",
196 "list loaded plugins",
197 "plugin-list",
198 "Get the list of all loaded plugins.\n\n"
199 "Example:\n"
200 "\tirccdctl plugin-list")
201 {
202 }
203
204 void PluginListCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &)
205 {
206 auto result = request(irccdctl);
207
208 for (const auto &value : result["list"])
209 if (value.is_string())
210 std::cout << value.get<std::string>() << std::endl;
211 }
212
213 /*
214 * PluginLoadCli.
215 * ------------------------------------------------------------------
216 */
217
218 PluginLoadCli::PluginLoadCli()
219 : Cli("plugin-load",
220 "load a plugin",
221 "plugin-load logger",
222 "Load a plugin into the irccd instance.\n\n"
223 "Example:\n"
224 "\tirccdctl plugin-load logger")
225 {
226 }
227
228 void PluginLoadCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
229 {
230 if (args.size() < 1)
231 throw std::invalid_argument("plugin-load requires 1 argument");
232
233 check(request(irccdctl, {{"plugin", args[0]}}));
234 }
235
236 /*
237 * PluginReloadCli.
238 * ------------------------------------------------------------------
239 */
240
241 PluginReloadCli::PluginReloadCli()
242 : Cli("plugin-reload",
243 "reload a plugin",
244 "plugin-reload plugin",
245 "Call the onReload event on the specified plugin.")
246 {
247 }
248
249 void PluginReloadCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
250 {
251 if (args.size() < 1)
252 throw std::invalid_argument("plugin-reload requires 1 argument");
253
254 check(request(irccdctl, {{ "plugin", args[0] }}));
255 }
256
257 /*
258 * PluginUnloadCli.
259 * ------------------------------------------------------------------
260 */
261
262 PluginUnloadCli::PluginUnloadCli()
263 : Cli("plugin-unload",
264 "unload a plugin",
265 "plugin-unload plugin",
266 "Unload a loaded plugin from the irccd instance.\n\n"
267 "Example:\n"
268 "tirccdctl plugin-unload logger")
269 {
270 }
271
272 void PluginUnloadCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
273 {
274 if (args.size() < 1)
275 throw std::invalid_argument("plugin-unload requires 1 argument");
276
277 check(request(irccdctl, {{ "plugin", args[0] }}));
278 }
279
280 /*
281 * ServerChannelCli.
282 * ------------------------------------------------------------------
283 */
284
285 ServerChannelMode::ServerChannelMode()
286 : Cli("server-cmode",
287 "change channel mode",
288 "server-cmode server channel mode",
289 "Change the mode of the specified channel.\n\n"
290 "Example:\n"
291 "\tirccdctl server-cmode freenode #staff +t")
292 {
293 }
294
295 void ServerChannelMode::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
296 {
297 if (args.size() < 3)
298 throw std::invalid_argument("server-cmode requires 3 arguments");
299
300 check(request(irccdctl, {
301 { "command", "server-cmode" },
302 { "server", args[0] },
303 { "channel", args[1] },
304 { "mode", args[2] }
305 }));
306 }
307
308 /*
309 * ServerChannelNoticeCli.
310 * ------------------------------------------------------------------
311 */
312
313 ServerChannelNoticeCli::ServerChannelNoticeCli()
314 : Cli("server-cnotice",
315 "send a channel notice",
316 "server-cnotice server channel message",
317 "Send a message notice on a channel.\n\n"
318 "Example:\n"
319 "\tirccdctl server-cnotice freenode #staff \"Don't flood!\"")
320 {
321 }
322
323 void ServerChannelNoticeCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
324 {
325 if (args.size() < 3)
326 throw std::invalid_argument("server-cnotice requires 3 arguments");
327
328 check(request(irccdctl, {
329 { "command", "server-cnotice" },
330 { "server", args[0] },
331 { "channel", args[1] },
332 { "message", args[2] }
333 }));
334 }
335
336 /*
337 * ServerConnectCli.
338 * ------------------------------------------------------------------
339 */
340
341 namespace {
342
343 option::Result parse(std::vector<std::string> &args)
344 {
345 option::Options options{
346 { "-c", true },
347 { "--command", true },
348 { "-n", true },
349 { "--nickname", true },
350 { "-r", true },
351 { "--realname", true },
352 { "-S", false },
353 { "--ssl-verify", false },
354 { "-s", false },
355 { "--ssl", false },
356 { "-u", true },
357 { "--username", true }
358 };
359
360 return option::read(args, options);
361 }
362
363 } // !namespace
364
365 ServerConnectCli::ServerConnectCli()
366 : Cli("server-connect",
367 "add a server",
368 "server-connect [options] id host [port]",
369 "Connect to a server.\n\n"
370 "Available options:\n"
371 " -c, --command\t\tspecify the command char\n"
372 " -n, --nickname\tspecify a nickname\n"
373 " -r, --realname\tspecify a real name\n"
374 " -S, --ssl-verify\tverify SSL\n"
375 " -s, --ssl\t\tconnect using SSL\n"
376 " -u, --username\tspecify a user name\n\n"
377 "Example:\n"
378 "\tirccdctl server-connect -n jean example irc.example.org\n"
379 "\tirccdctl server-connect --ssl example irc.example.org 6697")
380 {
381 }
382
383 void ServerConnectCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
384 {
385 std::vector<std::string> copy(args);
386
387 option::Result result = parse(copy);
388 option::Result::const_iterator it;
389
390 if (copy.size() < 2)
391 throw std::invalid_argument("server-connect requires at least 2 arguments");
392
393 auto object = nlohmann::json::object({
394 { "name", copy[0] },
395 { "host", copy[1] }
396 });
397
398 if (copy.size() == 3) {
399 if (!util::isNumber(copy[2]))
400 throw std::invalid_argument("invalid port number");
401
402 object["port"] = std::stoi(copy[2]);
403 }
404
405 if (result.count("-S") > 0 || result.count("--ssl-verify") > 0)
406 object["sslVerify"] = true;
407 if (result.count("-s") > 0 || result.count("--ssl") > 0)
408 object["ssl"] = true;
409 if ((it = result.find("-n")) != result.end() || (it = result.find("--nickname")) != result.end())
410 object["nickname"] = it->second;
411 if ((it = result.find("-r")) != result.end() || (it = result.find("--realname")) != result.end())
412 object["realname"] = it->second;
413 if ((it = result.find("-u")) != result.end() || (it = result.find("--username")) != result.end())
414 object["username"] = it->second;
415
416 check(request(irccdctl, object));
417 }
418
419 /*
420 * ServerDisconnectCli.
421 * ------------------------------------------------------------------
422 */
423
424 ServerDisconnectCli::ServerDisconnectCli()
425 : Cli("server-disconnect",
426 "disconnect server",
427 "server-disconnect [server]",
428 "Disconnect from a server.\n\n"
429 "If server is not specified, irccd disconnects all servers.\n\n"
430 "Example:\n"
431 "\tirccdctl server-disconnect localhost")
432 {
433 }
434
435 void ServerDisconnectCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
436 {
437 auto object = nlohmann::json::object({
438 { "command", "server-disconnect" }
439 });
440
441 if (args.size() > 0)
442 object["server"] = args[0];
443
444 check(request(irccdctl, object));
445 }
446
447 /*
448 * ServerInfoCli.
449 * ------------------------------------------------------------------
450 */
451
452 ServerInfoCli::ServerInfoCli()
453 : Cli("server-info",
454 "get server information",
455 "server-info server",
456 "Get information about a server.\n\n"
457 "Example:\n"
458 "\tirccdctl server-info freenode")
459 {
460 }
461
462 void ServerInfoCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
463 {
464 if (args.size() < 1)
465 throw std::invalid_argument("server-info requires 1 argument");
466
467 auto result = request(irccdctl, {
468 { "command", "server-info" },
469 { "server", args[0] }
470 });
471
472 check(result);
473
474 std::cout << std::boolalpha;
475 std::cout << "Name : " << util::json::pretty(result["name"]) << std::endl;
476 std::cout << "Host : " << util::json::pretty(result["host"]) << std::endl;
477 std::cout << "Port : " << util::json::pretty(result["port"]) << std::endl;
478 std::cout << "Ipv6 : " << util::json::pretty(result["ipv6"]) << std::endl;
479 std::cout << "SSL : " << util::json::pretty(result["ssl"]) << std::endl;
480 std::cout << "SSL verified : " << util::json::pretty(result["sslVerify"]) << std::endl;
481 std::cout << "Channels : ";
482
483 for (const auto &v : result["channels"])
484 if (v.is_string())
485 std::cout << v.get<std::string>() << " ";
486
487 std::cout << std::endl;
488
489 std::cout << "Nickname : " << util::json::pretty(result["nickname"]) << std::endl;
490 std::cout << "User name : " << util::json::pretty(result["username"]) << std::endl;
491 std::cout << "Real name : " << util::json::pretty(result["realname"]) << std::endl;
492 }
493
494 /*
495 * ServerInviteCli.
496 * ------------------------------------------------------------------
497 */
498
499 ServerInviteCli::ServerInviteCli()
500 : Cli("server-invite",
501 "invite someone",
502 "server-invite server nickname channel",
503 "Invite the specified target on the channel.\n\n"
504 "Example:\n"
505 "\tirccdctl server-invite freenode xorg62 #staff")
506 {
507 }
508
509 void ServerInviteCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
510 {
511 if (args.size() < 3)
512 throw std::invalid_argument("server-invite requires 3 arguments");
513
514 check(request(irccdctl, {
515 { "command", "server-invite" },
516 { "server", args[0] },
517 { "target", args[1] },
518 { "channel", args[2] }
519 }));
520 }
521
522 /*
523 * ServerJoinCli.
524 * ------------------------------------------------------------------
525 */
526
527 ServerJoinCli::ServerJoinCli()
528 : Cli("server-join",
529 "join a channel",
530 "server-join server channel [password]",
531 "Join the specified channel, the password is optional.\n\n"
532 "Example:\n"
533 "\tirccdctl server-join freenode #test\n"
534 "\tirccdctl server-join freenode #private-club secret")
535 {
536 }
537
538 void ServerJoinCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
539 {
540 if (args.size() < 2)
541 throw std::invalid_argument("server-join requires at least 2 arguments");
542
543 auto object = nlohmann::json::object({
544 { "server", args[0] },
545 { "channel", args[1] }
546 });
547
548 if (args.size() == 3)
549 object["password"] = args[2];
550
551 check(request(irccdctl, object));
552 }
553
554 /*
555 * ServerKickCli.
556 * ------------------------------------------------------------------
557 */
558
559 ServerKickCli::ServerKickCli()
560 : Cli("server-kick",
561 "kick someone from a channel",
562 "server-kick server target channel [reason]",
563 "Kick the specified target from the channel, the reason is optional.\n\n"
564 "Example:\n"
565 "\tirccdctl server-kick freenode jean #staff \"Stop flooding\"")
566 {
567 }
568
569 void ServerKickCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
570 {
571 if (args.size() < 3)
572 throw std::invalid_argument("server-kick requires at least 3 arguments ");
573
574 auto object = nlohmann::json::object({
575 { "server", args[0] },
576 { "target", args[1] },
577 { "channel", args[2] }
578 });
579
580 if (args.size() == 4)
581 object["reason"] = args[3];
582
583 check(request(irccdctl, object));
584 }
585
586 /*
587 * ServerListCli.
588 * ------------------------------------------------------------------
589 */
590
591 ServerListCli::ServerListCli()
592 : Cli("server-list",
593 "get list of servers",
594 "server-list\n\n",
595 "Get the list of all connected servers.\n\n"
596 "Example:\n"
597 "\tirccdctl server-list")
598 {
599 }
600
601 void ServerListCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &)
602 {
603 auto response = request(irccdctl);
604
605 check(response);
606
607 for (const auto &n : response["list"])
608 if (n.is_string())
609 std::cout << n.get<std::string>() << std::endl;
610 }
611
612 /*
613 * ServerMeCli.
614 * ------------------------------------------------------------------
615 */
616
617 ServerMeCli::ServerMeCli()
618 : Cli("server-me",
619 "send an action emote",
620 "server-me server target message",
621 "Send an action emote.\n\n"
622 "Example:\n"
623 "\tirccdctl server-me freenode #staff \"going back soon\"")
624 {
625 }
626
627 void ServerMeCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
628 {
629 if (args.size() < 3)
630 throw std::runtime_error("server-me requires 3 arguments");
631
632 check(request(irccdctl, {
633 { "server", args[0] },
634 { "target", args[1] },
635 { "message", args[2] }
636 }));
637 }
638
639 /*
640 * ServerMessageCli.
641 * ------------------------------------------------------------------
642 */
643
644 ServerMessageCli::ServerMessageCli()
645 : Cli("server-message",
646 "send a message",
647 "server-message server target message",
648 "Send a message to the specified target or channel.\n\n"
649 "Example:\n"
650 "\tirccdctl server-message freenode #staff \"Hello from irccd\"")
651 {
652 }
653
654 void ServerMessageCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
655 {
656 if (args.size() < 3)
657 throw std::invalid_argument("server-message requires 3 arguments");
658
659 check(request(irccdctl, {
660 { "server", args[0] },
661 { "target", args[1] },
662 { "message", args[2] }
663 }));
664 }
665
666 /*
667 * ServerModeCli.
668 * ------------------------------------------------------------------
669 */
670
671 ServerModeCli::ServerModeCli()
672 : Cli("server-mode",
673 "the the user mode",
674 "server-mode server mode",
675 "Set the irccd's user mode.\n\n"
676 "Example:\n"
677 "\tirccdctl server-mode +i")
678 {
679 }
680
681 void ServerModeCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
682 {
683 if (args.size() < 2)
684 throw std::invalid_argument("server-mode requires 2 arguments");
685
686 check(request(irccdctl, {
687 { "server", args[0] },
688 { "mode", args[1] }
689 }));
690 }
691
692 /*
693 * ServerNickCli.
694 * ------------------------------------------------------------------
695 */
696
697 ServerNickCli::ServerNickCli()
698 : Cli("server-nick",
699 "change your nickname",
700 "server-nick server nickname",
701 "Change irccd's nickname.\n\n"
702 "Example:\n"
703 "\tirccdctl server-nick freenode david")
704 {
705 }
706
707 void ServerNickCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
708 {
709 if (args.size() < 2)
710 throw std::invalid_argument("server-nick requires 2 arguments");
711
712 check(request(irccdctl, {
713 { "server", args[0] },
714 { "nickname", args[1] }
715 }));
716 }
717
718 /*
719 * ServerNoticeCli.
720 * ------------------------------------------------------------------
721 */
722
723 ServerNoticeCli::ServerNoticeCli()
724 : Cli("server-notice",
725 "send a private notice",
726 "server-notice server target message",
727 "Send a private notice to the specified target.\n\n"
728 "Example:\n"
729 "\tirccdctl server-notice freenode jean \"I know you are here.\"")
730 {
731 }
732
733 void ServerNoticeCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
734 {
735 if (args.size() < 3)
736 throw std::invalid_argument("server-notice requires 3 arguments");
737
738 check(request(irccdctl, {
739 { "server", args[0] },
740 { "target", args[1] },
741 { "message", args[2] }
742 }));
743 }
744
745 /*
746 * ServerPartCli.
747 * ------------------------------------------------------------------
748 */
749
750 ServerPartCli::ServerPartCli()
751 : Cli("server-part",
752 "leave a channel",
753 "server-part server channel [reason]",
754 "Leave the specified channel, the reason is optional.\n\n"
755 "Not all IRC servers support giving a reason to leave a channel, do not "
756 "specify it if this is a concern.\n\n"
757 "Example:\n"
758 "\tirccdctl server-part freenode #staff"
759 "\tirccdctl server-part freenode #botwar \"too noisy\"")
760 {
761 }
762
763 void ServerPartCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
764 {
765 if (args.size() < 2)
766 throw std::invalid_argument("server-part requires at least 2 arguments");
767
768 auto object = nlohmann::json::object({
769 { "server", args[0] },
770 { "channel", args[1] }
771 });
772
773 if (args.size() >= 3)
774 object["reason"] = args[2];
775
776 check(request(irccdctl, object));
777 }
778
779 /*
780 * ServerReconnectCli.
781 * ------------------------------------------------------------------
782 */
783
784 ServerReconnectCli::ServerReconnectCli()
785 : Cli("server-reconnect",
786 "force reconnection of a server",
787 "server-reconnect [server]",
788 "Force reconnection of one or all servers.\n\n"
789 "If server is not specified, all servers will try to reconnect.\n\n"
790 "Example:\n"
791 "\tirccdctl server-reconnect\n"
792 "\tirccdctl server-reconnect wanadoo")
793 {
794 }
795
796 void ServerReconnectCli::exec(Irccdctl &irccdctl, const std::vector<std::string> &args)
797 {
798 auto object = nlohmann::json::object({
799 { "command", "server-reconnect" }
800 });
801
802 if (args.size() >= 1)
803 object["server"] = args[0];
804
805 check(request(irccdctl, object));
806 }
807
808 } // !cli
809
83 } // !irccd 810 } // !irccd