mtxcli: chat room updates asynchronously

Added more predefined scalar messages
Checks WiFi status
Spawns separate thread for client_sync (reading the network)
Most all log messages are now INFO (to be shown by default)

Closes #300

Signed-off-by: Tom Marble <tmarble@info9.net>
This commit is contained in:
Tom Marble 2023-01-19 21:59:50 -06:00 committed by Sean Cross
parent bfe87cadb3
commit 275dee1ae1
10 changed files with 326 additions and 175 deletions

5
Cargo.lock generated
View file

@ -2240,10 +2240,11 @@ dependencies = [
[[package]]
name = "mtxcli"
version = "0.6.0"
version = "0.7.0"
dependencies = [
"codec",
"com",
"com_rs-ref",
"content-plugin-api",
"gam",
"graphics-server",
@ -2252,11 +2253,13 @@ dependencies = [
"llio",
"locales",
"log",
"net",
"num-derive",
"num-traits",
"pddb",
"percent-encoding",
"serde",
"status",
"trng",
"ureq",
"xous 0.9.31 (registry+https://github.com/rust-lang/crates.io-index)",

View file

@ -1,6 +1,6 @@
[package]
name = "mtxcli"
version = "0.6.0"
version = "0.7.0"
authors = ["bunnie <bunnie@kosagi.com>"]
edition = "2018"
description = "Matrix chat"
@ -8,29 +8,31 @@ description = "Matrix chat"
# Dependency versions enforced by Cargo.lock.
[dependencies]
log = "0.4.14"
num-derive = {version = "0.3.3", default-features = false}
num-traits = {version = "0.2.14", default-features = false}
num-derive = { version = "0.3.3", default-features = false}
num-traits = { version = "0.2.14", default-features = false}
xous = "0.9.31"
xous-ipc = "0.9.31"
log-server = { package = "xous-api-log", version = "0.1.26" }
ticktimer-server = { package = "xous-api-ticktimer", version = "0.9.26" }
xous-names = { package = "xous-api-names", version = "0.9.28" }
gam = {path = "../../services/gam" }
graphics-server = {path = "../../services/graphics-server" }
trng = {path = "../../services/trng"}
locales = {path = "../../locales"}
ime-plugin-api = {path = "../../services/ime-plugin-api"}
ime-plugin-shell = {path = "../../services/ime-plugin-shell"}
content-plugin-api = {path = "../../services/content-plugin-api"} # all content canvas providers must provide this API
com = {path = "../../services/com"}
llio = {path = "../../services/llio"}
codec = {path = "../../services/codec"}
gam = { path = "../../services/gam" }
graphics-server = { path = "../../services/graphics-server" }
trng = { path = "../../services/trng"}
locales = { path = "../../locales"}
ime-plugin-api = { path = "../../services/ime-plugin-api"}
ime-plugin-shell = { path = "../../services/ime-plugin-shell"}
content-plugin-api = { path = "../../services/content-plugin-api"} # all content canvas providers must provide this API
codec = { path = "../../services/codec"}
com = { path = "../../services/com"}
com_rs-ref = { path = "../../imports/com_rs-ref"}
llio = { path = "../../services/llio"}
net = { path = "../../services/net" }
pddb = { path = "../../services/pddb" }
status = { path = "../../services/status" }
# new dependencies for mtxcli
percent-encoding = "2.2"
serde = { version = "1.0", features = [ "derive" ] }
ureq = { version = "2.5", features = ["json"] }
# Xous APIs
pddb = {path = "../../services/pddb" }
[features]
default = []

View file

@ -48,6 +48,13 @@
"ja": "available mtxcli commands: *EN*",
"zh": "available mtxcli commands: *EN*"
},
"mtxcli.initialized": {
"en": "MTXCLI ready",
"en-tts": "MTXCLI ready",
"fr": "MTXCLI prêt",
"ja": "MTXCLI ready *EN*",
"zh": "MTXCLI ready *EN*"
},
"mtxcli.logged.in": {
"en": "logged in",
"en-tts": "logged in",
@ -97,6 +104,13 @@
"ja": "migration completed *EN*",
"zh": "migration completed *EN*"
},
"mtxcli.migrations.complete": {
"en": "migrations complete",
"en-tts": "migrations complete",
"fr": "tous les migrations terminées",
"ja": "migrations complete *EN*",
"zh": "migrations complete *EN*"
},
"mtxcli.not.connected": {
"en": "not connected",
"en-tts": "not conntected",
@ -111,6 +125,13 @@
"ja": "WARNING: pddb not mounted *EN*",
"zh": "WARNING: pddb not mounted *EN*"
},
"mtxcli.please.login": {
"en": "please /login",
"en-tts": "please /login",
"fr": "Veuillez /login",
"ja": "please /login *EN*",
"zh": "please /login *EN*"
},
"mtxcli.please.set.password": {
"en": "please /set password my-password",
"en-tts": "please /set password my-password",
@ -188,6 +209,13 @@
"ja": "/unset key *EN*",
"zh": "/unset key *EN*"
},
"mtxcli.wifi.connected": {
"en": "WiFi connected",
"en-tts": "WiFi connected",
"fr": "WiFi connecté",
"ja": "WiFi connected *EN*",
"zh": "WiFi connected *EN*"
},
"mtxcli.wifi.warning": {
"en": "WARNING: WiFi not connected",
"en-tts": "WARNING: WiFi not connected",

View file

@ -1,7 +1,6 @@
use xous::{MessageEnvelope, Message,StringBuffer};
use xous_ipc::String as XousString;
use core::fmt::Write;
use locales::t;
use std::collections::HashMap;
use std::fs::File;
@ -15,7 +14,6 @@ mod url;
mod web;
const DATE_2023: u64 = 1672538401; // for clock_not_set()
const APP: &str = "mtxcli";
/// PDDB Dict for mtxcli keys
const MTXCLI_DICT: &str = "mtxcli";
@ -36,11 +34,32 @@ const HTTPS: &str = "https://";
const SERVER_MATRIX: &str = "https://matrix.org";
const EMPTY: &str = "";
const MTX_TIMEOUT: i32 = 300; // ms
const SENTINEL: char = '‡';
const MTX_LONG_TIMEOUT: i32 = 60000; // ms
pub const CLOCK_NOT_SET_ID: usize = 1;
pub const PDDB_NOT_MOUNTED_ID: usize = 2;
pub const WIFI_NOT_CONNECTED_ID: usize = 3;
pub const MTXCLI_INITIALIZED_ID: usize = 4;
pub const WIFI_CONNECTED_ID: usize = 5;
pub const SET_USER_ID: usize = 6;
pub const SET_PASSWORD_ID: usize = 7;
pub const LOGGED_IN_ID: usize = 8;
pub const LOGIN_FAILED_ID: usize = 9;
pub const SET_ROOM_ID: usize = 10;
pub const ROOMID_FAILED_ID: usize = 11;
pub const FILTER_FAILED_ID: usize = 12;
pub const SET_SERVER_ID: usize = 13;
pub const LOGGING_IN_ID: usize = 14;
pub const LOGGED_OUT_ID: usize = 15;
pub const NOT_CONNECTED_ID: usize = 16;
pub const FAILED_TO_SEND_ID: usize = 17;
pub const PLEASE_LOGIN_ID: usize = 18;
#[cfg(not(target_os = "xous"))]
pub const HOSTED_MODE: bool = true;
#[cfg(target_os = "xous")]
pub const HOSTED_MODE: bool = false;
/// Returns a version string which is more likely to string compare
/// correctly vs. another version. FFI please see
@ -54,7 +73,7 @@ fn get_version(ticktimer: &ticktimer_server::Ticktimer) -> String {
log::info!("version={}=", version);
version
} else {
log::error!("ERROR, couldn't find version from xous_version: {}",
log::info!("ERROR, couldn't find version from xous_version: {}",
xous_version);
xous_version
}
@ -102,6 +121,7 @@ pub struct CommonEnv {
async_msg_callback_id: u32,
async_msg_conn: u32,
trng: Trng,
netmgr: net::NetManager,
xns: xous_names::XousNames,
user: String,
username: String,
@ -114,21 +134,26 @@ pub struct CommonEnv {
first_line: bool,
version: String,
initialized: bool,
wifi_connected: bool,
listening: bool,
}
impl CommonEnv {
pub fn new() -> CommonEnv {
let xns = xous_names::XousNames::new().unwrap();
let ticktimer = ticktimer_server::Ticktimer::new()
.expect("Couldn't connect to Ticktimer");
let cb_registrations = HashMap::new();
let async_msg_callback_id: u32 = 0;
let async_msg_conn: u32 = 0;
let netmgr = net::NetManager::new();
let xns = xous_names::XousNames::new().unwrap();
let trng = Trng::new(&xns).unwrap();
let common = CommonEnv {
ticktimer,
cb_registrations,
async_msg_callback_id,
async_msg_conn,
trng: Trng::new(&xns).unwrap(),
trng,
netmgr,
xns,
user: EMPTY.to_string(),
username: EMPTY.to_string(),
@ -141,6 +166,8 @@ impl CommonEnv {
first_line: true,
version: EMPTY.to_string(),
initialized: false,
wifi_connected: false,
listening: false,
};
common
}
@ -176,8 +203,6 @@ impl CommonEnv {
.expect("unable to create string message");
str_buf.send(self.async_msg_conn, self.async_msg_callback_id)
.expect("unable to send string message");
// let msg = str_buf.create_memory_message(self.async_msg_callback_id);
// xous::send_message(self.async_msg_conn, msg).unwrap();
}
pub fn gen_txn_id(&mut self) -> String {
@ -198,7 +223,7 @@ impl CommonEnv {
let mut keypath = PathBuf::new();
keypath.push(MTXCLI_DICT);
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict '{}' exists", MTXCLI_DICT);
// log::info!("dict '{}' exists", MTXCLI_DICT);
} else {
log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
@ -227,14 +252,14 @@ impl CommonEnv {
true
},
Err(e) => {
log::error!("error setting key {}: {:?}", key, e);
log::info!("error setting key {}: {:?}", key, e);
false
}
}
}
pub fn set_user(&mut self, value: &str) {
log::debug!("# USER_KEY set '{}' = '{}'", USER_KEY, value);
log::info!("# USER_KEY set '{}' = '{}'", USER_KEY, value);
let i = match value.find('@') {
Some(index) => { index + 1 },
None => { 0 },
@ -251,26 +276,22 @@ impl CommonEnv {
self.server = SERVER_MATRIX.to_string();
}
self.user = value.to_string();
log::debug!("# user = '{}' username = '{}' server = '{}'", self.user, self.username, self.server);
log::info!("# 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);
log::info!("# 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);
log::info!("# ROOM_KEY set '{}' => clearing ROOM_ID_KEY, SINCE_KEY, FILTER_KEY", ROOM_KEY);
self.unset_debug(ROOM_ID_KEY);
self.room_id = EMPTY.to_string();
self.unset_debug(SINCE_KEY);
self.since = EMPTY.to_string();
self.unset_debug(FILTER_KEY);
self.filter = EMPTY.to_string();
}
pub fn unset(&mut self, key: &str) -> Result<(), Error> {
@ -282,17 +303,12 @@ impl CommonEnv {
let mut keypath = PathBuf::new();
keypath.push(MTXCLI_DICT);
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict '{}' exists", MTXCLI_DICT);
// 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);
// NOTE: the std:fs::metadata call may return Ok() even when
// the file does not exist.
// As a workaround WE COULD set the variable to the empty string
// log::info!("dict:key = '{}:{}' set to empty string (not deleting it)", MTXCLI_DICT, key);
// File::create(keypath)?.write_all(EMPTY.as_bytes())?;
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict:key = '{}:{}' exists.. deleting it", MTXCLI_DICT, key);
std::fs::remove_file(keypath)?;
@ -317,7 +333,7 @@ impl CommonEnv {
true
},
Err(e) => {
log::error!("error unsetting key {}: {:?}", key, e);
log::info!("error unsetting key {}: {:?}", key, e);
false
}
}
@ -330,7 +346,7 @@ impl CommonEnv {
let mut keypath = PathBuf::new();
keypath.push(MTXCLI_DICT);
if std::fs::metadata(&keypath).is_ok() { // keypath exists
log::info!("dict '{}' exists", MTXCLI_DICT);
// log::info!("dict '{}' exists", MTXCLI_DICT);
} else {
log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT);
std::fs::create_dir_all(&keypath)?;
@ -356,55 +372,40 @@ impl CommonEnv {
value.to_string()
}
Err(e) => {
log::error!("error getting key {}: {:?}", key, e);
log::info!("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) {
pub fn user_says(&mut self, text: &str) {
if ! self.logged_in {
if ! self.login(ret) {
if ! self.login() {
return;
}
}
if self.room_id.len() == 0 {
if ! self.get_room_id(ret) {
if ! self.get_room_id() {
return;
}
}
if self.filter.len() == 0 {
if ! self.get_filter(ret) {
if ! self.get_filter() {
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();
self.scalar_async_msg(FAILED_TO_SEND_ID);
}
}
pub fn login(&mut self, ret: &mut XousString::<1024>) -> bool {
self.prompt(ret, t!("mtxcli.logging.in", xous::LANG));
pub fn login(&mut self) -> bool {
self.scalar_async_msg(LOGGING_IN_ID);
self.token = self.get_default(TOKEN_KEY, EMPTY);
self.logged_in = false;
if self.token.len() > 0 {
@ -415,47 +416,48 @@ impl CommonEnv {
if ! self.logged_in {
if web::get_login_type(&self.server) {
let user = self.get_default(USER_KEY, USER_KEY);
if user.len() == 0 {
self.scalar_async_msg(SET_USER_ID);
}
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));
self.scalar_async_msg(SET_PASSWORD_ID);
} 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);
log::info!("Error: cannnot login with type: {}", web::MTX_LOGIN_PASSWORD);
}
}
}
}
if self.logged_in {
self.prompt(ret, t!("mtxcli.logged.in", xous::LANG));
self.scalar_async_msg(LOGGED_IN_ID);
} else {
self.prompt(ret, t!("mtxcli.login.failed", xous::LANG));
self.scalar_async_msg(LOGIN_FAILED_ID);
}
self.logged_in
}
pub fn logout(&mut self, ret: &mut XousString::<1024>) {
pub fn logout(&mut self) {
self.unset_debug(TOKEN_KEY);
self.prompt(ret, t!("mtxcli.logged.out", xous::LANG));
self.scalar_async_msg(LOGGED_OUT_ID);
self.logged_in = false;
}
// assume logged in, token is valid
pub fn get_room_id(&mut self, ret: &mut XousString::<1024>) -> bool {
pub fn get_room_id(&mut self) -> 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));
self.scalar_async_msg(SET_ROOM_ID);
false
} else if server.len() == 0 {
self.prompt(ret, t!("mtxcli.please.set.server", xous::LANG));
self.scalar_async_msg(SET_SERVER_ID);
false
} else {
let mut room_server = String::new();
@ -473,16 +475,15 @@ impl CommonEnv {
},
};
if i >= server.len() {
self.prompt(ret, t!("mtxcli.please.set.server", xous::LANG));
self.scalar_async_msg(SET_SERVER_ID);
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));
self.scalar_async_msg(ROOMID_FAILED_ID);
false
}
}
@ -491,46 +492,79 @@ impl CommonEnv {
}
// assume logged in, token is valid, room_id is valid, user is valid
pub fn get_filter(&mut self, ret: &mut XousString::<1024>) -> bool {
pub fn get_filter(&mut self) -> bool {
if self.filter.len() > 0 {
true
} else {
if let Some(new_filter) = web::get_filter(&self.user, &self.server,
&self.room_id, &self.token) {
self.set_debug(FILTER_KEY, &new_filter);
self.filter = new_filter;
true
} else {
self.prompt(ret, t!("mtxcli.filter.failed", xous::LANG));
self.scalar_async_msg(FILTER_FAILED_ID);
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();
pub fn listen(&mut self) {
if self.listening {
log::info!("Already listening");
return;
}
if ! self.logged_in {
log::info!("Not logged in");
return;
}
if self.room_id.len() == 0 {
if ! self.get_room_id() {
return;
}
}
if self.filter.len() == 0 {
if ! self.get_filter() {
return;
}
}
self.listening = true;
log::info!("Started listening");
std::thread::spawn({
let server = self.server.clone();
let filter = self.filter.clone();
let since = self.since.clone();
let room_id = self.room_id.clone();
let token = self.token.clone();
let async_msg_conn = self.async_msg_conn.clone();
let async_msg_callback_id = self.async_msg_callback_id.clone();
move || {
// log::info!("client_sync for {} ms...", MTX_LONG_TIMEOUT);
let mut response = String::new();
response.push(SENTINEL);
if let Some((since, messages)) = web::client_sync(&server, &filter, &since, MTX_LONG_TIMEOUT, &room_id, &token) {
response.push_str(&since);
response.push(SENTINEL);
response.push_str(&messages);
response.push(SENTINEL);
}
true
} else {
false
let str_buf = StringBuffer::from_str(&response)
.expect("unable to create string message");
str_buf.send(async_msg_conn, async_msg_callback_id)
.expect("unable to send string message");
}
} else {
false
}
});
}
pub fn listen_over(&mut self, since: &str) {
self.listening = false;
log::info!("Stopped listening");
if since.len() > 0 {
self.set_debug(SINCE_KEY, since);
// don't re-start listening if there was an error
if self.logged_in && (HOSTED_MODE || self.wifi_connected) {
self.listen();
}
}
}
}
/*
@ -603,36 +637,61 @@ impl CmdEnv {
&mut self.unset_cmd,
];
let prev_wifi_connected = self.common_env.wifi_connected;
self.common_env.wifi_connected = false;
if let Some(conf) = self.common_env.netmgr.get_ipv4_config() {
if conf.dhcp == com_rs_ref::DhcpState::Bound {
self.common_env.wifi_connected = true;
}
}
if self.common_env.wifi_connected != prev_wifi_connected {
if self.common_env.wifi_connected {
self.common_env.scalar_async_msg(WIFI_CONNECTED_ID);
} else {
self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ID);
}
}
if let Some(cmdline) = maybe_cmdline {
// Initialization (must wait until PDDB is mounted and llio can
// report accurate time). Here we wait to check for initialization
// once the user has typed something
if ! self.common_env.initialized {
log::info!("initializing");
log::info!("WiFi connected: {}", self.common_env.wifi_connected);
if clock_not_set() {
self.common_env.scalar_async_msg(CLOCK_NOT_SET_ID);
}
if ! self.common_env.wifi_connected && ! prev_wifi_connected {
self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ID);
}
let pddb = pddb::PddbMountPoller::new();
if ! pddb.is_mounted_nonblocking() {
self.common_env.scalar_async_msg(PDDB_NOT_MOUNTED_ID);
} else {
let pddb = pddb::PddbMountPoller::new();
if ! pddb.is_mounted_nonblocking() {
self.common_env.scalar_async_msg(PDDB_NOT_MOUNTED_ID);
} else {
// FUTURE: Check if Wifi is connected
// if not then
// self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ ID);
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);
self.common_env.version = get_version(&self.common_env.ticktimer);
log::info!("PDDB is mounted");
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);
self.common_env.version = get_version(&self.common_env.ticktimer);
if self.common_env.logged_in || self.common_env.login() {
run_migrations(&mut self.common_env);
self.common_env.initialized = true;
log::info!("initialized");
self.common_env.scalar_async_msg(MTXCLI_INITIALIZED_ID);
} else {
self.common_env.scalar_async_msg(PLEASE_LOGIN_ID);
}
}
}
if ! self.common_env.listening &&
self.common_env.logged_in &&
(HOSTED_MODE || self.common_env.wifi_connected) &&
self.common_env.initialized {
self.common_env.listen();
}
let maybe_verb = tokenize(cmdline);
let mut cmd_ret: Result<Option<XousString::<1024>>, xous::Error> = Ok(None);
@ -674,16 +733,13 @@ impl CmdEnv {
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))
self.common_env.user_says(&text);
// only for sync case Ok(Some(ret))
Ok(None)
}
} else {
log::info!("NO INPUT");
if self.common_env.read_messages(&mut ret) {
Ok(Some(ret))
} else {
Ok(None)
}
Ok(None)
}
} else if let Some(callback) = maybe_callback {
let mut cmd_ret: Result<Option<XousString::<1024>>, xous::Error> = Ok(None);
@ -716,6 +772,7 @@ impl CmdEnv {
}
}
/// extract the first token, as delimited by spaces
/// modifies the incoming line by removing the token and returning the remainder
/// returns the found token
@ -756,7 +813,7 @@ pub(crate) fn heap_usage() -> usize {
usage
}
_ => {
log::error!("Couldn't measure heap usage");
log::info!("Couldn't measure heap usage");
0
},
}
@ -769,8 +826,10 @@ pub fn clock_not_set() -> bool {
.expect("Time went backwards");
let seconds: u64 = since_the_epoch.as_secs();
if seconds < DATE_2023 {
log::info!("clock NOT set, seconds since epoch: {}", seconds);
true
} else {
log::info!("clock set, seconds since epoch: {}", seconds);
false
}
}

View file

@ -1,6 +1,6 @@
use crate::{ShellCmdApi,CommonEnv,
cmds::{CLOCK_NOT_SET_ID,PDDB_NOT_MOUNTED_ID,WIFI_NOT_CONNECTED_ID}};
use xous::{MessageEnvelope, Message,StringBuffer};
use crate::{ShellCmdApi, CommonEnv};
use crate::cmds::*;
use xous::{MessageEnvelope, Message, StringBuffer};
use xous_ipc::String as XousString;
use core::fmt::Write;
use locales::t;
@ -74,7 +74,7 @@ impl<'a> ShellCmdApi<'a> for Help {
}
// NOTE: the help callback is used to process async messages
fn callback(&mut self, msg: &MessageEnvelope, _env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
fn callback(&mut self, msg: &MessageEnvelope, env: &mut CommonEnv) -> Result<Option<XousString::<1024>>, xous::Error> {
match &msg.body {
Message::Scalar(xous::ScalarMessage{id: _, arg1: _, arg2: _,
arg3: _, arg4: async_msg_id}) => {
@ -89,6 +89,51 @@ impl<'a> ShellCmdApi<'a> for Help {
WIFI_NOT_CONNECTED_ID => {
t!("mtxcli.wifi.warning", xous::LANG)
},
MTXCLI_INITIALIZED_ID => {
t!("mtxcli.initialized", xous::LANG)
},
WIFI_CONNECTED_ID => {
t!("mtxcli.wifi.connected", xous::LANG)
},
SET_USER_ID => {
t!("mtxcli.please.set.user", xous::LANG)
},
SET_PASSWORD_ID => {
t!("mtxcli.please.set.password", xous::LANG)
},
LOGGED_IN_ID => {
t!("mtxcli.logged.in", xous::LANG)
},
LOGIN_FAILED_ID => {
t!("mtxcli.login.failed", xous::LANG)
},
SET_ROOM_ID => {
t!("mtxcli.please.set.room", xous::LANG)
},
ROOMID_FAILED_ID => {
t!("mtxcli.roomid.failed", xous::LANG)
},
FILTER_FAILED_ID => {
t!("mtxcli.filter.failed", xous::LANG)
},
SET_SERVER_ID => {
t!("mtxcli.please.set.server", xous::LANG)
},
LOGGING_IN_ID => {
t!("mtxcli.logging.in", xous::LANG)
},
LOGGED_OUT_ID => {
t!("mtxcli.logged.out", xous::LANG)
},
NOT_CONNECTED_ID => {
t!("mtxcli.not.connected", xous::LANG)
},
FAILED_TO_SEND_ID => {
t!("mtxcli.send.failed", xous::LANG)
},
PLEASE_LOGIN_ID => {
t!("mtxcli.please.login", xous::LANG)
},
_ => {
"unknown async_msg_id"
},
@ -100,10 +145,27 @@ impl<'a> ShellCmdApi<'a> for Help {
Message::Move(mm) => {
let str_buf = unsafe { StringBuffer::from_memory_message(mm) };
let msg = str_buf.to_str();
let mut ret = XousString::<1024>::new();
write!(ret, "{}", msg).unwrap();
// log::info!("async message \"{}\"", msg);
return Ok(Some(ret));
let mut ret = XousString::<1024>::new();
if msg.starts_with(SENTINEL) {
let msgv: Vec<&str> = msg.split(SENTINEL).collect();
if msgv.len() == 4 {
env.listen_over(msgv[1]);
if msgv[2].len() > 0 {
write!(ret, "{}", msgv[2]).unwrap();
return Ok(Some(ret));
} else {
return Ok(None);
}
} else {
log::info!("client_sync had an error");
env.listen_over(msgv[0]);
return Ok(None);
}
} else {
write!(ret, "{}", msg).unwrap();
return Ok(Some(ret));
}
},
_ => {
log::error!("received unknown callback type: {:?}", msg)

View file

@ -15,8 +15,7 @@ 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))
env.login();
Ok(None)
}
}

View file

@ -15,8 +15,7 @@ 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))
env.logout();
Ok(None)
}
}

View file

@ -71,5 +71,8 @@ pub fn run_migrations(common: &mut CommonEnv) {
}
common.set(VERSION_KEY, &common.version.clone())
.expect("cannot set _version");
let migrations_complete = t!("mtxcli.migrations.complete", xous::LANG);
log::info!("{}", migrations_complete);
common.send_async_msg(&migrations_complete);
}
}

View file

@ -1,6 +1,6 @@
use crate::{ShellCmdApi,CommonEnv};
use crate::cmds::*;
use xous_ipc::String as XousString;
use locales::t;
#[derive(Debug)]
pub struct Status {
@ -16,15 +16,11 @@ 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> {
let mut ret = XousString::<1024>::new();
let mut text = String::new();
text.push_str("status: ");
if env.logged_in {
text.push_str(t!("mtxcli.logged.in", xous::LANG));
env.scalar_async_msg(LOGGED_IN_ID);
} else {
text.push_str(t!("mtxcli.not.connected", xous::LANG));
env.scalar_async_msg(NOT_CONNECTED_ID);
}
env.prompt(&mut ret, &text);
Ok(Some(ret))
Ok(None)
}
}

View file

@ -30,7 +30,7 @@ fn serialize<T: ?Sized + Serialize>(object: &T) -> Option<String> {
Some(value)
},
Err(e) => {
log::error!("ERROR in serialize: {:?}", e);
log::info!("ERROR in serialize: {:?}", e);
None
}
}
@ -42,7 +42,7 @@ pub fn handle_response(maybe_response: Result<ureq::Response,ureq::Error>) -> Op
if let Ok(body) = response.into_json() {
Some(body)
} else {
log::error!("Error: could not convert response into JSON");
log::info!("Error: could not convert response into JSON");
None
}
},
@ -50,11 +50,11 @@ pub fn handle_response(maybe_response: Result<ureq::Response,ureq::Error>) -> Op
/* 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);
log::info!("ERROR code {} err_body = {}", code, err_body);
None
}
Err(e) => {
log::error!("ERROR in handle_response: {:?}", e);
log::info!("ERROR in handle_response: {:?}", e);
None
}
}
@ -107,10 +107,10 @@ pub fn whoami(server: &str, token: &str) -> bool {
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);
log::info!("device_id = {}", device_id);
}
if let Some(Value::String(user_id)) = body.get("user_id") {
log::debug!("user_id = {}", user_id);
log::info!("user_id = {}", user_id);
}
}
true
@ -192,21 +192,21 @@ pub fn get_room_id(server: &str, room_server: &str, token: &str) -> Option<Strin
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);
log::info!("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");
log::info!("invalid response for get_room_id");
None
}
} else {
log::error!("invalid response for get_room_id");
log::info!("invalid response for get_room_id");
None
}
} else {
log::error!("Error for get_room_id");
log::info!("Error for get_room_id");
None
}
}
@ -309,34 +309,34 @@ pub fn get_filter(user: &str, server: &str, room_id: &str, token: &str)
url.push_str("/_matrix/client/v3/user/");
url.push_str(&user_encoded);
url.push_str("/filter");
log::debug!("get_filter = {}", url);
log::info!("get_filter = {}", url);
let filter_request = FilterRequest::new(room_id);
if let Some(request_body) = serialize(&filter_request) {
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);
log::info!("filter_id = {}", filter_id);
Some(filter_id.to_string())
} else {
log::error!("invalid response for get_filter");
log::info!("invalid response for get_filter");
None
}
} else {
log::error!("invalid response for get_filter");
log::info!("invalid response for get_filter");
None
}
} else {
log::error!("Error for get_filter");
log::info!("Error for get_filter");
None
}
} else {
log::error!("Error unable to serialize request for get_filter");
log::info!("Error unable to serialize request for get_filter");
None
}
}
fn get_messages(body: Map<String, Value>, room_id: &str) -> String {
log::debug!("heap usage: {}", crate::cmds::heap_usage());
log::info!("heap usage: {}", crate::cmds::heap_usage());
let mut messages = String::new();
if let Some(Value::Object(rooms)) = body.get("rooms") {
if let Some(Value::Object(join)) = rooms.get("join") {
@ -378,7 +378,7 @@ fn get_messages(body: Map<String, Value>, room_id: &str) -> String {
pub fn client_sync(server: &str, filter: &str, since: &str, timeout: i32,
room_id: &str, token: &str) -> Option<(String, String)> {
log::debug!("heap usage: {}", crate::cmds::heap_usage());
log::info!("heap usage: {}", crate::cmds::heap_usage());
let mut url = String::from(server);
url.push_str("/_matrix/client/r0/sync?filter=");
url.push_str(filter);
@ -388,17 +388,17 @@ pub fn client_sync(server: &str, filter: &str, since: &str, timeout: i32,
url.push_str("&since=");
url.push_str(since);
}
log::debug!("client_sync = {}", url);
log::info!("client_sync = {}", url);
if let Some(value) = handle_response(get_json_auth(&url, token)) {
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");
log::info!("invalid response for client_sync");
None
}
} else {
log::error!("Error for client_sync: deserialization");
log::info!("Error for client_sync: deserialization");
None
}
} else {
@ -424,29 +424,29 @@ impl MessageRequest {
}
pub fn send_message(server: &str, room_id: &str, text: &str, txn_id: &str, token: &str) -> bool {
log::debug!("heap usage: {}", crate::cmds::heap_usage());
log::info!("heap usage: {}", crate::cmds::heap_usage());
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);
log::info!("send_message = {}", url);
let message_request = MessageRequest::new(text);
if let Some(request_body) = serialize(&message_request) {
if let Some(value) = handle_response(put_string_auth(&url, &request_body, token)) {
if let Value::Object(_body) = value {
true
} else {
log::error!("invalid response for send_message");
log::info!("invalid response for send_message");
false
}
} else {
log::error!("Error for send_message");
log::info!("Error for send_message");
false
}
} else {
log::error!("Error unable to serialize request for send_message");
log::info!("Error unable to serialize request for send_message");
false
}
}