From 13ae036ca04b4ebd427444252ef9856b3028b7ac Mon Sep 17 00:00:00 2001
From: Andrei Vasiliu <whyte.vuhuni@gmail.com>
Date: Sun, 16 Jan 2022 13:52:23 +0200
Subject: [PATCH 1/7] Move and refactor admin commands into admin module
---
src/database/admin.rs | 239 +++++++++++++++++++++++++++++++++++++++++-
src/database/rooms.rs | 220 +-------------------------------------
2 files changed, 240 insertions(+), 219 deletions(-)
diff --git a/src/database/admin.rs b/src/database/admin.rs
index 7d2301d9..518d7587 100644
--- a/src/database/admin.rs
+++ b/src/database/admin.rs
@@ -1,10 +1,17 @@
-use std::{convert::TryInto, sync::Arc};
+use std::{convert::TryFrom, convert::TryInto, sync::Arc, time::Instant};
-use crate::{pdu::PduBuilder, Database};
-use rocket::futures::{channel::mpsc, stream::StreamExt};
+use crate::{
+ error::{Error, Result},
+ pdu::PduBuilder,
+ server_server, Database, PduEvent,
+};
+use rocket::{
+ futures::{channel::mpsc, stream::StreamExt},
+ http::RawStr,
+};
use ruma::{
events::{room::message::RoomMessageEventContent, EventType},
- UserId,
+ EventId, RoomId, RoomVersionId, UserId,
};
use serde_json::value::to_raw_value;
use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
@@ -137,3 +144,227 @@ impl Admin {
self.sender.unbounded_send(command).unwrap();
}
}
+
+pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -> AdminCommand {
+ let mut parts = command_line.split_whitespace().skip(1);
+
+ let command_name = match parts.next() {
+ Some(command) => command,
+ None => {
+ let message = "No command given. Use <code>help</code> for a list of commands.";
+ return AdminCommand::SendMessage(RoomMessageEventContent::text_html(
+ html_to_markdown(message),
+ message,
+ ));
+ }
+ };
+
+ let args: Vec<_> = parts.collect();
+
+ match try_parse_admin_command(db, command_name, args, body) {
+ Ok(admin_command) => admin_command,
+ Err(error) => {
+ let message = format!(
+ "Encountered error while handling <code>{}</code> command:\n\
+ <pre>{}</pre>",
+ command_name, error,
+ );
+
+ AdminCommand::SendMessage(RoomMessageEventContent::text_html(
+ html_to_markdown(&message),
+ message,
+ ))
+ }
+ }
+}
+
+// Helper for `RoomMessageEventContent::text_html`, which needs the content as
+// both markdown and HTML.
+fn html_to_markdown(text: &str) -> String {
+ text.replace("<p>", "")
+ .replace("</p>", "\n")
+ .replace("<pre>", "```\n")
+ .replace("</pre>", "\n```")
+ .replace("<code>", "`")
+ .replace("</code>", "`")
+ .replace("<li>", "* ")
+ .replace("</li>", "")
+ .replace("<ul>\n", "")
+ .replace("</ul>\n", "")
+}
+
+const HELP_TEXT: &'static str = r#"
+<p>The following commands are available:</p>
+<ul>
+<li><code>register_appservice</code>: Register a bridge using its registration YAML</li>
+<li><code>unregister_appservice</code>: Unregister a bridge using its ID</li>
+<li><code>list_appservices</code>: List all the currently registered bridges</li>
+<li><code>get_auth_chain</code>: Get the `auth_chain` of a PDU</li>
+<li><code>parse_pdu</code>: Parse and print a PDU from a JSON</li>
+<li><code>get_pdu</code>: Retrieve and print a PDU by ID from the Conduit database</li>
+<li><code>database_memory_usage</code>: Print database memory usage statistics</li>
+<ul>
+"#;
+
+pub fn try_parse_admin_command(
+ db: &Database,
+ command: &str,
+ args: Vec<&str>,
+ body: Vec<&str>,
+) -> Result<AdminCommand> {
+ let command = match command {
+ "help" => AdminCommand::SendMessage(RoomMessageEventContent::text_html(
+ html_to_markdown(HELP_TEXT),
+ HELP_TEXT,
+ )),
+ "register_appservice" => {
+ if body.len() > 2 && body[0].trim() == "```" && body.last().unwrap().trim() == "```" {
+ let appservice_config = body[1..body.len() - 1].join("\n");
+ let parsed_config = serde_yaml::from_str::<serde_yaml::Value>(&appservice_config);
+ match parsed_config {
+ Ok(yaml) => AdminCommand::RegisterAppservice(yaml),
+ Err(e) => AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ format!("Could not parse appservice config: {}", e),
+ )),
+ }
+ } else {
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ "Expected code block in command body.",
+ ))
+ }
+ }
+ "unregister_appservice" => {
+ if args.len() == 1 {
+ AdminCommand::UnregisterAppservice(args[0].to_owned())
+ } else {
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ "Missing appservice identifier",
+ ))
+ }
+ }
+ "list_appservices" => AdminCommand::ListAppservices,
+ "get_auth_chain" => {
+ if args.len() == 1 {
+ if let Ok(event_id) = EventId::parse_arc(args[0]) {
+ if let Some(event) = db.rooms.get_pdu_json(&event_id)? {
+ let room_id_str = event
+ .get("room_id")
+ .and_then(|val| val.as_str())
+ .ok_or_else(|| Error::bad_database("Invalid event in database"))?;
+
+ let room_id = <&RoomId>::try_from(room_id_str).map_err(|_| {
+ Error::bad_database("Invalid room id field in event in database")
+ })?;
+ let start = Instant::now();
+ let count =
+ server_server::get_auth_chain(room_id, vec![event_id], db)?.count();
+ let elapsed = start.elapsed();
+ return Ok(AdminCommand::SendMessage(
+ RoomMessageEventContent::text_plain(format!(
+ "Loaded auth chain with length {} in {:?}",
+ count, elapsed
+ )),
+ ));
+ }
+ }
+ }
+
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ "Usage: get_auth_chain <event-id>",
+ ))
+ }
+ "parse_pdu" => {
+ if body.len() > 2 && body[0].trim() == "```" && body.last().unwrap().trim() == "```" {
+ let string = body[1..body.len() - 1].join("\n");
+ match serde_json::from_str(&string) {
+ Ok(value) => {
+ let event_id = EventId::parse(format!(
+ "${}",
+ // Anything higher than version3 behaves the same
+ ruma::signatures::reference_hash(&value, &RoomVersionId::V6)
+ .expect("ruma can calculate reference hashes")
+ ))
+ .expect("ruma's reference hashes are valid event ids");
+
+ match serde_json::from_value::<PduEvent>(
+ serde_json::to_value(value).expect("value is json"),
+ ) {
+ Ok(pdu) => {
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ format!("EventId: {:?}\n{:#?}", event_id, pdu),
+ ))
+ }
+ Err(e) => AdminCommand::SendMessage(
+ RoomMessageEventContent::text_plain(format!(
+ "EventId: {:?}\nCould not parse event: {}",
+ event_id, e
+ )),
+ ),
+ }
+ }
+ Err(e) => AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ format!("Invalid json in command body: {}", e),
+ )),
+ }
+ } else {
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ "Expected code block in command body.",
+ ))
+ }
+ }
+ "get_pdu" => {
+ if args.len() == 1 {
+ if let Ok(event_id) = EventId::parse(args[0]) {
+ let mut outlier = false;
+ let mut pdu_json = db.rooms.get_non_outlier_pdu_json(&event_id)?;
+ if pdu_json.is_none() {
+ outlier = true;
+ pdu_json = db.rooms.get_pdu_json(&event_id)?;
+ }
+ match pdu_json {
+ Some(json) => {
+ let json_text = serde_json::to_string_pretty(&json)
+ .expect("canonical json is valid json");
+ AdminCommand::SendMessage(
+ RoomMessageEventContent::text_html(
+ format!("{}\n```json\n{}\n```",
+ if outlier {
+ "PDU is outlier"
+ } else { "PDU was accepted"}, json_text),
+ format!("<p>{}</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
+ if outlier {
+ "PDU is outlier"
+ } else { "PDU was accepted"}, RawStr::new(&json_text).html_escape())
+ ),
+ )
+ }
+ None => AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ "PDU not found.",
+ )),
+ }
+ } else {
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ "Event ID could not be parsed.",
+ ))
+ }
+ } else {
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
+ "Usage: get_pdu <eventid>",
+ ))
+ }
+ }
+ "database_memory_usage" => AdminCommand::ShowMemoryUsage,
+ _ => {
+ let message = format!(
+ "Unrecognized command <code>{}</code>, try <code>help</code> for a list of commands.",
+ command,
+ );
+ AdminCommand::SendMessage(RoomMessageEventContent::text_html(
+ html_to_markdown(&message),
+ message,
+ ))
+ }
+ };
+
+ Ok(command)
+}
diff --git a/src/database/rooms.rs b/src/database/rooms.rs
index 0ba6c9ba..14df8f50 100644
--- a/src/database/rooms.rs
+++ b/src/database/rooms.rs
@@ -3,13 +3,13 @@ mod edus;
pub use edus::RoomEdus;
use crate::{
+ database::admin::parse_admin_command,
pdu::{EventHash, PduBuilder},
- server_server, utils, Database, Error, PduEvent, Result,
+ utils, Database, Error, PduEvent, Result,
};
use lru_cache::LruCache;
use regex::Regex;
use ring::digest;
-use rocket::http::RawStr;
use ruma::{
api::{client::error::ErrorKind, federation},
events::{
@@ -19,7 +19,6 @@ use ruma::{
room::{
create::RoomCreateEventContent,
member::{MembershipState, RoomMemberEventContent},
- message::RoomMessageEventContent,
power_levels::RoomPowerLevelsEventContent,
},
tag::TagEvent,
@@ -40,12 +39,11 @@ use std::{
iter,
mem::size_of,
sync::{Arc, Mutex, RwLock},
- time::Instant,
};
use tokio::sync::MutexGuard;
use tracing::{error, warn};
-use super::{abstraction::Tree, admin::AdminCommand, pusher};
+use super::{abstraction::Tree, pusher};
/// The unique identifier of each state group.
///
@@ -1496,216 +1494,8 @@ impl Rooms {
let command_line = lines.next().expect("each string has at least one line");
let body: Vec<_> = lines.collect();
- let mut parts = command_line.split_whitespace().skip(1);
- if let Some(command) = parts.next() {
- let args: Vec<_> = parts.collect();
-
- match command {
- "register_appservice" => {
- if body.len() > 2
- && body[0].trim() == "```"
- && body.last().unwrap().trim() == "```"
- {
- let appservice_config = body[1..body.len() - 1].join("\n");
- let parsed_config = serde_yaml::from_str::<serde_yaml::Value>(
- &appservice_config,
- );
- match parsed_config {
- Ok(yaml) => {
- db.admin
- .send(AdminCommand::RegisterAppservice(yaml));
- }
- Err(e) => {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(format!(
- "Could not parse appservice config: {}",
- e
- )),
- ));
- }
- }
- } else {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- "Expected code block in command body.",
- ),
- ));
- }
- }
- "unregister_appservice" => {
- if args.len() == 1 {
- db.admin.send(AdminCommand::UnregisterAppservice(
- args[0].to_owned(),
- ));
- } else {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- "Missing appservice identifier",
- ),
- ));
- }
- }
- "list_appservices" => {
- db.admin.send(AdminCommand::ListAppservices);
- }
- "get_auth_chain" => {
- if args.len() == 1 {
- if let Ok(event_id) = EventId::parse_arc(args[0]) {
- if let Some(event) = db.rooms.get_pdu_json(&event_id)? {
- let room_id_str = event
- .get("room_id")
- .and_then(|val| val.as_str())
- .ok_or_else(|| {
- Error::bad_database(
- "Invalid event in database",
- )
- })?;
-
- let room_id = <&RoomId>::try_from(room_id_str)
- .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
- let start = Instant::now();
- let count = server_server::get_auth_chain(
- room_id,
- vec![event_id],
- db,
- )?
- .count();
- let elapsed = start.elapsed();
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(format!(
- "Loaded auth chain with length {} in {:?}",
- count, elapsed
- )),
- ));
- }
- }
- }
- }
- "parse_pdu" => {
- if body.len() > 2
- && body[0].trim() == "```"
- && body.last().unwrap().trim() == "```"
- {
- let string = body[1..body.len() - 1].join("\n");
- match serde_json::from_str(&string) {
- Ok(value) => {
- let event_id = EventId::parse(format!(
- "${}",
- // Anything higher than version3 behaves the same
- ruma::signatures::reference_hash(
- &value,
- &RoomVersionId::V6
- )
- .expect("ruma can calculate reference hashes")
- ))
- .expect(
- "ruma's reference hashes are valid event ids",
- );
-
- match serde_json::from_value::<PduEvent>(
- serde_json::to_value(value)
- .expect("value is json"),
- ) {
- Ok(pdu) => {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- format!(
- "EventId: {:?}\n{:#?}",
- event_id, pdu
- ),
- ),
- ));
- }
- Err(e) => {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- format!("EventId: {:?}\nCould not parse event: {}", event_id, e),
- ),
- ));
- }
- }
- }
- Err(e) => {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(format!(
- "Invalid json in command body: {}",
- e
- )),
- ));
- }
- }
- } else {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- "Expected code block in command body.",
- ),
- ));
- }
- }
- "get_pdu" => {
- if args.len() == 1 {
- if let Ok(event_id) = EventId::parse(args[0]) {
- let mut outlier = false;
- let mut pdu_json =
- db.rooms.get_non_outlier_pdu_json(&event_id)?;
- if pdu_json.is_none() {
- outlier = true;
- pdu_json = db.rooms.get_pdu_json(&event_id)?;
- }
- match pdu_json {
- Some(json) => {
- let json_text =
- serde_json::to_string_pretty(&json)
- .expect("canonical json is valid json");
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_html(
- format!("{}\n```json\n{}\n```",
- if outlier {
- "PDU is outlier"
- } else { "PDU was accepted"}, json_text),
- format!("<p>{}</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
- if outlier {
- "PDU is outlier"
- } else { "PDU was accepted"}, RawStr::new(&json_text).html_escape())
- ),
- ));
- }
- None => {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- "PDU not found.",
- ),
- ));
- }
- }
- } else {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- "Event ID could not be parsed.",
- ),
- ));
- }
- } else {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(
- "Usage: get_pdu <eventid>",
- ),
- ));
- }
- }
- "database_memory_usage" => {
- db.admin.send(AdminCommand::ShowMemoryUsage);
- }
- _ => {
- db.admin.send(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(format!(
- "Unrecognized command: {}",
- command
- )),
- ));
- }
- }
- }
+ let command = parse_admin_command(db, command_line, body);
+ db.admin.send(command);
}
}
}
From e378bc4a2c5590047b42cd4f8e244396125cb428 Mon Sep 17 00:00:00 2001
From: Andrei Vasiliu <whyte.vuhuni@gmail.com>
Date: Tue, 18 Jan 2022 13:53:17 +0200
Subject: [PATCH 2/7] Refactor admin commands to use structopt
---
APPSERVICES.md | 8 +-
Cargo.toml | 3 +
src/database/admin.rs | 302 +++++++++++++++++++++++-------------------
3 files changed, 175 insertions(+), 138 deletions(-)
diff --git a/APPSERVICES.md b/APPSERVICES.md
index 894bc6f4..257166eb 100644
--- a/APPSERVICES.md
+++ b/APPSERVICES.md
@@ -18,7 +18,7 @@ First, go into the #admins room of your homeserver. The first person that
registered on the homeserver automatically joins it. Then send a message into
the room like this:
- @conduit:your.server.name: register_appservice
+ @conduit:your.server.name: register-appservice
```
paste
the
@@ -31,7 +31,7 @@ the room like this:
```
You can confirm it worked by sending a message like this:
-`@conduit:your.server.name: list_appservices`
+`@conduit:your.server.name: list-appservices`
The @conduit bot should answer with `Appservices (1): your-bridge`
@@ -46,9 +46,9 @@ could help.
To remove an appservice go to your admin room and execute
-```@conduit:your.server.name: unregister_appservice <name>```
+```@conduit:your.server.name: unregister-appservice <name>```
-where `<name>` one of the output of `list_appservices`.
+where `<name>` one of the output of `list-appservices`.
### Tested appservices
diff --git a/Cargo.toml b/Cargo.toml
index c87d949c..08afe1f4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -83,6 +83,9 @@ thread_local = "1.1.3"
# used for TURN server authentication
hmac = "0.11.0"
sha-1 = "0.9.8"
+# used for conduit's CLI and admin room command parsing
+structopt = { version = "0.3.25", default-features = false }
+pulldown-cmark = "0.9.1"
[features]
default = ["conduit_bin", "backend_sqlite", "backend_rocksdb"]
diff --git a/src/database/admin.rs b/src/database/admin.rs
index 518d7587..55724db5 100644
--- a/src/database/admin.rs
+++ b/src/database/admin.rs
@@ -5,6 +5,7 @@ use crate::{
pdu::PduBuilder,
server_server, Database, PduEvent,
};
+use regex::Regex;
use rocket::{
futures::{channel::mpsc, stream::StreamExt},
http::RawStr,
@@ -14,6 +15,7 @@ use ruma::{
EventId, RoomId, RoomVersionId, UserId,
};
use serde_json::value::to_raw_value;
+use structopt::StructOpt;
use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
use tracing::warn;
@@ -146,78 +148,98 @@ impl Admin {
}
pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -> AdminCommand {
- let mut parts = command_line.split_whitespace().skip(1);
+ let mut argv: Vec<_> = command_line.split_whitespace().skip(1).collect();
- let command_name = match parts.next() {
- Some(command) => command,
+ let command_name = match argv.get(0) {
+ Some(command) => *command,
None => {
- let message = "No command given. Use <code>help</code> for a list of commands.";
+ let markdown_message = "No command given. Use `help` for a list of commands.";
+ let html_message = markdown_to_html(&markdown_message);
+
return AdminCommand::SendMessage(RoomMessageEventContent::text_html(
- html_to_markdown(message),
- message,
+ markdown_message,
+ html_message,
));
}
};
- let args: Vec<_> = parts.collect();
+ // Backwards compatibility with `register_appservice`-style commands
+ let command_with_dashes;
+ if command_line.contains("_") {
+ command_with_dashes = command_name.replace("_", "-");
+ argv[0] = &command_with_dashes;
+ }
- match try_parse_admin_command(db, command_name, args, body) {
+ match try_parse_admin_command(db, argv, body) {
Ok(admin_command) => admin_command,
Err(error) => {
- let message = format!(
- "Encountered error while handling <code>{}</code> command:\n\
- <pre>{}</pre>",
+ let markdown_message = format!(
+ "Encountered an error while handling the `{}` command:\n\
+ ```\n{}\n```",
command_name, error,
);
+ let html_message = markdown_to_html(&markdown_message);
AdminCommand::SendMessage(RoomMessageEventContent::text_html(
- html_to_markdown(&message),
- message,
+ markdown_message,
+ html_message,
))
}
}
}
-// Helper for `RoomMessageEventContent::text_html`, which needs the content as
-// both markdown and HTML.
-fn html_to_markdown(text: &str) -> String {
- text.replace("<p>", "")
- .replace("</p>", "\n")
- .replace("<pre>", "```\n")
- .replace("</pre>", "\n```")
- .replace("<code>", "`")
- .replace("</code>", "`")
- .replace("<li>", "* ")
- .replace("</li>", "")
- .replace("<ul>\n", "")
- .replace("</ul>\n", "")
+#[derive(StructOpt)]
+enum AdminCommands {
+ #[structopt(verbatim_doc_comment)]
+ /// Register a bridge using its registration YAML
+ ///
+ /// This command needs a YAML generated by an appservice (such as a mautrix
+ /// bridge), which must be provided in a code-block below the command.
+ ///
+ /// Example:
+ /// ````
+ /// @conduit:example.com: register-appservice
+ /// ```
+ /// yaml content here
+ /// ```
+ /// ````
+ RegisterAppservice,
+ /// Unregister a bridge using its ID
+ UnregisterAppservice { appservice_identifier: String },
+ /// List all the currently registered bridges
+ ListAppservices,
+ /// Get the auth_chain of a PDU
+ GetAuthChain { event_id: Box<EventId> },
+ /// Parse and print a PDU from a JSON
+ ParsePdu,
+ /// Retrieve and print a PDU by ID from the Conduit database
+ GetPdu { event_id: Box<EventId> },
+ /// Print database memory usage statistics
+ DatabaseMemoryUsage,
}
-const HELP_TEXT: &'static str = r#"
-<p>The following commands are available:</p>
-<ul>
-<li><code>register_appservice</code>: Register a bridge using its registration YAML</li>
-<li><code>unregister_appservice</code>: Unregister a bridge using its ID</li>
-<li><code>list_appservices</code>: List all the currently registered bridges</li>
-<li><code>get_auth_chain</code>: Get the `auth_chain` of a PDU</li>
-<li><code>parse_pdu</code>: Parse and print a PDU from a JSON</li>
-<li><code>get_pdu</code>: Retrieve and print a PDU by ID from the Conduit database</li>
-<li><code>database_memory_usage</code>: Print database memory usage statistics</li>
-<ul>
-"#;
-
pub fn try_parse_admin_command(
db: &Database,
- command: &str,
- args: Vec<&str>,
+ mut argv: Vec<&str>,
body: Vec<&str>,
) -> Result<AdminCommand> {
- let command = match command {
- "help" => AdminCommand::SendMessage(RoomMessageEventContent::text_html(
- html_to_markdown(HELP_TEXT),
- HELP_TEXT,
- )),
- "register_appservice" => {
+ argv.insert(0, "@conduit:example.com:");
+ let command = match AdminCommands::from_iter_safe(argv) {
+ Ok(command) => command,
+ Err(error) => {
+ println!("Before:\n{}\n", error.to_string());
+ let markdown_message = usage_to_markdown(&error.to_string())
+ .replace("example.com", db.globals.server_name().as_str());
+ let html_message = markdown_to_html(&markdown_message);
+
+ return Ok(AdminCommand::SendMessage(
+ RoomMessageEventContent::text_html(markdown_message, html_message),
+ ));
+ }
+ };
+
+ let admin_command = match command {
+ AdminCommands::RegisterAppservice => {
if body.len() > 2 && body[0].trim() == "```" && body.last().unwrap().trim() == "```" {
let appservice_config = body[1..body.len() - 1].join("\n");
let parsed_config = serde_yaml::from_str::<serde_yaml::Value>(&appservice_config);
@@ -233,47 +255,35 @@ pub fn try_parse_admin_command(
))
}
}
- "unregister_appservice" => {
- if args.len() == 1 {
- AdminCommand::UnregisterAppservice(args[0].to_owned())
+ AdminCommands::UnregisterAppservice {
+ appservice_identifier,
+ } => AdminCommand::UnregisterAppservice(appservice_identifier),
+ AdminCommands::ListAppservices => AdminCommand::ListAppservices,
+ AdminCommands::GetAuthChain { event_id } => {
+ let event_id = Arc::<EventId>::from(event_id);
+ if let Some(event) = db.rooms.get_pdu_json(&event_id)? {
+ let room_id_str = event
+ .get("room_id")
+ .and_then(|val| val.as_str())
+ .ok_or_else(|| Error::bad_database("Invalid event in database"))?;
+
+ let room_id = <&RoomId>::try_from(room_id_str).map_err(|_| {
+ Error::bad_database("Invalid room id field in event in database")
+ })?;
+ let start = Instant::now();
+ let count = server_server::get_auth_chain(room_id, vec![event_id], db)?.count();
+ let elapsed = start.elapsed();
+ return Ok(AdminCommand::SendMessage(
+ RoomMessageEventContent::text_plain(format!(
+ "Loaded auth chain with length {} in {:?}",
+ count, elapsed
+ )),
+ ));
} else {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- "Missing appservice identifier",
- ))
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain("Event not found."))
}
}
- "list_appservices" => AdminCommand::ListAppservices,
- "get_auth_chain" => {
- if args.len() == 1 {
- if let Ok(event_id) = EventId::parse_arc(args[0]) {
- if let Some(event) = db.rooms.get_pdu_json(&event_id)? {
- let room_id_str = event
- .get("room_id")
- .and_then(|val| val.as_str())
- .ok_or_else(|| Error::bad_database("Invalid event in database"))?;
-
- let room_id = <&RoomId>::try_from(room_id_str).map_err(|_| {
- Error::bad_database("Invalid room id field in event in database")
- })?;
- let start = Instant::now();
- let count =
- server_server::get_auth_chain(room_id, vec![event_id], db)?.count();
- let elapsed = start.elapsed();
- return Ok(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(format!(
- "Loaded auth chain with length {} in {:?}",
- count, elapsed
- )),
- ));
- }
- }
- }
-
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- "Usage: get_auth_chain <event-id>",
- ))
- }
- "parse_pdu" => {
+ AdminCommands::ParsePdu => {
if body.len() > 2 && body[0].trim() == "```" && body.last().unwrap().trim() == "```" {
let string = body[1..body.len() - 1].join("\n");
match serde_json::from_str(&string) {
@@ -312,59 +322,83 @@ pub fn try_parse_admin_command(
))
}
}
- "get_pdu" => {
- if args.len() == 1 {
- if let Ok(event_id) = EventId::parse(args[0]) {
- let mut outlier = false;
- let mut pdu_json = db.rooms.get_non_outlier_pdu_json(&event_id)?;
- if pdu_json.is_none() {
- outlier = true;
- pdu_json = db.rooms.get_pdu_json(&event_id)?;
- }
- match pdu_json {
- Some(json) => {
- let json_text = serde_json::to_string_pretty(&json)
- .expect("canonical json is valid json");
- AdminCommand::SendMessage(
- RoomMessageEventContent::text_html(
- format!("{}\n```json\n{}\n```",
- if outlier {
- "PDU is outlier"
- } else { "PDU was accepted"}, json_text),
- format!("<p>{}</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
- if outlier {
- "PDU is outlier"
- } else { "PDU was accepted"}, RawStr::new(&json_text).html_escape())
- ),
- )
- }
- None => AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- "PDU not found.",
- )),
- }
- } else {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- "Event ID could not be parsed.",
+ AdminCommands::GetPdu { event_id } => {
+ let mut outlier = false;
+ let mut pdu_json = db.rooms.get_non_outlier_pdu_json(&event_id)?;
+ if pdu_json.is_none() {
+ outlier = true;
+ pdu_json = db.rooms.get_pdu_json(&event_id)?;
+ }
+ match pdu_json {
+ Some(json) => {
+ let json_text =
+ serde_json::to_string_pretty(&json).expect("canonical json is valid json");
+ AdminCommand::SendMessage(RoomMessageEventContent::text_html(
+ format!(
+ "{}\n```json\n{}\n```",
+ if outlier {
+ "PDU is outlier"
+ } else {
+ "PDU was accepted"
+ },
+ json_text
+ ),
+ format!(
+ "<p>{}</p>\n<pre><code class=\"language-json\">{}\n</code></pre>\n",
+ if outlier {
+ "PDU is outlier"
+ } else {
+ "PDU was accepted"
+ },
+ RawStr::new(&json_text).html_escape()
+ ),
))
}
- } else {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- "Usage: get_pdu <eventid>",
- ))
+ None => {
+ AdminCommand::SendMessage(RoomMessageEventContent::text_plain("PDU not found."))
+ }
}
}
- "database_memory_usage" => AdminCommand::ShowMemoryUsage,
- _ => {
- let message = format!(
- "Unrecognized command <code>{}</code>, try <code>help</code> for a list of commands.",
- command,
- );
- AdminCommand::SendMessage(RoomMessageEventContent::text_html(
- html_to_markdown(&message),
- message,
- ))
- }
+ AdminCommands::DatabaseMemoryUsage => AdminCommand::ShowMemoryUsage,
};
- Ok(command)
+ Ok(admin_command)
+}
+
+fn usage_to_markdown(text: &str) -> String {
+ // For the conduit admin room, subcommands become main commands
+ let text = text.replace("SUBCOMMAND", "COMMAND");
+ let text = text.replace("subcommand", "command");
+
+ // Put the first line (command name and version text) on its own paragraph
+ let re = Regex::new("^(.*?)\n").expect("Regex compilation should not fail");
+ let text = re.replace_all(&text, "*$1*\n\n");
+
+ // Wrap command names in backticks
+ // (?m) enables multi-line mode for ^ and $
+ let re = Regex::new("(?m)^ ([a-z-]+) +(.*)$").expect("Regex compilation should not fail");
+ let text = re.replace_all(&text, " `$1`: $2");
+
+ // Add * to list items
+ let re = Regex::new("(?m)^ (.*)$").expect("Regex compilation should not fail");
+ let text = re.replace_all(&text, "* $1");
+
+ // Turn section names to headings
+ let re = Regex::new("(?m)^([A-Z-]+):$").expect("Regex compilation should not fail");
+ let text = re.replace_all(&text, "#### $1");
+
+ text.to_string()
+}
+
+fn markdown_to_html(text: &str) -> String {
+ // CommonMark's spec allows HTML tags; however, CLI required arguments look
+ // very much like tags so escape them.
+ let text = text.replace("<", "<").replace(">", ">");
+
+ let mut html_output = String::new();
+
+ let parser = pulldown_cmark::Parser::new(&text);
+ pulldown_cmark::html::push_html(&mut html_output, parser);
+
+ html_output
}
From cc3ef1a8be08b9212a16957062304d7bd5da1111 Mon Sep 17 00:00:00 2001
From: Andrei Vasiliu <whyte.vuhuni@gmail.com>
Date: Fri, 21 Jan 2022 11:06:16 +0200
Subject: [PATCH 3/7] Improve help text for admin commands
---
src/database/admin.rs | 27 ++++++++++++++++++++++-----
1 file changed, 22 insertions(+), 5 deletions(-)
diff --git a/src/database/admin.rs b/src/database/admin.rs
index f690bdf4..362ef294 100644
--- a/src/database/admin.rs
+++ b/src/database/admin.rs
@@ -147,6 +147,7 @@ impl Admin {
}
}
+// Parse chat messages from the admin room into an AdminCommand object
pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -> AdminCommand {
let mut argv: Vec<_> = command_line.split_whitespace().skip(1).collect();
@@ -191,10 +192,13 @@ pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -
#[derive(StructOpt)]
enum AdminCommands {
#[structopt(verbatim_doc_comment)]
- /// Register a bridge using its registration YAML
+ /// Register an appservice using its registration YAML
///
- /// This command needs a YAML generated by an appservice (such as a mautrix
- /// bridge), which must be provided in a code-block below the command.
+ /// This command needs a YAML generated by an appservice (such as a bridge),
+ /// which must be provided in a Markdown code-block below the command.
+ ///
+ /// Registering a new bridge using the ID of an existing bridge will replace
+ /// the old one.
///
/// Example:
/// ````
@@ -204,16 +208,27 @@ enum AdminCommands {
/// ```
/// ````
RegisterAppservice,
- /// Unregister a bridge using its ID
+
+ /// Unregister an appservice using its ID
+ ///
+ /// You can find the ID using the `list-appservices` command.
UnregisterAppservice { appservice_identifier: String },
- /// List all the currently registered bridges
+
+ /// List all the currently registered appservices
ListAppservices,
+
/// Get the auth_chain of a PDU
GetAuthChain { event_id: Box<EventId> },
+
/// Parse and print a PDU from a JSON
+ ///
+ /// The PDU event is only checked for validity and is not added to the
+ /// database.
ParsePdu,
+
/// Retrieve and print a PDU by ID from the Conduit database
GetPdu { event_id: Box<EventId> },
+
/// Print database memory usage statistics
DatabaseMemoryUsage,
}
@@ -365,6 +380,7 @@ pub fn try_parse_admin_command(
Ok(admin_command)
}
+// Utility to turn structopt's `--help` text to markdown.
fn usage_to_markdown(text: &str) -> String {
// For the conduit admin room, subcommands become main commands
let text = text.replace("SUBCOMMAND", "COMMAND");
@@ -390,6 +406,7 @@ fn usage_to_markdown(text: &str) -> String {
text.to_string()
}
+// Convert markdown to HTML using the CommonMark flavor
fn markdown_to_html(text: &str) -> String {
// CommonMark's spec allows HTML tags; however, CLI required arguments look
// very much like tags so escape them.
From 57979da28c0af4bc14787575d94308d5762e7dc6 Mon Sep 17 00:00:00 2001
From: Andrei Vasiliu <whyte.vuhuni@gmail.com>
Date: Fri, 21 Jan 2022 17:34:21 +0200
Subject: [PATCH 4/7] Change structopt to clap, remove markdown dependency
---
Cargo.lock | 75 +++++++++++++++++++++++-
Cargo.toml | 3 +-
src/database/admin.rs | 131 ++++++++++++++++++++++++++----------------
3 files changed, 156 insertions(+), 53 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 5be10f14..ae385fe6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -269,6 +269,33 @@ dependencies = [
"libloading",
]
+[[package]]
+name = "clap"
+version = "3.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a30c3bf9ff12dfe5dae53f0a96e0febcd18420d1c0e7fad77796d9d5c4b5375"
+dependencies = [
+ "bitflags",
+ "clap_derive",
+ "indexmap",
+ "lazy_static",
+ "os_str_bytes",
+ "textwrap",
+]
+
+[[package]]
+name = "clap_derive"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "517358c28fcef6607bf6f76108e02afad7e82297d132a6b846dcc1fc3efcd153"
+dependencies = [
+ "heck 0.4.0",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
[[package]]
name = "color_quant"
version = "1.1.0"
@@ -281,6 +308,7 @@ version = "0.2.0"
dependencies = [
"base64 0.13.0",
"bytes",
+ "clap",
"crossbeam",
"directories",
"heed",
@@ -630,7 +658,7 @@ version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c5f0096a91d210159eceb2ff5e1c4da18388a170e1e3ce948aac9c8fdbbf595"
dependencies = [
- "heck",
+ "heck 0.3.3",
"proc-macro2",
"quote",
"syn",
@@ -902,6 +930,12 @@ dependencies = [
"unicode-segmentation",
]
+[[package]]
+name = "heck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+
[[package]]
name = "heed"
version = "0.10.6"
@@ -1570,6 +1604,15 @@ dependencies = [
"num-traits",
]
+[[package]]
+name = "os_str_bytes"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+dependencies = [
+ "memchr",
+]
+
[[package]]
name = "page_size"
version = "0.4.2"
@@ -1728,6 +1771,30 @@ dependencies = [
"toml",
]
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
[[package]]
name = "proc-macro-hack"
version = "0.5.19"
@@ -2863,6 +2930,12 @@ dependencies = [
"winapi",
]
+[[package]]
+name = "textwrap"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80"
+
[[package]]
name = "thiserror"
version = "1.0.30"
diff --git a/Cargo.toml b/Cargo.toml
index 9a2d2fdb..3f8677d6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -86,8 +86,7 @@ thread_local = "1.1.3"
hmac = "0.11.0"
sha-1 = "0.9.8"
# used for conduit's CLI and admin room command parsing
-structopt = { version = "0.3.25", default-features = false }
-pulldown-cmark = "0.9.1"
+clap = { version = "3.0.10", default-features = false, features = ["std", "derive"] }
[features]
default = ["conduit_bin", "backend_sqlite", "backend_rocksdb"]
diff --git a/src/database/admin.rs b/src/database/admin.rs
index 362ef294..59b8acdf 100644
--- a/src/database/admin.rs
+++ b/src/database/admin.rs
@@ -5,6 +5,7 @@ use crate::{
pdu::PduBuilder,
server_server, Database, PduEvent,
};
+use clap::Parser;
use regex::Regex;
use rocket::{
futures::{channel::mpsc, stream::StreamExt},
@@ -15,7 +16,6 @@ use ruma::{
EventId, RoomId, RoomVersionId, UserId,
};
use serde_json::value::to_raw_value;
-use structopt::StructOpt;
use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
use tracing::warn;
@@ -155,7 +155,7 @@ pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -
Some(command) => *command,
None => {
let markdown_message = "No command given. Use `help` for a list of commands.";
- let html_message = markdown_to_html(&markdown_message);
+ let html_message = "No command given. Use <code>help</code> for a list of commands.";
return AdminCommand::SendMessage(RoomMessageEventContent::text_html(
markdown_message,
@@ -164,10 +164,17 @@ pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -
}
};
+ // Replace `help command` with `command --help`
+ // Clap has a help subcommand, but it omits the long help description.
+ if argv[0] == "help" {
+ argv.remove(0);
+ argv.push("--help");
+ }
+
// Backwards compatibility with `register_appservice`-style commands
let command_with_dashes;
- if command_line.contains("_") {
- command_with_dashes = command_name.replace("_", "-");
+ if argv[0].contains("_") {
+ command_with_dashes = argv[0].replace("_", "-");
argv[0] = &command_with_dashes;
}
@@ -179,7 +186,11 @@ pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -
```\n{}\n```",
command_name, error,
);
- let html_message = markdown_to_html(&markdown_message);
+ let html_message = format!(
+ "Encountered an error while handling the <code>{}</code> command:\n\
+ <pre>\n{}\n</pre>",
+ command_name, error,
+ );
AdminCommand::SendMessage(RoomMessageEventContent::text_html(
markdown_message,
@@ -189,9 +200,10 @@ pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -
}
}
-#[derive(StructOpt)]
+#[derive(Parser)]
+#[clap(name = "@conduit:example.com", version = env!("CARGO_PKG_VERSION"))]
enum AdminCommands {
- #[structopt(verbatim_doc_comment)]
+ #[clap(verbatim_doc_comment)]
/// Register an appservice using its registration YAML
///
/// This command needs a YAML generated by an appservice (such as a bridge),
@@ -200,25 +212,25 @@ enum AdminCommands {
/// Registering a new bridge using the ID of an existing bridge will replace
/// the old one.
///
- /// Example:
- /// ````
- /// @conduit:example.com: register-appservice
- /// ```
- /// yaml content here
- /// ```
- /// ````
+ /// [add-yaml-block-to-usage]
RegisterAppservice,
/// Unregister an appservice using its ID
- ///
+ ///
/// You can find the ID using the `list-appservices` command.
- UnregisterAppservice { appservice_identifier: String },
+ UnregisterAppservice {
+ /// The appservice to unregister
+ appservice_identifier: String,
+ },
/// List all the currently registered appservices
ListAppservices,
/// Get the auth_chain of a PDU
- GetAuthChain { event_id: Box<EventId> },
+ GetAuthChain {
+ /// An event ID (the $ character followed by the base64 reference hash)
+ event_id: Box<EventId>,
+ },
/// Parse and print a PDU from a JSON
///
@@ -227,7 +239,10 @@ enum AdminCommands {
ParsePdu,
/// Retrieve and print a PDU by ID from the Conduit database
- GetPdu { event_id: Box<EventId> },
+ GetPdu {
+ /// An event ID (a $ followed by the base64 reference hash)
+ event_id: Box<EventId>,
+ },
/// Print database memory usage statistics
DatabaseMemoryUsage,
@@ -239,16 +254,16 @@ pub fn try_parse_admin_command(
body: Vec<&str>,
) -> Result<AdminCommand> {
argv.insert(0, "@conduit:example.com:");
- let command = match AdminCommands::from_iter_safe(argv) {
+ let command = match AdminCommands::try_parse_from(argv) {
Ok(command) => command,
Err(error) => {
- println!("Before:\n{}\n", error.to_string());
- let markdown_message = usage_to_markdown(&error.to_string())
+ let message = error
+ .to_string()
.replace("example.com", db.globals.server_name().as_str());
- let html_message = markdown_to_html(&markdown_message);
+ let html_message = usage_to_html(&message);
return Ok(AdminCommand::SendMessage(
- RoomMessageEventContent::text_html(markdown_message, html_message),
+ RoomMessageEventContent::text_html(message, html_message),
));
}
};
@@ -380,42 +395,58 @@ pub fn try_parse_admin_command(
Ok(admin_command)
}
-// Utility to turn structopt's `--help` text to markdown.
-fn usage_to_markdown(text: &str) -> String {
+// Utility to turn clap's `--help` text to HTML.
+fn usage_to_html(text: &str) -> String {
// For the conduit admin room, subcommands become main commands
let text = text.replace("SUBCOMMAND", "COMMAND");
let text = text.replace("subcommand", "command");
- // Put the first line (command name and version text) on its own paragraph
+ // Escape option names (e.g. `<element-id>`) since they look like HTML tags
+ let text = text.replace("<", "<").replace(">", ">");
+
+ // Italicize the first line (command name and version text)
let re = Regex::new("^(.*?)\n").expect("Regex compilation should not fail");
- let text = re.replace_all(&text, "*$1*\n\n");
+ let text = re.replace_all(&text, "<em>$1</em>\n");
- // Wrap command names in backticks
+ // Unmerge wrapped lines
+ let text = text.replace("\n ", " ");
+
+ // Wrap option names in backticks. The lines look like:
+ // -V, --version Prints version information
+ // And are converted to:
+ // <code>-V, --version</code>: Prints version information
// (?m) enables multi-line mode for ^ and $
- let re = Regex::new("(?m)^ ([a-z-]+) +(.*)$").expect("Regex compilation should not fail");
- let text = re.replace_all(&text, " `$1`: $2");
+ let re = Regex::new("(?m)^ (([a-zA-Z_&;-]+(, )?)+) +(.*)$")
+ .expect("Regex compilation should not fail");
+ let text = re.replace_all(&text, "<code>$1</code>: $4");
- // Add * to list items
- let re = Regex::new("(?m)^ (.*)$").expect("Regex compilation should not fail");
- let text = re.replace_all(&text, "* $1");
+ // // Enclose examples in code blocks
+ // // (?ms) enables multi-line mode and dot-matches-all
+ // let re =
+ // Regex::new("(?ms)^Example:\n(.*?)\nUSAGE:$").expect("Regex compilation should not fail");
+ // let text = re.replace_all(&text, "EXAMPLE:\n<pre>$1</pre>\nUSAGE:");
- // Turn section names to headings
- let re = Regex::new("(?m)^([A-Z-]+):$").expect("Regex compilation should not fail");
- let text = re.replace_all(&text, "#### $1");
+ let has_yaml_block_marker = text.contains("\n[add-yaml-block-to-usage]\n");
+ let text = text.replace("\n[add-yaml-block-to-usage]\n", "");
+
+ // Add HTML line-breaks
+ let text = text.replace("\n", "<br>\n");
+
+ let text = if !has_yaml_block_marker {
+ // Wrap the usage line in code tags
+ let re = Regex::new("(?m)^USAGE:<br>\n (@conduit:.*)<br>$")
+ .expect("Regex compilation should not fail");
+ re.replace_all(&text, "USAGE:<br>\n<code>$1</code><br>")
+ } else {
+ // Wrap the usage line in a code block, and add a yaml block example
+ // This makes the usage of e.g. `register-appservice` more accurate
+ let re = Regex::new("(?m)^USAGE:<br>\n (.*?)<br>\n<br>\n")
+ .expect("Regex compilation should not fail");
+ re.replace_all(
+ &text,
+ "USAGE:<br>\n<pre>$1\n```\nyaml content here\n```</pre>",
+ )
+ };
text.to_string()
}
-
-// Convert markdown to HTML using the CommonMark flavor
-fn markdown_to_html(text: &str) -> String {
- // CommonMark's spec allows HTML tags; however, CLI required arguments look
- // very much like tags so escape them.
- let text = text.replace("<", "<").replace(">", ">");
-
- let mut html_output = String::new();
-
- let parser = pulldown_cmark::Parser::new(&text);
- pulldown_cmark::html::push_html(&mut html_output, parser);
-
- html_output
-}
From 677f044d13985f794afecdb0bbf62fbab3a52dec Mon Sep 17 00:00:00 2001
From: Andrei Vasiliu <whyte.vuhuni@gmail.com>
Date: Sun, 30 Jan 2022 23:15:53 +0200
Subject: [PATCH 5/7] Refactor admin code to always defer command processing
---
src/client_server/report.rs | 12 +-
src/database/admin.rs | 304 ++++++++++++++++++------------------
src/database/rooms.rs | 8 +-
3 files changed, 155 insertions(+), 169 deletions(-)
diff --git a/src/client_server/report.rs b/src/client_server/report.rs
index ae069849..032e446c 100644
--- a/src/client_server/report.rs
+++ b/src/client_server/report.rs
@@ -1,7 +1,4 @@
-use crate::{
- database::{admin::AdminCommand, DatabaseGuard},
- ConduitResult, Error, Ruma,
-};
+use crate::{database::DatabaseGuard, ConduitResult, Error, Ruma};
use ruma::{
api::client::{error::ErrorKind, r0::room::report_content},
events::room::message,
@@ -50,8 +47,8 @@ pub async fn report_event_route(
));
};
- db.admin.send(AdminCommand::SendMessage(
- message::RoomMessageEventContent::text_html(
+ db.admin
+ .send_message(message::RoomMessageEventContent::text_html(
format!(
"Report received from: {}\n\n\
Event ID: {}\n\
@@ -75,8 +72,7 @@ pub async fn report_event_route(
body.score,
RawStr::new(&body.reason).html_escape()
),
- ),
- ));
+ ));
db.flush()?;
diff --git a/src/database/admin.rs b/src/database/admin.rs
index dbd20e44..ea08f65a 100644
--- a/src/database/admin.rs
+++ b/src/database/admin.rs
@@ -19,25 +19,21 @@ use serde_json::value::to_raw_value;
use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
use tracing::warn;
-pub enum AdminCommand {
- RegisterAppservice(serde_yaml::Value),
- UnregisterAppservice(String),
- ListAppservices,
- ListLocalUsers,
- ShowMemoryUsage,
+pub enum AdminRoomEvent {
+ ProcessMessage(String),
SendMessage(RoomMessageEventContent),
}
#[derive(Clone)]
pub struct Admin {
- pub sender: mpsc::UnboundedSender<AdminCommand>,
+ pub sender: mpsc::UnboundedSender<AdminRoomEvent>,
}
impl Admin {
pub fn start_handler(
&self,
db: Arc<RwLock<Database>>,
- mut receiver: mpsc::UnboundedReceiver<AdminCommand>,
+ mut receiver: mpsc::UnboundedReceiver<AdminRoomEvent>,
) {
tokio::spawn(async move {
// TODO: Use futures when we have long admin commands
@@ -56,7 +52,7 @@ impl Admin {
.try_into()
.expect("#admins:server_name is a valid room alias"),
)
- .unwrap();
+ .expect("Admin room must exist");
let conduit_room = match conduit_room {
None => {
@@ -105,46 +101,13 @@ impl Admin {
let state_lock = mutex_state.lock().await;
match event {
- AdminCommand::ListLocalUsers => {
- match guard.users.list_local_users() {
- Ok(users) => {
- let mut msg: String = format!("Found {} local user account(s):\n", users.len());
- msg += &users.join("\n");
- send_message(RoomMessageEventContent::text_plain(&msg), guard, &state_lock);
- }
- Err(e) => {
- send_message(RoomMessageEventContent::text_plain(e.to_string()), guard, &state_lock);
- }
- }
+ AdminRoomEvent::SendMessage(content) => {
+ send_message(content, guard, &state_lock);
}
- AdminCommand::RegisterAppservice(yaml) => {
- guard.appservice.register_appservice(yaml).unwrap(); // TODO handle error
- }
- AdminCommand::UnregisterAppservice(service_name) => {
- guard.appservice.unregister_appservice(&service_name).unwrap(); // TODO: see above
- }
- AdminCommand::ListAppservices => {
- if let Ok(appservices) = guard.appservice.iter_ids().map(|ids| ids.collect::<Vec<_>>()) {
- let count = appservices.len();
- let output = format!(
- "Appservices ({}): {}",
- count,
- appservices.into_iter().filter_map(|r| r.ok()).collect::<Vec<_>>().join(", ")
- );
- send_message(RoomMessageEventContent::text_plain(output), guard, &state_lock);
- } else {
- send_message(RoomMessageEventContent::text_plain("Failed to get appservices."), guard, &state_lock);
- }
- }
- AdminCommand::ShowMemoryUsage => {
- if let Ok(response) = guard._db.memory_usage() {
- send_message(RoomMessageEventContent::text_plain(response), guard, &state_lock);
- } else {
- send_message(RoomMessageEventContent::text_plain("Failed to get database memory usage.".to_owned()), guard, &state_lock);
- }
- }
- AdminCommand::SendMessage(message) => {
- send_message(message, guard, &state_lock);
+ AdminRoomEvent::ProcessMessage(room_message) => {
+ let reply_message = process_admin_message(&*guard, room_message);
+
+ send_message(reply_message, guard, &state_lock);
}
}
@@ -155,67 +118,81 @@ impl Admin {
});
}
- pub fn send(&self, command: AdminCommand) {
- self.sender.unbounded_send(command).unwrap();
+ pub fn process_message(&self, room_message: String) {
+ self.sender
+ .unbounded_send(AdminRoomEvent::ProcessMessage(room_message))
+ .unwrap();
+ }
+
+ pub fn send_message(&self, message_content: RoomMessageEventContent) {
+ self.sender
+ .unbounded_send(AdminRoomEvent::SendMessage(message_content))
+ .unwrap();
+ }
+}
+
+// Parse and process a message from the admin room
+pub fn process_admin_message(db: &Database, room_message: String) -> RoomMessageEventContent {
+ let mut lines = room_message.lines();
+ let command_line = lines.next().expect("each string has at least one line");
+ let body: Vec<_> = lines.collect();
+
+ let admin_command = match parse_admin_command(&command_line) {
+ Ok(command) => command,
+ Err(error) => {
+ let message = error
+ .to_string()
+ .replace("example.com", db.globals.server_name().as_str());
+ let html_message = usage_to_html(&message);
+
+ return RoomMessageEventContent::text_html(message, html_message);
+ }
+ };
+
+ match process_admin_command(db, admin_command, body) {
+ Ok(reply_message) => reply_message,
+ Err(error) => {
+ let markdown_message = format!(
+ "Encountered an error while handling the command:\n\
+ ```\n{}\n```",
+ error,
+ );
+ let html_message = format!(
+ "Encountered an error while handling the command:\n\
+ <pre>\n{}\n</pre>",
+ error,
+ );
+
+ RoomMessageEventContent::text_html(markdown_message, html_message)
+ }
}
}
// Parse chat messages from the admin room into an AdminCommand object
-pub fn parse_admin_command(db: &Database, command_line: &str, body: Vec<&str>) -> AdminCommand {
- let mut argv: Vec<_> = command_line.split_whitespace().skip(1).collect();
-
- let command_name = match argv.get(0) {
- Some(command) => *command,
- None => {
- let markdown_message = "No command given. Use `help` for a list of commands.";
- let html_message = "No command given. Use <code>help</code> for a list of commands.";
-
- return AdminCommand::SendMessage(RoomMessageEventContent::text_html(
- markdown_message,
- html_message,
- ));
- }
- };
+fn parse_admin_command(command_line: &str) -> std::result::Result<AdminCommand, String> {
+ // Note: argv[0] is `@conduit:servername:`, which is treated as the main command
+ let mut argv: Vec<_> = command_line.split_whitespace().collect();
// Replace `help command` with `command --help`
// Clap has a help subcommand, but it omits the long help description.
- if argv[0] == "help" {
- argv.remove(0);
+ if argv.len() > 1 && argv[1] == "help" {
+ argv.remove(1);
argv.push("--help");
}
// Backwards compatibility with `register_appservice`-style commands
let command_with_dashes;
- if argv[0].contains("_") {
- command_with_dashes = argv[0].replace("_", "-");
- argv[0] = &command_with_dashes;
+ if argv.len() > 1 && argv[1].contains("_") {
+ command_with_dashes = argv[1].replace("_", "-");
+ argv[1] = &command_with_dashes;
}
- match try_parse_admin_command(db, argv, body) {
- Ok(admin_command) => admin_command,
- Err(error) => {
- let markdown_message = format!(
- "Encountered an error while handling the `{}` command:\n\
- ```\n{}\n```",
- command_name, error,
- );
- let html_message = format!(
- "Encountered an error while handling the <code>{}</code> command:\n\
- <pre>\n{}\n</pre>",
- command_name, error,
- );
-
- AdminCommand::SendMessage(RoomMessageEventContent::text_html(
- markdown_message,
- html_message,
- ))
- }
- }
+ AdminCommand::try_parse_from(argv).map_err(|error| error.to_string())
}
#[derive(Parser)]
#[clap(name = "@conduit:example.com", version = env!("CARGO_PKG_VERSION"))]
-enum AdminCommands {
+enum AdminCommand {
#[clap(verbatim_doc_comment)]
/// Register an appservice using its registration YAML
///
@@ -264,49 +241,70 @@ enum AdminCommands {
DatabaseMemoryUsage,
}
-pub fn try_parse_admin_command(
+fn process_admin_command(
db: &Database,
- mut argv: Vec<&str>,
+ command: AdminCommand,
body: Vec<&str>,
-) -> Result<AdminCommand> {
- argv.insert(0, "@conduit:example.com:");
- let command = match AdminCommands::try_parse_from(argv) {
- Ok(command) => command,
- Err(error) => {
- let message = error
- .to_string()
- .replace("example.com", db.globals.server_name().as_str());
- let html_message = usage_to_html(&message);
-
- return Ok(AdminCommand::SendMessage(
- RoomMessageEventContent::text_html(message, html_message),
- ));
- }
- };
-
- let admin_command = match command {
- AdminCommands::RegisterAppservice => {
+) -> Result<RoomMessageEventContent> {
+ let reply_message_content = match command {
+ AdminCommand::RegisterAppservice => {
if body.len() > 2 && body[0].trim() == "```" && body.last().unwrap().trim() == "```" {
let appservice_config = body[1..body.len() - 1].join("\n");
let parsed_config = serde_yaml::from_str::<serde_yaml::Value>(&appservice_config);
match parsed_config {
- Ok(yaml) => AdminCommand::RegisterAppservice(yaml),
- Err(e) => AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- format!("Could not parse appservice config: {}", e),
+ Ok(yaml) => match db.appservice.register_appservice(yaml) {
+ Ok(()) => RoomMessageEventContent::text_plain("Appservice registered."),
+ Err(e) => RoomMessageEventContent::text_plain(format!(
+ "Failed to register appservice: {}",
+ e
+ )),
+ },
+ Err(e) => RoomMessageEventContent::text_plain(format!(
+ "Could not parse appservice config: {}",
+ e
)),
}
} else {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- "Expected code block in command body.",
- ))
+ RoomMessageEventContent::text_plain(
+ "Expected code block in command body. Add --help for details.",
+ )
}
}
- AdminCommands::UnregisterAppservice {
+ AdminCommand::UnregisterAppservice {
appservice_identifier,
- } => AdminCommand::UnregisterAppservice(appservice_identifier),
- AdminCommands::ListAppservices => AdminCommand::ListAppservices,
- AdminCommands::ListLocalUsers => AdminCommand::ListLocalUsers,
- AdminCommands::GetAuthChain { event_id } => {
+ } => match db.appservice.unregister_appservice(&appservice_identifier) {
+ Ok(()) => RoomMessageEventContent::text_plain("Appservice unregistered."),
+ Err(e) => RoomMessageEventContent::text_plain(format!(
+ "Failed to unregister appservice: {}",
+ e
+ )),
+ },
+ AdminCommand::ListAppservices => {
+ if let Ok(appservices) = db.appservice.iter_ids().map(|ids| ids.collect::<Vec<_>>()) {
+ let count = appservices.len();
+ let output = format!(
+ "Appservices ({}): {}",
+ count,
+ appservices
+ .into_iter()
+ .filter_map(|r| r.ok())
+ .collect::<Vec<_>>()
+ .join(", ")
+ );
+ RoomMessageEventContent::text_plain(output)
+ } else {
+ RoomMessageEventContent::text_plain("Failed to get appservices.")
+ }
+ }
+ AdminCommand::ListLocalUsers => match db.users.list_local_users() {
+ Ok(users) => {
+ let mut msg: String = format!("Found {} local user account(s):\n", users.len());
+ msg += &users.join("\n");
+ RoomMessageEventContent::text_plain(&msg)
+ }
+ Err(e) => RoomMessageEventContent::text_plain(e.to_string()),
+ },
+ AdminCommand::GetAuthChain { event_id } => {
let event_id = Arc::<EventId>::from(event_id);
if let Some(event) = db.rooms.get_pdu_json(&event_id)? {
let room_id_str = event
@@ -320,17 +318,15 @@ pub fn try_parse_admin_command(
let start = Instant::now();
let count = server_server::get_auth_chain(room_id, vec![event_id], db)?.count();
let elapsed = start.elapsed();
- return Ok(AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(format!(
- "Loaded auth chain with length {} in {:?}",
- count, elapsed
- )),
- ));
+ RoomMessageEventContent::text_plain(format!(
+ "Loaded auth chain with length {} in {:?}",
+ count, elapsed
+ ))
} else {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain("Event not found."))
+ RoomMessageEventContent::text_plain("Event not found.")
}
}
- AdminCommands::ParsePdu => {
+ AdminCommand::ParsePdu => {
if body.len() > 2 && body[0].trim() == "```" && body.last().unwrap().trim() == "```" {
let string = body[1..body.len() - 1].join("\n");
match serde_json::from_str(&string) {
@@ -346,30 +342,26 @@ pub fn try_parse_admin_command(
match serde_json::from_value::<PduEvent>(
serde_json::to_value(value).expect("value is json"),
) {
- Ok(pdu) => {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- format!("EventId: {:?}\n{:#?}", event_id, pdu),
- ))
- }
- Err(e) => AdminCommand::SendMessage(
- RoomMessageEventContent::text_plain(format!(
- "EventId: {:?}\nCould not parse event: {}",
- event_id, e
- )),
- ),
+ Ok(pdu) => RoomMessageEventContent::text_plain(format!(
+ "EventId: {:?}\n{:#?}",
+ event_id, pdu
+ )),
+ Err(e) => RoomMessageEventContent::text_plain(format!(
+ "EventId: {:?}\nCould not parse event: {}",
+ event_id, e
+ )),
}
}
- Err(e) => AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- format!("Invalid json in command body: {}", e),
+ Err(e) => RoomMessageEventContent::text_plain(format!(
+ "Invalid json in command body: {}",
+ e
)),
}
} else {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain(
- "Expected code block in command body.",
- ))
+ RoomMessageEventContent::text_plain("Expected code block in command body.")
}
}
- AdminCommands::GetPdu { event_id } => {
+ AdminCommand::GetPdu { event_id } => {
let mut outlier = false;
let mut pdu_json = db.rooms.get_non_outlier_pdu_json(&event_id)?;
if pdu_json.is_none() {
@@ -380,7 +372,7 @@ pub fn try_parse_admin_command(
Some(json) => {
let json_text =
serde_json::to_string_pretty(&json).expect("canonical json is valid json");
- AdminCommand::SendMessage(RoomMessageEventContent::text_html(
+ RoomMessageEventContent::text_html(
format!(
"{}\n```json\n{}\n```",
if outlier {
@@ -399,17 +391,21 @@ pub fn try_parse_admin_command(
},
RawStr::new(&json_text).html_escape()
),
- ))
- }
- None => {
- AdminCommand::SendMessage(RoomMessageEventContent::text_plain("PDU not found."))
+ )
}
+ None => RoomMessageEventContent::text_plain("PDU not found."),
}
}
- AdminCommands::DatabaseMemoryUsage => AdminCommand::ShowMemoryUsage,
+ AdminCommand::DatabaseMemoryUsage => match db._db.memory_usage() {
+ Ok(response) => RoomMessageEventContent::text_plain(response),
+ Err(e) => RoomMessageEventContent::text_plain(format!(
+ "Failed to get database memory usage: {}",
+ e
+ )),
+ },
};
- Ok(admin_command)
+ Ok(reply_message_content)
}
// Utility to turn clap's `--help` text to HTML.
diff --git a/src/database/rooms.rs b/src/database/rooms.rs
index 1f4566fe..2303b0dd 100644
--- a/src/database/rooms.rs
+++ b/src/database/rooms.rs
@@ -3,7 +3,6 @@ mod edus;
pub use edus::RoomEdus;
use crate::{
- database::admin::parse_admin_command,
pdu::{EventHash, PduBuilder},
utils, Database, Error, PduEvent, Result,
};
@@ -1490,12 +1489,7 @@ impl Rooms {
.as_ref()
== Some(&pdu.room_id)
{
- let mut lines = body.lines();
- let command_line = lines.next().expect("each string has at least one line");
- let body: Vec<_> = lines.collect();
-
- let command = parse_admin_command(db, command_line, body);
- db.admin.send(command);
+ db.admin.process_message(body.to_string());
}
}
}
From 87225e70c3441c9ddd96d9fe0c4dd4e5a2c1289e Mon Sep 17 00:00:00 2001
From: Andrei Vasiliu <whyte.vuhuni@gmail.com>
Date: Wed, 2 Feb 2022 21:35:57 +0200
Subject: [PATCH 6/7] Parse admin command body templates from doc comments
---
src/database/admin.rs | 69 ++++++++++++++++++++++++++++++-------------
1 file changed, 48 insertions(+), 21 deletions(-)
diff --git a/src/database/admin.rs b/src/database/admin.rs
index ea08f65a..c7150493 100644
--- a/src/database/admin.rs
+++ b/src/database/admin.rs
@@ -132,7 +132,7 @@ impl Admin {
}
// Parse and process a message from the admin room
-pub fn process_admin_message(db: &Database, room_message: String) -> RoomMessageEventContent {
+fn process_admin_message(db: &Database, room_message: String) -> RoomMessageEventContent {
let mut lines = room_message.lines();
let command_line = lines.next().expect("each string has at least one line");
let body: Vec<_> = lines.collect();
@@ -202,7 +202,10 @@ enum AdminCommand {
/// Registering a new bridge using the ID of an existing bridge will replace
/// the old one.
///
- /// [add-yaml-block-to-usage]
+ /// [commandbody]
+ /// # ```
+ /// # yaml content here
+ /// # ```
RegisterAppservice,
/// Unregister an appservice using its ID
@@ -225,10 +228,16 @@ enum AdminCommand {
event_id: Box<EventId>,
},
+ #[clap(verbatim_doc_comment)]
/// Parse and print a PDU from a JSON
///
/// The PDU event is only checked for validity and is not added to the
/// database.
+ ///
+ /// [commandbody]
+ /// # ```
+ /// # PDU json content here
+ /// # ```
ParsePdu,
/// Retrieve and print a PDU by ID from the Conduit database
@@ -433,33 +442,51 @@ fn usage_to_html(text: &str) -> String {
.expect("Regex compilation should not fail");
let text = re.replace_all(&text, "<code>$1</code>: $4");
- // // Enclose examples in code blocks
- // // (?ms) enables multi-line mode and dot-matches-all
- // let re =
- // Regex::new("(?ms)^Example:\n(.*?)\nUSAGE:$").expect("Regex compilation should not fail");
- // let text = re.replace_all(&text, "EXAMPLE:\n<pre>$1</pre>\nUSAGE:");
+ // Look for a `[commandbody]` tag. If it exists, use all lines below it that
+ // start with a `#` in the USAGE section.
+ let mut text_lines: Vec<&str> = text.lines().collect();
+ let mut command_body = String::new();
- let has_yaml_block_marker = text.contains("\n[add-yaml-block-to-usage]\n");
- let text = text.replace("\n[add-yaml-block-to-usage]\n", "");
+ if let Some(line_index) = text_lines.iter().position(|line| *line == "[commandbody]") {
+ text_lines.remove(line_index);
- // Add HTML line-breaks
- let text = text.replace("\n", "<br>\n");
+ while text_lines
+ .get(line_index)
+ .map(|line| line.starts_with("#"))
+ .unwrap_or(false)
+ {
+ command_body += if text_lines[line_index].starts_with("# ") {
+ &text_lines[line_index][2..]
+ } else {
+ &text_lines[line_index][1..]
+ };
+ command_body += "[nobr]\n";
+ text_lines.remove(line_index);
+ }
+ }
- let text = if !has_yaml_block_marker {
+ let text = text_lines.join("\n");
+
+ // Improve the usage section
+ let text = if command_body.is_empty() {
// Wrap the usage line in code tags
- let re = Regex::new("(?m)^USAGE:<br>\n (@conduit:.*)<br>$")
+ let re = Regex::new("(?m)^USAGE:\n (@conduit:.*)$")
.expect("Regex compilation should not fail");
- re.replace_all(&text, "USAGE:<br>\n<code>$1</code><br>")
+ re.replace_all(&text, "USAGE:\n<code>$1</code>").to_string()
} else {
// Wrap the usage line in a code block, and add a yaml block example
// This makes the usage of e.g. `register-appservice` more accurate
- let re = Regex::new("(?m)^USAGE:<br>\n (.*?)<br>\n<br>\n")
- .expect("Regex compilation should not fail");
- re.replace_all(
- &text,
- "USAGE:<br>\n<pre>$1\n```\nyaml content here\n```</pre>",
- )
+ let re =
+ Regex::new("(?m)^USAGE:\n (.*?)\n\n").expect("Regex compilation should not fail");
+ re.replace_all(&text, "USAGE:\n<pre>$1[nobr]\n[commandbodyblock]</pre>")
+ .replace("[commandbodyblock]", &command_body)
};
- text.to_string()
+ // Add HTML line-breaks
+ let text = text
+ .replace("\n\n\n", "\n\n")
+ .replace("\n", "<br>\n")
+ .replace("[nobr]<br>", "");
+
+ text
}
From 6399a7fe4e07f9992ac8ca0412dc48c87d4d0456 Mon Sep 17 00:00:00 2001
From: Andrei Vasiliu <whyte.vuhuni@gmail.com>
Date: Thu, 3 Feb 2022 20:21:04 +0200
Subject: [PATCH 7/7] Remove dash from admin command help
---
src/database/admin.rs | 17 ++++++++++++-----
1 file changed, 12 insertions(+), 5 deletions(-)
diff --git a/src/database/admin.rs b/src/database/admin.rs
index 8f90e4d5..34bef5f5 100644
--- a/src/database/admin.rs
+++ b/src/database/admin.rs
@@ -13,7 +13,7 @@ use rocket::{
};
use ruma::{
events::{room::message::RoomMessageEventContent, EventType},
- EventId, RoomId, RoomVersionId, UserId,
+ EventId, RoomId, RoomVersionId, ServerName, UserId,
};
use serde_json::value::to_raw_value;
use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
@@ -140,10 +140,11 @@ fn process_admin_message(db: &Database, room_message: String) -> RoomMessageEven
let admin_command = match parse_admin_command(&command_line) {
Ok(command) => command,
Err(error) => {
+ let server_name = db.globals.server_name();
let message = error
.to_string()
- .replace("example.com", db.globals.server_name().as_str());
- let html_message = usage_to_html(&message);
+ .replace("server.name", server_name.as_str());
+ let html_message = usage_to_html(&message, server_name);
return RoomMessageEventContent::text_html(message, html_message);
}
@@ -191,7 +192,7 @@ fn parse_admin_command(command_line: &str) -> std::result::Result<AdminCommand,
}
#[derive(Parser)]
-#[clap(name = "@conduit:example.com", version = env!("CARGO_PKG_VERSION"))]
+#[clap(name = "@conduit:server.name:", version = env!("CARGO_PKG_VERSION"))]
enum AdminCommand {
#[clap(verbatim_doc_comment)]
/// Register an appservice using its registration YAML
@@ -421,7 +422,13 @@ fn process_admin_command(
}
// Utility to turn clap's `--help` text to HTML.
-fn usage_to_html(text: &str) -> String {
+fn usage_to_html(text: &str, server_name: &ServerName) -> String {
+ // Replace `@conduit:servername:-subcmdname` with `@conduit:servername: subcmdname`
+ let text = text.replace(
+ &format!("@conduit:{}:-", server_name),
+ &format!("@conduit:{}: ", server_name),
+ );
+
// For the conduit admin room, subcommands become main commands
let text = text.replace("SUBCOMMAND", "COMMAND");
let text = text.replace("subcommand", "command");