mtxchat replace EMPTY String with Option<String>

This commit is contained in:
nworbnhoj 2023-09-13 15:31:23 +10:00
parent d8db9ad2a7
commit 747fb93c58

View file

@ -8,9 +8,9 @@ use chat::{Chat, ChatOp};
use locales::t; use locales::t;
use modals::Modals; use modals::Modals;
use pddb::Pddb; use pddb::Pddb;
use std::sync::Arc;
use std::fmt::Write as _; use std::fmt::Write as _;
use std::io::{Error, ErrorKind, Read, Write as StdWrite}; use std::io::{Error, ErrorKind, Read, Write as StdWrite};
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH}; use std::time::{SystemTime, UNIX_EPOCH};
use tls::Tls; use tls::Tls;
use trng::*; use trng::*;
@ -35,7 +35,6 @@ const USER_DOMAIN_KEY: &str = "user_domain";
const HTTPS: &str = "https://"; const HTTPS: &str = "https://";
const DOMAIN_MATRIX: &str = "matrix.org"; const DOMAIN_MATRIX: &str = "matrix.org";
const EMPTY: &str = "";
const MTX_LONG_TIMEOUT: i32 = 60000; // ms const MTX_LONG_TIMEOUT: i32 = 60000; // ms
const WIFI_TIMEOUT: u32 = 10; // seconds const WIFI_TIMEOUT: u32 = 10; // seconds
@ -69,17 +68,17 @@ pub struct MtxChat<'a> {
trng: Trng, trng: Trng,
pddb: Pddb, pddb: Pddb,
netmgr: net::NetManager, netmgr: net::NetManager,
user_id: String, user_id: Option<String>,
user_name: String, user_name: Option<String>,
user_domain: String, user_domain: Option<String>,
agent: Agent, agent: Agent,
token: String, token: Option<String>,
logged_in: bool, logged_in: bool,
room_id: String, room_id: Option<String>,
room_name: String, room_name: Option<String>,
room_domain: String, room_domain: Option<String>,
filter: String, filter: Option<String>,
since: String, since: Option<String>,
listening: bool, listening: bool,
modals: Modals, modals: Modals,
new_username: bool, new_username: bool,
@ -98,19 +97,19 @@ impl<'a> MtxChat<'a> {
trng: trng, trng: trng,
pddb: pddb, pddb: pddb,
netmgr: net::NetManager::new(), netmgr: net::NetManager::new(),
user_id: EMPTY.to_string(), user_id: None,
user_name: EMPTY.to_string(), user_name: None,
user_domain: DOMAIN_MATRIX.to_string(), user_domain: Some(DOMAIN_MATRIX.to_string()),
agent: ureq::builder() agent: ureq::builder()
.tls_config(Arc::new(tls.client_config())) .tls_config(Arc::new(tls.client_config()))
.build(), .build(),
token: EMPTY.to_string(), token: None,
logged_in: false, logged_in: false,
room_id: EMPTY.to_string(), room_id: None,
room_name: EMPTY.to_string(), room_name: None,
room_domain: EMPTY.to_string(), room_domain: None,
filter: EMPTY.to_string(), filter: None,
since: EMPTY.to_string(), since: None,
listening: false, listening: false,
modals: modals, modals: modals,
new_username: false, new_username: false,
@ -143,16 +142,16 @@ impl<'a> MtxChat<'a> {
}; };
match key { match key {
// update cached values // update cached values
FILTER_KEY => self.filter = value.to_string(), FILTER_KEY => self.filter = Some(value.to_string()),
PASSWORD_KEY => (), PASSWORD_KEY => (),
ROOM_ID_KEY => self.room_id = value.to_string(), ROOM_ID_KEY => self.room_id = Some(value.to_string()),
ROOM_NAME_KEY => self.room_name = value.to_string(), ROOM_NAME_KEY => self.room_name = Some(value.to_string()),
ROOM_DOMAIN_KEY => self.room_domain = value.to_string(), ROOM_DOMAIN_KEY => self.room_domain = Some(value.to_string()),
SINCE_KEY => self.since = value.to_string(), SINCE_KEY => self.since = Some(value.to_string()),
TOKEN_KEY => self.token = value.to_string(), TOKEN_KEY => self.token = Some(value.to_string()),
USER_NAME_KEY => self.user_name = value.to_string(), USER_NAME_KEY => self.user_name = Some(value.to_string()),
USER_DOMAIN_KEY => self.user_domain = value.to_string(), USER_DOMAIN_KEY => self.user_domain = Some(value.to_string()),
USER_ID_KEY => self.user_id = value.to_string(), USER_ID_KEY => self.user_id = Some(value.to_string()),
_ => {} _ => {}
} }
Ok(()) Ok(())
@ -187,13 +186,14 @@ impl<'a> MtxChat<'a> {
} }
match key { match key {
// update cached values // update cached values
FILTER_KEY => self.filter = EMPTY.to_string(), FILTER_KEY => self.filter = None,
ROOM_ID_KEY => self.room_id = EMPTY.to_string(), PASSWORD_KEY => (),
ROOM_DOMAIN_KEY => self.room_domain = EMPTY.to_string(), ROOM_ID_KEY => self.room_id = None,
SINCE_KEY => self.since = EMPTY.to_string(), ROOM_DOMAIN_KEY => self.room_domain = None,
USER_DOMAIN_KEY => self.user_domain = EMPTY.to_string(), SINCE_KEY => self.since = None,
USER_ID_KEY => self.user_id = EMPTY.to_string(), USER_DOMAIN_KEY => self.user_domain = None,
USER_NAME_KEY => self.user_name = EMPTY.to_string(), USER_ID_KEY => self.user_id = None,
USER_NAME_KEY => self.user_name = None,
_ => {} _ => {}
} }
Ok(()) Ok(())
@ -238,17 +238,6 @@ impl<'a> MtxChat<'a> {
Ok(value) Ok(value)
} }
pub fn get_or(&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::info!("error getting key {}: {:?}", key, e);
default.to_string()
}
}
}
pub fn connect(&mut self) -> bool { pub fn connect(&mut self) -> bool {
log::info!("Attempting connect to Matrix server"); log::info!("Attempting connect to Matrix server");
if self.wifi() { if self.wifi() {
@ -287,18 +276,21 @@ impl<'a> MtxChat<'a> {
} }
pub fn login(&mut self) -> bool { pub fn login(&mut self) -> bool {
self.token = self.get_or(TOKEN_KEY, EMPTY); self.token = self.get(TOKEN_KEY).unwrap_or(None);
self.logged_in = false; self.logged_in = false;
let mut server = String::new(); let mut server = String::new();
write!( write!(
server, server,
"{}{}", "{}{}",
HTTPS, HTTPS,
&self.get_or(USER_DOMAIN_KEY, DOMAIN_MATRIX) &self
.get(USER_DOMAIN_KEY)
.unwrap_or(Some(DOMAIN_MATRIX.to_string()))
.unwrap_or("".to_string())
) )
.expect("failed to write server"); .expect("failed to write server");
if self.token.len() > 0 { if let Some(token) = &self.token {
if let Some(user_id) = web::whoami(&server, &self.token, &mut self.agent) { if let Some(user_id) = web::whoami(&server, &token, &mut self.agent) {
let i = match user_id.find('@') { let i = match user_id.find('@') {
Some(index) => index + 1, Some(index) => index + 1,
None => 0, None => 0,
@ -319,16 +311,22 @@ impl<'a> MtxChat<'a> {
if !self.logged_in { if !self.logged_in {
if web::get_login_type(&server, &mut self.agent) { if web::get_login_type(&server, &mut self.agent) {
self.login_modal(); self.login_modal();
let password = self.get_or(PASSWORD_KEY, EMPTY); let log_entry = match (&self.user_id, self.get(PASSWORD_KEY).unwrap_or(None)) {
if let Some(new_token) = web::authenticate_user(&server, &self.user_id, &password, &mut self.agent) { (Some(user_id), Some(password)) => {
self.set_debug(TOKEN_KEY, &new_token); if let Some(new_token) =
self.logged_in = true; web::authenticate_user(&server, &user_id, &password, &mut self.agent)
} else { {
log::warn!( self.set_debug(TOKEN_KEY, &new_token);
"Error: cannnot login with type: {}", self.logged_in = true;
web::MTX_LOGIN_PASSWORD "authenticated user"
); } else {
} "Error: cannnot login with password"
}
}
(None, _) => "missing user id",
(_, None) => "missing password",
};
log::info!("{log_entry}");
} else { } else {
log::warn!("failed to web::get_login_type()"); log::warn!("failed to web::get_login_type()");
} }
@ -385,17 +383,21 @@ impl<'a> MtxChat<'a> {
.expect("failed to save password"); .expect("failed to save password");
} }
} }
let mut user_id = String::new(); if let Some(user_name) = &self.user_name {
write!(user_id, "@{}:{}", self.user_name, self.user_domain) if let Some(user_domain) = &self.user_domain {
.expect("failed to write user_id"); let mut user_id = String::new();
self.set(USER_ID_KEY, &user_id) write!(user_id, "@{}:{}", user_name, user_domain)
.expect("failed to save user"); .expect("failed to write user_id");
self.set(USER_ID_KEY, &user_id)
.expect("failed to save user");
}
}
} }
log::info!( log::info!(
"# user = '{}' user_name = '{}' server = '{}'", "# user = {:?} user_name = {:?} server = {:?}",
self.user_id, self.user_id,
self.user_name, self.user_name,
self.user_domain self.user_domain,
); );
} }
@ -404,20 +406,35 @@ impl<'a> MtxChat<'a> {
// TODO logout with server // TODO logout with server
} }
// assume logged in, token is valid
pub fn get_room_id(&mut self) -> Option<String> { pub fn get_room_id(&mut self) -> Option<String> {
let mut room = String::new();
self.room_modal(); self.room_modal();
write!(room, "#{}:{}", &self.room_name, &self.room_domain).expect("failed to write room"); let log_entry = match (
let mut server = String::new(); self.logged_in,
write!(server, "{}{}", HTTPS, &self.user_domain).expect("failed to write server"); &self.token,
if let Some(room_id) = web::get_room_id(&server, &room, &self.token, &mut self.agent) { &self.user_domain,
self.set_debug(ROOM_ID_KEY, &room_id); &self.room_name,
Some(room) &self.room_domain,
} else { ) {
log::warn!("failed to return room_id"); (true, Some(token), Some(user_domain), Some(room_name), Some(room_domain)) => {
None let mut room = String::new();
} write!(room, "#{}:{}", &room_name, &room_domain).expect("failed to write room");
let mut server = String::new();
write!(server, "{}{}", HTTPS, &user_domain).expect("failed to write server");
if let Some(room_id) = web::get_room_id(&server, &room, &token, &mut self.agent) {
self.set_debug(ROOM_ID_KEY, &room_id);
return Some(room);
} else {
"failed to get room_id"
}
}
(false, _, _, _, _) => "Not logged in",
(_, None, _, _, _) => "No token set",
(_, _, None, _, _) => "No user domain set",
(_, _, _, None, _) => "No room name set",
(_, _, _, _, None) => "No room domain set",
};
log::warn!("{log_entry}");
None
} }
pub fn redraw(&self) { pub fn redraw(&self) {
@ -473,111 +490,134 @@ impl<'a> MtxChat<'a> {
self.chat.help(); self.chat.help();
} }
// assume logged in, token is valid, room_id is valid, user is valid
pub fn get_filter(&mut self) -> bool { pub fn get_filter(&mut self) -> bool {
if self.filter.len() > 0 { let log_entry = match (
true &self.filter,
} else { &self.logged_in,
let mut server = String::new(); &self.token,
write!(server, "{}{}", HTTPS, &self.user_domain).expect("failed to write server"); &self.user_id,
log::info!( &self.user_domain,
"get_filter {} : {} : {} : {}", &self.room_id,
&self.user_id, ) {
&server, (Some(_filter), _, _, _, _, _) => "filter already set",
&self.room_id, (_, true, Some(token), Some(user_id), Some(user_domain), Some(room_id)) => {
&self.token let mut server = String::new();
); write!(server, "{}{}", HTTPS, &user_domain).expect("failed to write server");
if let Some(new_filter) = log::info!(
web::get_filter(&self.user_id, &server, &self.room_id, &self.token, &mut self.agent) "get_filter {} : {} : {} : {}",
{ &user_id,
self.set_debug(FILTER_KEY, &new_filter); &server,
true &room_id,
} else { &token
false );
if let Some(new_filter) =
web::get_filter(&user_id, &server, &room_id, &token, &mut self.agent)
{
if self.set_debug(FILTER_KEY, &new_filter) {
"set filter"
} else {
"failed to set"
}
} else {
"failed to get filter"
}
} }
} (_, false, _, _, _, _) => "Not logged in",
(_, _, None, _, _, _) => "No token set",
(_, _, _, None, _, _) => "No user id set",
(_, _, _, _, None, _) => "No user domain set",
(_, _, _, _, _, None) => "No room id set",
};
log::warn!("{log_entry}");
self.filter.is_some()
} }
pub fn listen(&mut self) { pub fn listen(&mut self) {
if self.listening { self.get_filter();
log::info!("Already listening"); let log_entry = match (
return; self.listening,
} self.logged_in,
if !self.logged_in { &self.token,
log::info!("Not logged in"); &self.room_id,
return; &self.filter,
} ) {
if self.room_id.len() == 0 { (false, true, Some(token), Some(room_id), Some(filter)) => {
log::info!("No room id set"); self.listening = true;
return; std::thread::spawn({
} let domain = self
if self.filter.len() == 0 { .get(ROOM_DOMAIN_KEY)
if !self.get_filter() { .unwrap_or(Some(DOMAIN_MATRIX.to_string()))
return; .unwrap_or("".to_string());
} let mut server = String::new();
} write!(server, "{}{}", HTTPS, &domain,).expect("failed to write server");
self.listening = true; let mut agent = self.agent.clone();
log::info!("Started listening"); let filter = filter.clone();
std::thread::spawn({ let since = self.since.clone();
let mut server = String::new(); let room_id = room_id.clone();
write!( let token = token.clone();
server, let chat_cid = self.chat.cid();
"{}{}", move || {
HTTPS, let xns = xous_names::XousNames::new().unwrap();
&self.get_or(ROOM_DOMAIN_KEY, DOMAIN_MATRIX) let modals = Modals::new(&xns).expect("can't connect to Modals server");
) log::info!("client_sync for {} ms...", MTX_LONG_TIMEOUT);
.expect("failed to write server"); if let Some((_since, events)) = web::client_sync(
let mut agent = self.agent.clone(); &server,
let filter = self.filter.clone(); &filter,
let since = self.since.clone(); since.as_deref(),
let room_id = self.room_id.clone(); MTX_LONG_TIMEOUT,
let token = self.token.clone(); &room_id,
let chat_cid = self.chat.cid(); &token,
move || { &mut agent,
let xns = xous_names::XousNames::new().unwrap(); ) {
let modals = Modals::new(&xns).expect("can't connect to Modals server"); // TODO send "since" to mtxchat server
log::info!("client_sync for {} ms...", MTX_LONG_TIMEOUT); // and you probably want to have a look at Dialogue::MAX_BYTES
if let Some((_since, events)) =
web::client_sync(&server, &filter, &since, MTX_LONG_TIMEOUT, &room_id, &token, &mut agent)
{
// TODO send "since" to mtxchat server
// and you probably want to have a look at Dialogue::MAX_BYTES
// TODO resolve suspected race condition // TODO resolve suspected race condition
// This progress modal is masking a bug by slowing the loop down // This progress modal is masking a bug by slowing the loop down
// Precursor "Guru Mediation" `voilated: nonNull::new_unchecked` // Precursor "Guru Mediation" `voilated: nonNull::new_unchecked`
modals modals
.start_progress("Receiving events ...", 0, events.len() as u32, 0) .start_progress("Receiving events ...", 0, events.len() as u32, 0)
.expect("no progress bar"); .expect("no progress bar");
let mut event_count = 0; let mut event_count = 0;
for event in events { for event in events {
let sender = event.sender.unwrap_or("anon".to_string()); let sender = event.sender.unwrap_or("anon".to_string());
let body = event.body.unwrap_or("...".to_string()); let body = event.body.unwrap_or("...".to_string());
let post = chat::Post { let post = chat::Post {
author: xous_ipc::String::from_str(&get_username(&sender)), author: xous_ipc::String::from_str(&get_username(&sender)),
timestamp: event.ts.unwrap_or(0), timestamp: event.ts.unwrap_or(0),
text: xous_ipc::String::from_str(&body), text: xous_ipc::String::from_str(&body),
attach_url: None, attach_url: None,
}; };
match Buffer::into_buf(post) { match Buffer::into_buf(post) {
Ok(buf) => buf.send(chat_cid, ChatOp::PostAdd as u32).map(|_| ()), Ok(buf) => {
Err(_) => Err(xous::Error::InternalError), buf.send(chat_cid, ChatOp::PostAdd as u32).map(|_| ())
}
Err(_) => Err(xous::Error::InternalError),
}
.expect("failed to convert post into buffer");
event_count += 1;
modals
.update_progress(event_count)
.expect("no progress update");
}
} }
.expect("failed to convert post into buffer"); modals.finish_progress().expect("failed progress finish");
event_count += 1; // trigger the chat ui to save the dialogue to the pddb
modals xous::send_message(
.update_progress(event_count) chat_cid,
.expect("no progress update"); xous::Message::new_scalar(ChatOp::DialogueSave as usize, 0, 0, 0, 0),
)
} }
} });
modals.finish_progress().expect("failed progress finish"); "Started listening"
// trigger the chat ui to save the dialogue to the pddb
xous::send_message(
chat_cid,
xous::Message::new_scalar(ChatOp::DialogueSave as usize, 0, 0, 0, 0),
)
} }
}); (true, _, _, _, _) => "Already listening",
(_, false, _, _, _) => "Not logged in",
(_, _, None, _, _) => "No token set",
(_, _, _, None, _) => "No room id set",
(_, _, _, _, None) => "No filter set",
};
log::info!("{log_entry}");
} }
pub fn listen_over(&mut self, since: &str) { pub fn listen_over(&mut self, since: &str) {
@ -603,24 +643,29 @@ impl<'a> MtxChat<'a> {
} }
pub fn post(&mut self, text: &str) { pub fn post(&mut self, text: &str) {
if !self.logged_in {
if !self.login() {
return;
}
}
if self.room_id.len() == 0 {
log::info!("No room id set");
return;
}
let txn_id = self.gen_txn_id(); let txn_id = self.gen_txn_id();
log::info!("txn_id = {}", txn_id); let log_entry = match (
let mut server = String::new(); self.logged_in,
write!(server, "{}{}", HTTPS, &self.user_domain).expect("failed to write server"); &self.token,
if web::send_message(&server, &self.room_id, &text, &txn_id, &self.token, &mut self.agent) { &self.user_domain,
log::info!("SENT: {}", text); &self.room_id,
} else { ) {
log::info!("FAILED TO SEND"); (true, Some(token), Some(user_domain), Some(room_id)) => {
} log::info!("txn_id = {}", txn_id);
let mut server = String::new();
write!(server, "{}{}", HTTPS, &user_domain).expect("failed to write server");
if web::send_message(&server, &room_id, &text, &txn_id, token, &mut self.agent) {
"SENT"
} else {
"FAILED TO SEND"
}
}
(false, _, _, _) => "Not logged in",
(_, None, _, _) => "No token set",
(_, _, None, _) => "No user domain set",
(_, _, _, None) => "No room id set",
};
log::info!("{log_entry}");
} }
// returns true is wifi is connected // returns true is wifi is connected