Securejoin: store bobstate in database instead of context

The state bob needs to maintain during a secure-join process when
exchanging messages used to be stored on the context.  This means if
the process was killed this state was lost and the securejoin process
would fail.  Moving this state into the database should help this.

This still only allows a single securejoin process at a time, this may
be relaxed in the future.  For now any previous securejoin process
that was running is killed if a new one is started (this was already
the case).

This can remove some of the complexity around BobState handling: since
the state is in the database we can already make state interactions
transactional and correct.  We no longer need the mutex around the
state handling.  This means the BobStateHandle construct that was
handling the interactions between always having a valid state and
handling the mutex is no longer needed, resulting in some nice
simplifications.

Part of #2777.

Author: flub

src/chat.rs

@@ -175,7 +175,7 @@ impl ChatId {
     /// Returns the unblocked 1:1 chat with `contact_id`.
     ///
     /// This should be used when **a user action** creates a chat 1:1, it ensures the chat
-    /// exists and is unblocked and scales the [`Contact`]'s origin.
+    /// exists, is unblocked and scales the [`Contact`]'s origin.
     pub async fn create_for_contact(context: &Context, contact_id: u32) -> Result<Self> {
         ChatId::create_for_contact_with_blocked(context, contact_id, Blocked::Not).await
     }

src/context.rs

@@ -24,7 +24,6 @@ use crate::login_param::LoginParam;
 use crate::message::{self, MessageState, MsgId};
 use crate::quota::QuotaInfo;
 use crate::scheduler::Scheduler;
-use crate::securejoin::Bob;
 use crate::sql::Sql;
 
 #[derive(Clone, Debug)]
@@ -45,7 +44,6 @@ pub struct InnerContext {
     /// Blob directory path
     pub(crate) blobdir: PathBuf,
     pub(crate) sql: Sql,
-    pub(crate) bob: Bob,
     pub(crate) last_smeared_timestamp: RwLock<i64>,
     pub(crate) running_state: RwLock<RunningState>,
     /// Mutex to avoid generating the key for the user more than once.
@@ -171,7 +169,6 @@ impl Context {
             blobdir,
             running_state: RwLock::new(Default::default()),
             sql: Sql::new(dbfile),
-            bob: Default::default(),
             last_smeared_timestamp: RwLock::new(0),
             generating_key_mutex: Mutex::new(()),
             oauth2_mutex: Mutex::new(()),

src/events.rs

@@ -334,3 +334,26 @@ pub enum EventType {
         status_update_id: StatusUpdateId,
     },
 }
+
+/// Progress indicator with mili-units precision.
+///
+/// This indicates a linear progress, generally from 0 to 1000, however the extreme values
+/// have their own enum variants for clarity.
+#[derive(Debug, Copy, Clone)]
+pub enum Progress {
+    /// The progress reported has encountered an error.
+    Error,
+    /// A progress indication between 1-999.
+    Progress(usize),
+    /// The progress reported has completed.
+    Complete,
+}
+
+/// Trait to report progress.
+///
+/// Normal usage is to convert custom enums to a standard progress report which can be shown
+/// as a progress bar.
+pub trait ProgressReport {
+    /// Current progress.
+    fn progress(&self) -> Progress;
+}

src/key.rs

@@ -318,7 +318,7 @@ pub async fn store_self_keypair(
 }
 
 /// A key fingerprint
-#[derive(Clone, Eq, PartialEq, Hash)]
+#[derive(Clone, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct Fingerprint(Vec<u8>);
 
 impl Fingerprint {