Updates the mtxcli app (#254)

* Updates the mtxcli app

mtxcli:
- Simple chat now functional!
- All strings use translations
- Updates the README
- updates mtxcli to handle PDDB existence check

Adds *.pyc to .gitignore

Signed-off-by: Tom Marble <tmarble@info9.net>
This commit is contained in:
Tom Marble 2022-10-26 12:16:09 -05:00 committed by GitHub
parent bad8ba5ea2
commit e55c7495b1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 1015 additions and 44 deletions

1
.gitignore vendored
View file

@ -74,4 +74,5 @@ share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
*.pyc
MANIFEST

7
Cargo.lock generated
View file

@ -2226,7 +2226,10 @@ dependencies = [
"log",
"num-derive",
"num-traits",
"percent-encoding",
"serde",
"trng",
"ureq",
"xous 0.9.20 (registry+https://github.com/rust-lang/crates.io-index)",
"xous-api-log",
"xous-api-names",
@ -2563,9 +2566,9 @@ dependencies = [
[[package]]
name = "percent-encoding"
version = "2.1.0"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
[[package]]
name = "perflib"

View file

@ -25,6 +25,10 @@ content-plugin-api = {path = "../../services/content-plugin-api"} # all content
com = {path = "../../services/com"}
llio = {path = "../../services/llio"}
codec = {path = "../../services/codec"}
# new dependencies for mtxcli
percent-encoding = "2.2"
serde = { version = "1.0", features = [ "derive" ] }
ureq = { version = "2.5", features = ["json"] }
[features]
default = []

View file

@ -1,33 +1,36 @@
# MTXCLI
# mtxcli
This is a new Matrix chat application which will be derived from REPL.
This is a simple Matrix chat application.
![screenshot](mtxcli_screenshot.png)
## Background
This is a simple [Matrix chat](https://matrix.org/) application based on the REPL framework.
This is a simple [Matrix chat](https://matrix.org/) application based on the REPL framework and adapted from the Desktop project [mtxcli](https://github.com/betrusted-io/mtxcli)
## Setup
In order to simplify the **mtxcli** application as much as possible the following
must be setup on a conventional device before using Betrusted (laptop, mobile phone).
* Create a new Matrix user:
* Create a new Matrix user (if needed):
* https://matrix.org/faq/#how-do-i-get-an-account-and-get-started%3F
* https://matrix.org/docs/projects/try-matrix-now/
* Find (or create) a new room to join for chatting:
* https://doc.matrix.tu-dresden.de/en/rooms/create/
* https://spec.matrix.org/latest/#room-structure
* Join the room
* Save the configuration in the pddb
* `/set user @myname:matrix.org`
* `/set password AbigSecret`
* `/set password MySecret`
* `/set room #my-chat-room`
## Commands
The following commands are available in **mtxcli**:
* `/help [cmd]` -- shows help message for all commands (or one cmd if given)
* `/login` -- logs in to the server (assumes user and password are set)
* `/logout` -- logs out of the server
* `/get key` -- shows value of key (from the PDDB)
* `/set key value` -- sets value of key (in the PDDB)
* `/unset key` -- removes key (from the PDDB)
@ -38,4 +41,11 @@ The following commands are available in **mtxcli**:
Any line not starting with a slash ('/') will be sent to the current room.
New messages from the current room will be displayed.
_NOTE:_ chatting is not implemented yet
## Acknowledgements
This app is supported in part by a grant from the
[NGI0 PET Fund](https://nlnet.nl/PET/),
a fund established by NLnet with financial support from the
European Commission's [Next Generation Internet](https://www.ngi.eu/) program.
![nl.net+NGI0](https://www.crowdsupply.com/img/001b/precursor-grant-logos_png_md-xl.jpg)

View file

@ -1,50 +1,134 @@
{
"mtxcli.filter.failed": {
"en": "error: could not create filter",
"ja": "error: could not create filter *EN*",
"zh": "error: could not create filter *EN*",
"en-tts": "error: could not create filter"
},
"mtxcli.greeting": {
"en": "Welcome to the MTXCLI demo.",
"en": "Welcome to the MTXCLI demo. Type /help for available commands",
"ja": "シンプルなMTXCLIデモへようこそ",
"zh": "简单的 mtxcli 演示活动",
"en-tts": "Welcome to the simple MTXCLI demo."
"en-tts": "Welcome to the simple MTXCLI demo. Type /help for available commands"
},
"mtxcli.get.help": {
"en": "/get key",
"ja": "TBD /get key",
"zh": "TBD /get key",
"ja": "/get key *EN*",
"zh": "/get key *EN*",
"en-tts": "get key"
},
"mtxcli.help.help": {
"en": "/help [cmd]",
"ja": "TBD /help [cmd]",
"zh": "TBD /help [cmd]",
"ja": "/help [cmd] *EN*",
"zh": "/help [cmd] *EN*",
"en-tts": "help [cmd]"
},
"mtxcli.help.overview": {
"en": "available mtxcli commands:",
"ja": "TBD available mtxcli commands:",
"zh": "TBD available mtxcli commands:",
"ja": "available mtxcli commands: *EN*",
"zh": "available mtxcli commands: *EN*",
"en-tts": "available mtxcli commands:"
},
"mtxcli.logging.in": {
"en": "logging in...",
"ja": "logging in... *EN*",
"zh": "logging in... *EN*",
"en-tts": "logging in"
},
"mtxcli.logged.in": {
"en": "logged in",
"ja": "logged in *EN*",
"zh": "logged in *EN*",
"en-tts": "logged in"
},
"mtxcli.logged.out": {
"en": "logged out",
"ja": "logged out *EN*",
"zh": "logged out *EN*",
"en-tts": "logged out"
},
"mtxcli.login.failed": {
"en": "authentication failed",
"ja": "authentication failed *EN*",
"zh": "authentication failed *EN*",
"en-tts": "authentication failed"
},
"mtxcli.login.help": {
"en": "/login",
"ja": "/login *EN*",
"zh": "/login *EN*",
"en-tts": "login"
},
"mtxcli.logout.help": {
"en": "/logout",
"ja": "/logout *EN*",
"zh": "/logout *EN*",
"en-tts": "logout"
},
"mtxcli.not.connected": {
"en": "not connected",
"ja": "not connected *EN*",
"zh": "not connected *EN*",
"en-tts": "not conntected"
},
"mtxcli.please.set.user": {
"en": "please /set user @USER:matrix.org",
"ja": "please /set user @USER:matrix.org *EN*",
"zh": "please /set user @USER:matrix.org *EN*",
"en-tts": "please /set user @USER:matrix.org"
},
"mtxcli.please.set.password": {
"en": "please /set password my-password",
"ja": "please /set password my-password *EN*",
"zh": "please /set password my-password *EN*",
"en-tts": "please /set password my-password"
},
"mtxcli.please.set.room": {
"en": "please /set room #my-room-to-join",
"ja": "please /set room #my-room-to-join *EN*",
"zh": "please /set room #my-room-to-join *EN*",
"en-tts": "please /set room #my-room-to-join"
},
"mtxcli.please.set.server": {
"en": "please /set server https://matrix.org",
"ja": "please /set server https://matrix.org *EN*",
"zh": "please /set server https://matrix.org *EN*",
"en-tts": "please /set server https://matrix.org"
},
"mtxcli.roomid.failed": {
"en": "error: could not find room_id",
"ja": "error: could not find room_id *EN*",
"zh": "error: could not find room_id *EN*",
"en-tts": "error: could not find room_id"
},
"mtxcli.set.help": {
"en": "/set key value",
"ja": "TBD /set key value",
"zh": "TBD /set key value",
"ja": "/set key value *EN*",
"zh": "/set key value *EN*",
"en-tts": "set key value"
},
"mtxcli.send.failed": {
"en": "FAILED TO SEND!",
"ja": "FAILED TO SEND! *EN*",
"zh": "FAILED TO SEND! *EN*",
"en-tts": "FAILED TO SEND!"
},
"mtxcli.status.help": {
"en": "/status",
"ja": "TBD /status",
"zh": "TBD /status",
"ja": "/status *EN*",
"zh": "/status *EN*",
"en-tts": "status"
},
"mtxcli.unset.help": {
"en": "/unset key",
"ja": "TBD /unset key",
"zh": "TBD /unset key",
"ja": "/unset key *EN*",
"zh": "/unset key *EN*",
"en-tts": "unset key"
},
"mtxcli.unknown.help": {
"en": "unknown command",
"ja": "TBD unknown command",
"zh": "TBD unknown command",
"ja": "unknown command *EN*",
"zh": "unknown command *EN*",
"en-tts": "unknown command"
}
}

View file

@ -1,15 +1,38 @@
use xous::{MessageEnvelope};
use xous_ipc::String as XousString;
use core::fmt::Write;
use locales::t;
use std::collections::HashMap;
use std::fs::File;
use std::io::{Read, Write as StdWrite, Error};
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH}; // to help gen_txn_id
mod url;
mod web;
const APP: &str = "mtxcli";
/// PDDB Dict for mtxcli keys
const MTXCLI_DICT: &str = "mtxcli";
const FILTER_KEY: &str = "_filter";
const PASSWORD_KEY: &str = "password";
const ROOM_ID_KEY: &str = "_room_id";
const ROOM_KEY: &str = "room";
const SINCE_KEY: &str = "_since";
const SERVER_KEY: &str = "server";
const TOKEN_KEY: &str = "_token";
const USER_KEY: &str = "user";
const USERNAME_KEY: &str = "username";
const HTTPS: &str = "https://";
const SERVER_MATRIX: &str = "https://matrix.org";
const EMPTY: &str = "";
const MTX_TIMEOUT: i32 = 300; // ms
/////////////////////////// Common items to all commands
pub trait ShellCmdApi<'a> {
// user implemented:
@ -56,46 +79,333 @@ pub struct CommonEnv {
cb_registrations: HashMap::<u32, XousString::<256>>,
trng: Trng,
xns: xous_names::XousNames,
user: String,
username: String,
server: String,
token: String,
logged_in: bool,
room_id: String,
filter: String,
since: String,
first_line: bool,
}
impl CommonEnv {
pub fn gen_txn_id(&mut self) -> String {
let mut txn_id = self.trng.get_u32()
.expect("unable to generate random u32");
log::info!("trng.get_u32() = {}", txn_id);
txn_id += SystemTime::now().duration_since(UNIX_EPOCH)
.expect("Time went backwards").subsec_nanos();
txn_id.to_string()
}
pub fn set(&mut self, key: &str, value: &str) -> Result<(), Error> {
log::info!("set '{}' = '{}'", key, value);
let mut keypath = PathBuf::new();
keypath.push(MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict '{}' exists", MTXCLI_DICT);
} else {
log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
}
keypath.push(key);
File::create(keypath)?.write_all(value.as_bytes())?;
match key { // special case side effects
USER_KEY => { self.set_user(value); }
PASSWORD_KEY => { self.set_password(); }
ROOM_KEY => { self.set_room(); }
_ => { }
}
Ok(())
}
// will log on error (vs. panic)
pub fn set_debug(&mut self, key: &str, value: &str) -> bool {
match self.set(key, value) {
Ok(()) => {
true
},
Err(e) => {
log::error!("error setting key {}: {:?}", key, e);
false
}
}
}
pub fn set_user(&mut self, value: &str) {
log::debug!("# USER_KEY set '{}' = '{}'", USER_KEY, value);
let i = match value.find('@') {
Some(index) => { index + 1 },
None => { 0 },
};
let j = match value.find(':') {
Some(index) => { index },
None => { value.len() },
};
self.username = (&value[i..j]).to_string();
if j < value.len() {
self.server = String::from(HTTPS);
self.server.push_str(&value[j + 1..]);
} else {
self.server = SERVER_MATRIX.to_string();
}
self.user = value.to_string();
log::debug!("# user = '{}' username = '{}' server = '{}'", self.user, self.username, self.server);
self.set_debug(USERNAME_KEY, &self.username.clone());
self.set_debug(SERVER_KEY, &self.server.clone());
self.unset_debug(TOKEN_KEY);
self.token = EMPTY.to_string();
}
pub fn set_password(&mut self) {
log::debug!("# PASSWORD_KEY set '{}' => clearing TOKEN_KEY", PASSWORD_KEY);
self.unset_debug(TOKEN_KEY);
}
pub fn set_room(&mut self) {
log::debug!("# ROOM_KEY set '{}' => clearing ROOM_ID_KEY, SINCE_KEY, FILTER_KEY", ROOM_KEY);
self.unset_debug(ROOM_ID_KEY);
self.unset_debug(SINCE_KEY);
self.unset_debug(FILTER_KEY);
}
pub fn unset(&mut self, key: &str) -> Result<(), Error> {
log::info!("unset '{}'", key);
// log::info!("unset '{}'", key);
let mut keypath = PathBuf::new();
keypath.push(MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict '{}' exists", MTXCLI_DICT);
} else {
log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
}
keypath.push(key);
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict:key = '{}:{}' exists.. deleting it", MTXCLI_DICT, key);
std::fs::remove_file(keypath)?;
}
Ok(())
}
// will log on error (vs. panic)
pub fn unset_debug(&mut self, key: &str) -> bool {
match self.unset(key) {
Ok(()) => {
true
},
Err(e) => {
log::error!("error unsetting key {}: {:?}", key, e);
false
}
}
}
pub fn get(&mut self, key: &str) -> Result<Option<String>, Error> {
let mut keypath = PathBuf::new();
keypath.push(MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict '{}' exists", MTXCLI_DICT);
} else {
log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
}
keypath.push(key);
if let Ok(mut file)= File::open(keypath) {
let mut value = String::new();
file.read_to_string(&mut value)?;
log::info!("get '{}' = '{}'", key, value);
// log::info!("get '{}' = '{}'", key, value);
Ok(Some(value))
} else {
Ok(None)
}
}
pub fn get_default(&mut self, key: &str, default: &str) -> String {
match self.get(key) {
Ok(None) => {
default.to_string()
},
Ok(Some(value)) => {
value.to_string()
}
Err(e) => {
log::error!("error getting key {}: {:?}", key, e);
default.to_string()
}
}
}
pub fn prompt(&mut self, ret: &mut XousString::<1024>, text: &str) {
if self.first_line {
write!(ret, "{}> {}", APP, text).unwrap();
self.first_line = false;
} else {
write!(ret, "\n{}> {}", APP, text).unwrap();
}
}
pub fn user_says(&mut self, ret: &mut XousString::<1024>, text: &str) {
if ! self.logged_in {
if ! self.login(ret) {
return;
}
}
if self.room_id.len() == 0 {
if ! self.get_room_id(ret) {
return;
}
}
if self.filter.len() == 0 {
if ! self.get_filter(ret) {
return;
}
}
self.read_messages(ret);
// The following is not required, because we will get what
// the user said when we read_messages the second time
// write!(ret, "{}> {}", self.username, text).unwrap();
let txn_id = self.gen_txn_id();
log::info!("txn_id = {}", txn_id);
if web::send_message(&self.server, &self.room_id, &text, &txn_id, &self.token) {
log::info!("SENT: {}", text);
self.read_messages(ret); // update since to include what user said
} else {
log::info!("FAILED TO SEND");
write!(ret, "{}", t!("mtxcli.send.failed", xous::LANG)).unwrap();
}
}
pub fn login(&mut self, ret: &mut XousString::<1024>) -> bool {
self.prompt(ret, t!("mtxcli.logging.in", xous::LANG));
self.token = self.get_default(TOKEN_KEY, EMPTY);
self.logged_in = false;
if self.token.len() > 0 {
if web::whoami(&self.server, &self.token) {
self.logged_in = true;
}
}
if ! self.logged_in {
if web::get_login_type(&self.server) {
let user = self.get_default(USER_KEY, USER_KEY);
let password = self.get_default(PASSWORD_KEY, EMPTY);
if password.len() == 0 {
self.prompt(ret, t!("mtxcli.please.set.user", xous::LANG));
self.prompt(ret, t!("mtxcli.please.set.password", xous::LANG));
} else {
if let Some(new_token) = web::authenticate_user(&self.server, &user, &password) {
self.set_debug(TOKEN_KEY, &new_token);
self.token = new_token;
self.logged_in = true;
} else {
log::error!("Error: cannnot login with type: {}", web::MTX_LOGIN_PASSWORD);
}
}
}
}
if self.logged_in {
self.prompt(ret, t!("mtxcli.logged.in", xous::LANG));
} else {
self.prompt(ret, t!("mtxcli.login.failed", xous::LANG));
}
self.logged_in
}
pub fn logout(&mut self, ret: &mut XousString::<1024>) {
self.unset_debug(TOKEN_KEY);
self.prompt(ret, t!("mtxcli.logged.out", xous::LANG));
self.logged_in = false;
}
// assume logged in, token is valid
pub fn get_room_id(&mut self, ret: &mut XousString::<1024>) -> bool {
if self.room_id.len() > 0 {
true
} else {
let room = self.get_default(ROOM_KEY, EMPTY);
let server = self.get_default(SERVER_KEY, EMPTY);
if room.len() == 0 {
self.prompt(ret, t!("mtxcli.please.set.room", xous::LANG));
false
} else if server.len() == 0 {
self.prompt(ret, t!("mtxcli.please.set.server", xous::LANG));
false
} else {
let mut room_server = String::new();
if ! room.starts_with("#") {
room_server.push_str("#");
}
room_server.push_str(&room);
room_server.push_str(":");
let i = match server.find(HTTPS) {
Some(index) => {
index + HTTPS.len()
},
None => {
server.len()
},
};
if i >= server.len() {
self.prompt(ret, t!("mtxcli.please.set.server", xous::LANG));
false
} else {
room_server.push_str(&server[i..]);
if let Some(new_room_id) = web::get_room_id(&self.server, &room_server, &self.token) {
self.set_debug(ROOM_ID_KEY, &new_room_id);
self.room_id = new_room_id;
true
} else {
self.prompt(ret, t!("mtxcli.roomid.failed", xous::LANG));
false
}
}
}
}
}
// assume logged in, token is valid, room_id is valid, user is valid
pub fn get_filter(&mut self, ret: &mut XousString::<1024>) -> bool {
if self.filter.len() > 0 {
true
} else {
if let Some(new_filter) = web::get_filter(&self.user, &self.server, &self.token) {
self.set_debug(FILTER_KEY, &new_filter);
self.filter = new_filter;
true
} else {
self.prompt(ret, t!("mtxcli.filter.failed", xous::LANG));
false
}
}
}
// assume logged in, token is valid, room_id is valid, user is valid,
// and filter is valid
pub fn read_messages(&mut self, ret: &mut XousString::<1024>) -> bool {
if let Some((since, messages)) = web::client_sync(&self.server, &self.filter,
&self.since, MTX_TIMEOUT,
&self.room_id, &self.token) {
self.set_debug(SINCE_KEY, &since);
self.since = since;
if messages.len() > 0 {
if self.first_line {
write!(ret, "{}", messages).unwrap();
self.first_line = false;
} else {
write!(ret, "\n{}", messages).unwrap();
}
true
} else {
false
}
} else {
false
}
}
}
/*
@ -113,6 +423,8 @@ impl CommonEnv {
///// 1. add your module here, and pull its namespace into the local crate
mod get; use get::*;
mod help; use help::*;
mod login; use login::*;
mod logout; use logout::*;
mod set; use set::*;
mod status; use status::*;
mod unset; use unset::*;
@ -123,6 +435,8 @@ pub struct CmdEnv {
///// 2. declare storage for your command here.
get_cmd: Get,
help_cmd: Help,
login_cmd: Login,
logout_cmd: Logout,
set_cmd: Set,
status_cmd: Status,
unset_cmd: Unset,
@ -140,6 +454,16 @@ impl CmdEnv {
cb_registrations: HashMap::new(),
trng: Trng::new(&xns).unwrap(),
xns: xous_names::XousNames::new().unwrap(),
user: EMPTY.to_string(),
username: EMPTY.to_string(),
server: SERVER_MATRIX.to_string(),
token: EMPTY.to_string(),
logged_in: false,
room_id: EMPTY.to_string(),
filter: EMPTY.to_string(),
since: EMPTY.to_string(),
first_line: true
};
log::info!("done creating CommonEnv");
CmdEnv {
@ -148,6 +472,8 @@ impl CmdEnv {
///// 3. initialize your storage, by calling new()
get_cmd: Get::new(&xns),
help_cmd: Help::new(&xns),
login_cmd: Login::new(&xns),
logout_cmd: Logout::new(&xns),
set_cmd: Set::new(&xns),
status_cmd: Status::new(&xns),
unset_cmd: Unset::new(&xns),
@ -156,16 +482,28 @@ impl CmdEnv {
pub fn dispatch(&mut self, maybe_cmdline: Option<&mut XousString::<1024>>, maybe_callback: Option<&MessageEnvelope>) -> Result<Option<XousString::<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
self.common_env.first_line = true;
let commands: &mut [& mut dyn ShellCmdApi] = &mut [
///// 4. add your command to this array, so that it can be looked up and dispatched
&mut self.get_cmd,
&mut self.help_cmd,
&mut self.login_cmd,
&mut self.logout_cmd,
&mut self.set_cmd,
&mut self.status_cmd,
&mut self.unset_cmd,
];
if self.common_env.username.len() == 0 { // first time initialization
self.common_env.user = self.common_env.get_default(USER_KEY, EMPTY);
self.common_env.username = self.common_env.get_default(USERNAME_KEY, USERNAME_KEY);
self.common_env.server = self.common_env.get_default(SERVER_KEY, SERVER_MATRIX);
self.common_env.room_id = self.common_env.get_default(ROOM_ID_KEY, EMPTY);
self.common_env.filter = self.common_env.get_default(FILTER_KEY, EMPTY);
self.common_env.since = self.common_env.get_default(SINCE_KEY, EMPTY);
}
if let Some(cmdline) = maybe_cmdline {
let maybe_verb = tokenize(cmdline);
@ -205,11 +543,19 @@ impl CmdEnv {
cmd_ret
}
} else { // chat
write!(ret, "SAY: {} {}", verb, cmdline.to_str()).unwrap();
let mut text = String::from(verb);
text.push_str(" ");
text.push_str(cmdline.to_str());
self.common_env.user_says(&mut ret, &text);
Ok(Some(ret))
}
} else {
Ok(None)
log::info!("NO INPUT");
if self.common_env.read_messages(&mut ret) {
Ok(Some(ret))
} else {
Ok(None)
}
}
} else if let Some(callback) = maybe_callback {
let mut cmd_ret: Result<Option<XousString::<1024>>, xous::Error> = Ok(None);

View file

@ -34,7 +34,6 @@ impl<'a> ShellCmdApi<'a> for Get {
write!(ret, "{}", value).unwrap();
}
Err(e) => {
write!(ret, "error getting key {}: {:?}", key, e).unwrap();
log::error!("error getting key {}: {:?}", key, e);
}
}

View file

@ -33,6 +33,12 @@ impl<'a> ShellCmdApi<'a> for Help {
"help" => {
write!(ret, "{}", t!("mtxcli.help.help", xous::LANG)).unwrap();
}
"login" => {
write!(ret, "{}", t!("mtxcli.login.help", xous::LANG)).unwrap();
}
"logout" => {
write!(ret, "{}", t!("mtxcli.logout.help", xous::LANG)).unwrap();
}
"set" => {
write!(ret, "{}", t!("mtxcli.set.help", xous::LANG)).unwrap();
}
@ -46,6 +52,8 @@ impl<'a> ShellCmdApi<'a> for Help {
write!(ret, "{}\n", t!("mtxcli.help.overview", xous::LANG)).unwrap();
write!(ret, "{}\n", t!("mtxcli.get.help", xous::LANG)).unwrap();
write!(ret, "{}\n", t!("mtxcli.help.help", xous::LANG)).unwrap();
write!(ret, "{}\n", t!("mtxcli.login.help", xous::LANG)).unwrap();
write!(ret, "{}\n", t!("mtxcli.logout.help", xous::LANG)).unwrap();
write!(ret, "{}\n", t!("mtxcli.set.help", xous::LANG)).unwrap();
write!(ret, "{}\n", t!("mtxcli.status.help", xous::LANG)).unwrap();
write!(ret, "{}", t!("mtxcli.unset.help", xous::LANG)).unwrap();

View file

@ -0,0 +1,22 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
#[derive(Debug)]
pub struct Login {
}
impl Login {
pub fn new(_xns: &xous_names::XousNames) -> Self {
Login {
}
}
}
impl<'a> ShellCmdApi<'a> for Login {
cmd_api!(login);
fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
env.login(&mut ret);
Ok(Some(ret))
}
}

View file

@ -0,0 +1,22 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
#[derive(Debug)]
pub struct Logout {
}
impl Logout {
pub fn new(_xns: &xous_names::XousNames) -> Self {
Logout {
}
}
}
impl<'a> ShellCmdApi<'a> for Logout {
cmd_api!(logout);
fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
env.logout(&mut ret);
Ok(Some(ret))
}
}

View file

@ -34,13 +34,11 @@ impl<'a> ShellCmdApi<'a> for Set {
_ => {
match env.set(key, value) {
Ok(()) => {
write!(ret, "set {} = {}", key, value).unwrap();
write!(ret, "set {}", key).unwrap();
},
Err(e) => {
write!(ret, "error setting key {}: {:?}",
key, e).unwrap();
log::error!("error setting key {}: {:?}",
key, e);
// write!(ret, "error setting key {}: {:?}", key, e).unwrap();
log::error!("error setting key {}: {:?}", key, e);
}
}
}

View file

@ -1,7 +1,6 @@
use crate::{ShellCmdApi,CommonEnv};
use xous_ipc::String as XousString;
use core::fmt::Write;
// use locales::t;
use locales::t;
#[derive(Debug)]
pub struct Status {
@ -16,10 +15,16 @@ impl Status {
impl<'a> ShellCmdApi<'a> for Status {
cmd_api!(status);
fn process(&mut self, _args: XousString::<1024>, _env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
let mut ret = XousString::<1024>::new();
write!(ret, "status: not connected").unwrap();
let mut text = String::new();
text.push_str("status: ");
if env.logged_in {
text.push_str(t!("mtxcli.logged.in", xous::LANG));
} else {
text.push_str(t!("mtxcli.not.connected", xous::LANG));
}
env.prompt(&mut ret, &text);
Ok(Some(ret))
}
}

View file

@ -31,8 +31,9 @@ impl<'a> ShellCmdApi<'a> for Unset {
write!(ret, "unset {}", key).unwrap();
},
Err(e) => {
write!(ret, "error unsetting key {}: {:?}",
key, e).unwrap();
// NOTE: we current expect this error
// when unsetting a non existant key
write!(ret, "unset {} (did not exist)", key).unwrap();
log::error!("error unsetting key {}: {:?}", key, e);
}
}

View file

@ -0,0 +1,22 @@
//! URL encoding and decoding
/// Encoding to use for conversions
pub const RFC3986: &percent_encoding::AsciiSet = &percent_encoding::NON_ALPHANUMERIC
.remove(b'.')
.remove(b'-')
.remove(b'_')
.remove(b'~');
/// URL encode string
pub fn encode(v: &str) -> String {
percent_encoding::utf8_percent_encode(v, RFC3986).to_string()
}
/// URL decode string
#[allow(dead_code)]
pub fn decode(v: &str) -> String {
let decoded = percent_encoding::percent_decode_str(v)
.decode_utf8()
.expect("unable to decode");
decoded.to_string()
}

446
apps/mtxcli/src/cmds/web.rs Normal file
View file

@ -0,0 +1,446 @@
use serde::{Serialize,Deserialize};
use ureq::serde_json::{Value, Map};
use ureq;
use crate::cmds::url;
const ACCEPT: &str = "Accept";
const ACCEPT_JSON: &str = "application/json";
const AUTHORIZATION: &str = "Authorization";
const BEARER: &str = "Bearer ";
pub const MTX_LOGIN_PASSWORD: &str = "m.login.password";
const MTX_ID_USER: &str = "m.id.user";
pub fn get_username(user: &str) -> String {
let i = match user.find('@') {
Some(index) => { index + 1 },
None => { 0 },
};
let j = match user.find(':') {
Some(index) => { index },
None => { user.len() },
};
(&user[i..j]).to_string()
}
fn serialize<T: ?Sized + Serialize>(object: &T) -> Option<String> {
match ureq::serde_json::to_string(&object) {
Ok(value) => {
Some(value)
},
Err(_) => {
// println!("FAILED TO SERIALIZE");
None
}
}
}
pub fn handle_response(maybe_response: Result<ureq::Response,ureq::Error>) -> Option<Value> {
match maybe_response {
Ok(response) => {
// DEBUG
// if let Ok(json) = response.into_string() {
// println!("JSON = \n{}\n", json);
// None
if let Ok(body) = response.into_json() {
Some(body)
} else {
log::error!("Error: could not convert response into JSON");
None
}
},
Err(ureq::Error::Status(code, response)) => {
/* the server returned an unexpected status
code (such as 400, 500 etc) */
let err_body = response.into_string().unwrap();
log::error!("ERROR code {} err_body = {}", code, err_body);
// let status_text = "the status text";
// Err(ureq::Error::Status(code, ureq::Response::new(code, status_text, &body).unwrap()))
None
}
Err(_) => {
log::error!("Unknown Error");
// Err(e)
None
}
}
}
pub fn get_json(url: &str) -> Result<ureq::Response, ureq::Error> {
// println!("getting json from {}", &url);
ureq::get(&url)
.set(ACCEPT, ACCEPT_JSON)
.call()
}
pub fn get_json_auth(url: &str, token:&str) -> Result<ureq::Response, ureq::Error> {
// println!("getting json auth from {}", &url);
let mut authorization = String::from(BEARER);
authorization.push_str(token);
ureq::get(&url)
.set(ACCEPT, ACCEPT_JSON)
.set(AUTHORIZATION, &authorization)
.call()
}
pub fn post_string(url: &str, request_body: &str) -> Result<ureq::Response, ureq::Error> {
// println!("post json to {}", &url);
ureq::post(&url)
.set(ACCEPT, ACCEPT_JSON)
.send_string(request_body)
}
pub fn post_string_auth(url: &str, request_body: &str, token: &str) -> Result<ureq::Response, ureq::Error> {
// println!("post json auth from {}", &url);
let mut authorization = String::from(BEARER);
authorization.push_str(token);
ureq::post(&url)
.set(ACCEPT, ACCEPT_JSON)
.set(AUTHORIZATION, &authorization)
.send_string(request_body)
}
pub fn put_string_auth(url: &str, request_body: &str, token: &str) -> Result<ureq::Response, ureq::Error> {
// println!("put json auth from {}", &url);
let mut authorization = String::from(BEARER);
authorization.push_str(token);
ureq::put(&url)
.set(ACCEPT, ACCEPT_JSON)
.set(AUTHORIZATION, &authorization)
.send_string(request_body)
}
// --------------------------------
pub fn whoami(server: &str, token: &str) -> bool {
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/account/whoami");
if let Some(value) = handle_response(get_json_auth(&url, token)) {
if let Value::Object(body) = value {
if let Some(Value::String(device_id)) = body.get("device_id") {
log::debug!("device_id = {}", device_id);
}
if let Some(Value::String(user_id)) = body.get("user_id") {
log::debug!("user_id = {}", user_id);
}
}
true
} else {
false
}
}
pub fn get_login_type(server: &str) -> bool {
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/login");
let mut found = false;
if let Some(value) = handle_response(get_json(&url)) {
if let Value::Object(body) = value {
if let Some(Value::Array(flows)) = body.get("flows") {
for flow in flows.iter() {
if let Some(Value::String(login_type)) = flow.get("type") {
if login_type.eq(MTX_LOGIN_PASSWORD) {
found = true;
break;
}
}
}
}
}
}
found
}
#[derive(Serialize, Deserialize)]
struct AuthIdentifier {
#[serde(rename = "type")]
type_: String,
user: String,
}
#[derive(Serialize, Deserialize)]
struct AuthRequest {
#[serde(rename = "type")]
type_: String,
identifier: AuthIdentifier,
password: String,
}
impl AuthRequest {
pub fn new(user: &str, password: &str) -> Self {
let identifier = AuthIdentifier {
type_: MTX_ID_USER.to_string(),
user: user.to_string()
};
AuthRequest {
type_: MTX_LOGIN_PASSWORD.to_string(),
identifier: identifier,
password: password.to_string()
}
}
}
// fn authenticate_user() -> Result<String, ureq::Error> {
pub fn authenticate_user(server: &str, user: &str, password: &str) -> Option<String> {
let mut maybe_token: Option<String> = None;
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/login");
let auth_request = AuthRequest::new(user, password);
if let Some(request_body) = serialize(&auth_request) {
if let Some(value) = handle_response(post_string(&url, &request_body)) {
if let Value::Object(body) = value {
if let Some(Value::String(access_token)) = body.get("access_token") {
maybe_token = Some(access_token.to_string())
}
}
}
}
maybe_token
}
pub fn get_room_id(server: &str, room_server: &str, token: &str) -> Option<String> {
let room_encoded = url::encode(room_server);
let mut url = String::from(server);
url.push_str("/_matrix/client/v3/directory/room/");
url.push_str(&room_encoded);
log::debug!("get_room_id = {}", url);
if let Some(value) = handle_response(get_json_auth(&url, token)) {
if let Value::Object(body) = value {
if let Some(Value::String(room_id)) = body.get("room_id") {
Some(room_id.to_string())
} else {
log::error!("invalid response for get_room_id");
None
}
} else {
log::error!("invalid response for get_room_id");
None
}
} else {
log::error!("Error for get_room_id");
None
}
}
#[derive(Serialize, Deserialize)]
struct EventFilter {
limit: i32
}
impl EventFilter {
pub fn new(limit: i32) -> Self {
EventFilter {
limit
}
}
}
#[derive(Serialize, Deserialize)]
struct RoomEventFilter {
limit: i32,
types: Vec<String>,
}
impl RoomEventFilter {
pub fn new(limit: i32, type_0: &str) -> Self {
let mut types = Vec::new();
types.push(type_0.to_string());
RoomEventFilter {
limit,
types,
}
}
}
#[derive(Serialize, Deserialize)]
struct RoomFilter {
account_data: EventFilter, // Should be RoomEventFilter
state: EventFilter, // Should be StateFilter
ephemeral: EventFilter,
timeline: RoomEventFilter,
}
impl RoomFilter {
pub fn new() -> Self {
let account_data = EventFilter::new(0);
let state = EventFilter::new(0);
let ephemeral = EventFilter::new(0);
let timeline = RoomEventFilter::new(10, "m.room.message");
RoomFilter {
account_data,
state,
ephemeral,
timeline,
}
}
}
#[derive(Serialize, Deserialize)]
struct FilterRequest {
presence: EventFilter,
account_data: EventFilter,
room: RoomFilter,
}
impl FilterRequest {
pub fn new() -> Self {
let presence = EventFilter::new(0);
let account_data = EventFilter::new(0);
let room = RoomFilter::new();
FilterRequest {
presence,
account_data,
room
}
}
}
pub fn get_filter(user: &str, server: &str, token: &str) -> Option<String> {
let user_encoded = url::encode(user);
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/user/");
url.push_str(&user_encoded);
url.push_str("/filter");
log::debug!("get_filter = {}", url);
let filter_request = FilterRequest::new();
if let Some(request_body) = serialize(&filter_request) {
// println!("filter_request = {}", request_body);
if let Some(value) = handle_response(post_string_auth(&url, &request_body, token)) {
if let Value::Object(body) = value {
if let Some(Value::String(filter_id)) = body.get("filter_id") {
// log::debug!("filter_id = {}", filter_id);
Some(filter_id.to_string())
} else {
log::error!("invalid response for get_filter");
None
}
} else {
log::error!("invalid response for get_filter");
None
}
} else {
log::error!("Error for get_filter");
None
}
} else {
log::error!("Error unable to serialize request for get_filter");
None
}
}
fn get_messages(body: Map<String, Value>, room_id: &str) -> String {
let mut messages = String::new();
if let Some(Value::Object(rooms)) = body.get("rooms") {
if let Some(Value::Object(join)) = rooms.get("join") {
if let Some(Value::Object(room)) = join.get(room_id) {
if let Some(Value::Object(timeline)) = room.get("timeline") {
if let Some(Value::Array(events)) = timeline.get("events") {
for event in events.iter() {
if let Some(Value::String(type_)) = event.get("type") {
if type_.eq("m.room.message") {
if messages.len() > 0 {
messages.push_str("\n");
}
if let Some(Value::String(sender)) = event.get("sender") {
messages.push_str(&get_username(sender));
} else {
messages.push_str("unknown");
}
messages.push_str("> ");
if let Some(Value::Object(content)) = event.get("content") {
if let Some(Value::String(body)) = content.get("body") {
messages.push_str(body);
} else {
messages.push_str("....");
}
} else {
messages.push_str("...");
}
} // m.room.message
}
} // event
}
}
}
}
}
messages
}
pub fn client_sync(server: &str, filter: &str, since: &str, timeout: i32,
room_id: &str, token: &str) -> Option<(String, String)> {
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/sync?filter=");
url.push_str(filter);
url.push_str("&timeout=");
url.push_str(&timeout.to_string());
if since.len() > 0 {
url.push_str("&since=");
url.push_str(since);
}
log::debug!("client_sync = {}", url);
if let Some(value) = handle_response(get_json_auth(&url, token)) {
// println!("SYNC = {:?}", value);
if let Value::Object(body) = value {
if let Some(Value::String(next_batch)) = body.get("next_batch") {
Some((next_batch.to_string(), get_messages(body, room_id)))
} else {
log::error!("invalid response for client_sync");
None
}
} else {
log::error!("Error for client_sync: deserialization");
None
}
} else {
None
}
}
#[derive(Serialize, Deserialize)]
struct MessageRequest {
msgtype: String,
body: String,
}
impl MessageRequest {
pub fn new(text: &str) -> Self {
let msgtype = "m.text".to_string();
let body = text.to_string();
MessageRequest {
msgtype,
body,
}
}
}
pub fn send_message(server: &str, room_id: &str, text: &str, txn_id: &str, token: &str) -> bool {
let room_id_encoded = url::encode(room_id);
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/rooms/");
url.push_str(&room_id_encoded);
url.push_str("/send/m.room.message/");
url.push_str(txn_id);
log::debug!("send_message = {}", url);
let message_request = MessageRequest::new(text);
if let Some(request_body) = serialize(&message_request) {
// println!("request_body = {}", request_body);
if let Some(value) = handle_response(put_string_auth(&url, &request_body, token)) {
if let Value::Object(_body) = value {
// println!("SENT = {:?}", body);
true
} else {
log::error!("invalid response for send_message");
false
}
} else {
log::error!("Error for send_message");
false
}
} else {
log::error!("Error unable to serialize request for send_message");
false
}
}