Trait matrix_sdk_crypto::store::CryptoStore

pub trait CryptoStore: AsyncTraitDeps {
    type Error: Debug + Into<CryptoStoreError>;

    // Required methods
    fn load_account<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_identity<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Option<PrivateCrossSigningIdentity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_changes<'life0, 'async_trait>(
        &'life0 self,
        changes: Changes
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_pending_changes<'life0, 'async_trait>(
        &'life0 self,
        changes: PendingChanges
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_sessions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        sender_key: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<Mutex<Vec<Session>>>>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_inbound_group_session<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId,
        session_id: &'life2 str
    ) -> Pin<Box<dyn Future<Output = Result<Option<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_withheld_info<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId,
        session_id: &'life2 str
    ) -> Pin<Box<dyn Future<Output = Result<Option<RoomKeyWithheldEvent>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_inbound_group_sessions<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn inbound_group_session_counts<'life0, 'life1, 'async_trait>(
        &'life0 self,
        backup_version: Option<&'life1 str>
    ) -> Pin<Box<dyn Future<Output = Result<RoomKeyCounts, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn inbound_group_sessions_for_backup<'life0, 'life1, 'async_trait>(
        &'life0 self,
        backup_version: &'life1 str,
        limit: usize
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn mark_inbound_group_sessions_as_backed_up<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        backup_version: &'life1 str,
        room_and_session_ids: &'life2 [(&'life3 RoomId, &'life4 str)]
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn reset_backup_state<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_backup_keys<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<BackupKeys, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_outbound_group_session<'life0, 'life1, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId
    ) -> Pin<Box<dyn Future<Output = Result<Option<OutboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_tracked_users<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<TrackedUser>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_tracked_users<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        users: &'life1 [(&'life2 UserId, bool)]
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_device<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        user_id: &'life1 UserId,
        device_id: &'life2 DeviceId
    ) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyDevice>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_user_devices<'life0, 'life1, 'async_trait>(
        &'life0 self,
        user_id: &'life1 UserId
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<OwnedDeviceId, ReadOnlyDevice>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_user_identity<'life0, 'life1, 'async_trait>(
        &'life0 self,
        user_id: &'life1 UserId
    ) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyUserIdentities>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_message_known<'life0, 'life1, 'async_trait>(
        &'life0 self,
        message_hash: &'life1 OlmMessageHash
    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_outgoing_secret_requests<'life0, 'life1, 'async_trait>(
        &'life0 self,
        request_id: &'life1 TransactionId
    ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_secret_request_by_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        secret_info: &'life1 SecretInfo
    ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_unsent_secret_requests<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GossipRequest>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete_outgoing_secret_requests<'life0, 'life1, 'async_trait>(
        &'life0 self,
        request_id: &'life1 TransactionId
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_secrets_from_inbox<'life0, 'life1, 'async_trait>(
        &'life0 self,
        secret_name: &'life1 SecretName
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GossippedSecret>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_secrets_from_inbox<'life0, 'life1, 'async_trait>(
        &'life0 self,
        secret_name: &'life1 SecretName
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_room_settings<'life0, 'life1, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId
    ) -> Pin<Box<dyn Future<Output = Result<Option<RoomSettings>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_custom_value<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn set_custom_value<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 str,
        value: Vec<u8>
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn remove_custom_value<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn try_take_leased_lock<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        lease_duration_ms: u32,
        key: &'life1 str,
        holder: &'life2 str
    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn next_batch_token<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn clear_caches<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Represents a store that the OlmMachine uses to store E2EE data (such as cryptographic keys).

Required Associated Types

type Error: Debug + Into<CryptoStoreError>

The error type used by this crypto store.

Required Methods

fn load_account<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load an account that was previously stored.

fn load_identity<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Option<PrivateCrossSigningIdentity>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Try to load a private cross signing identity, if one is stored.

fn save_changes<'life0, 'async_trait>( &'life0 self, changes: Changes ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save the set of changes to the store.

Arguments

• changes - The set of changes that should be stored.

fn save_pending_changes<'life0, 'async_trait>( &'life0 self, changes: PendingChanges ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save the set of changes to the store.

This is an updated version of save_changes that will replace it as #2624 makes progress.

Arguments

• changes - The set of changes that should be stored.

fn get_sessions<'life0, 'life1, 'async_trait>( &'life0 self, sender_key: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<Mutex<Vec<Session>>>>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all the sessions that belong to the given sender key.

Arguments

• sender_key - The sender key that was used to establish the sessions.

fn get_inbound_group_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, session_id: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Option<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get the inbound group session from our store.

Arguments

• room_id - The room id of the room that the session belongs to.

• sender_key - The sender key that sent us the session.

• session_id - The unique id of the session.

fn get_withheld_info<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, session_id: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<Option<RoomKeyWithheldEvent>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get withheld info for this key. Allows to know if the session was not sent on purpose. This only returns withheld info sent by the owner of the group session, not the one you can get from a response to a key request from another of your device.

fn get_inbound_group_sessions<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get all the inbound group sessions we have stored.

fn inbound_group_session_counts<'life0, 'life1, 'async_trait>( &'life0 self, backup_version: Option<&'life1 str> ) -> Pin<Box<dyn Future<Output = Result<RoomKeyCounts, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the number inbound group sessions we have and how many of them are backed up.

fn inbound_group_sessions_for_backup<'life0, 'life1, 'async_trait>( &'life0 self, backup_version: &'life1 str, limit: usize ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Return a batch of [‘InboundGroupSession’] (“room keys”) that have not yet been backed up in the supplied backup version.

The size of the returned Vec is <= limit.

Note: some implementations ignore backup_version and assume the current backup version, which is normally the same.

fn mark_inbound_group_sessions_as_backed_up<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, backup_version: &'life1 str, room_and_session_ids: &'life2 [(&'life3 RoomId, &'life4 str)] ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Store the fact that the supplied sessions were backed up into the backup with version backup_version.

Note: some implementations ignore backup_version and assume the current backup version, which is normally the same.

fn reset_backup_state<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reset the backup state of all the stored inbound group sessions.

Note: this is mostly implemented by stores that ignore the backup_version argument on inbound_group_sessions_for_backup and mark_inbound_group_sessions_as_backed_up. Implementations that pay attention to the supplied backup version probably don’t need to update their storage when the current backup version changes, so have empty implementations of this method.

fn load_backup_keys<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<BackupKeys, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the backup keys we have stored.

fn get_outbound_group_session<'life0, 'life1, 'async_trait>( &'life0 self, room_id: &'life1 RoomId ) -> Pin<Box<dyn Future<Output = Result<Option<OutboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the outbound group session we have stored that is used for the given room.

fn load_tracked_users<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<TrackedUser>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide the list of users whose devices we are keeping track of, and whether they are considered dirty/outdated.

fn save_tracked_users<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, users: &'life1 [(&'life2 UserId, bool)] ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update the list of users whose devices we are keeping track of, and whether they are considered dirty/outdated.

Replaces any existing entry with a matching user ID.

fn get_device<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_id: &'life1 UserId, device_id: &'life2 DeviceId ) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyDevice>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get the device for the given user with the given device ID.

Arguments

• user_id - The user that the device belongs to.

• device_id - The unique id of the device.

fn get_user_devices<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 UserId ) -> Pin<Box<dyn Future<Output = Result<HashMap<OwnedDeviceId, ReadOnlyDevice>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all the devices of the given user.

Arguments

• user_id - The user for which we should get all the devices.

fn get_user_identity<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 UserId ) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyUserIdentities>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the user identity that is attached to the given user id.

Arguments

• user_id - The user for which we should get the identity.

fn is_message_known<'life0, 'life1, 'async_trait>( &'life0 self, message_hash: &'life1 OlmMessageHash ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a hash for an Olm message stored in the database.

fn get_outgoing_secret_requests<'life0, 'life1, 'async_trait>( &'life0 self, request_id: &'life1 TransactionId ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get an outgoing secret request that we created that matches the given request id.

Arguments

• request_id - The unique request id that identifies this outgoing secret request.

fn get_secret_request_by_info<'life0, 'life1, 'async_trait>( &'life0 self, secret_info: &'life1 SecretInfo ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get an outgoing key request that we created that matches the given requested key info.

Arguments

• key_info - The key info of an outgoing secret request.

fn get_unsent_secret_requests<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Vec<GossipRequest>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get all outgoing secret requests that we have in the store.

fn delete_outgoing_secret_requests<'life0, 'life1, 'async_trait>( &'life0 self, request_id: &'life1 TransactionId ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete an outgoing key request that we created that matches the given request id.

Arguments

• request_id - The unique request id that identifies this outgoing key request.

fn get_secrets_from_inbox<'life0, 'life1, 'async_trait>( &'life0 self, secret_name: &'life1 SecretName ) -> Pin<Box<dyn Future<Output = Result<Vec<GossippedSecret>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all the secrets with the given SecretName we have currently stored.

fn delete_secrets_from_inbox<'life0, 'life1, 'async_trait>( &'life0 self, secret_name: &'life1 SecretName ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete all the secrets with the given SecretName we have currently stored.

fn get_room_settings<'life0, 'life1, 'async_trait>( &'life0 self, room_id: &'life1 RoomId ) -> Pin<Box<dyn Future<Output = Result<Option<RoomSettings>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the room settings, such as the encryption algorithm or whether to encrypt only for trusted devices.

Arguments

• room_id - The room id of the room

fn get_custom_value<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get arbitrary data from the store

Arguments

• key - The key to fetch data for

fn set_custom_value<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, value: Vec<u8> ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Put arbitrary data into the store

Arguments

• key - The key to insert data into

• value - The value to insert

fn remove_custom_value<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove arbitrary data into the store

Arguments

• key - The key to insert data into

fn try_take_leased_lock<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, lease_duration_ms: u32, key: &'life1 str, holder: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Try to take a leased lock.

This attempts to take a lock for the given lease duration.

• If we already had the lease, this will extend the lease.
• If we didn’t, but the previous lease has expired, we will acquire the lock.
• If there was no previous lease, we will acquire the lock.
• Otherwise, we don’t get the lock.

Returns whether taking the lock succeeded.

fn next_batch_token<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Option<String>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load the next-batch token for a to-device query, if any.

fn clear_caches<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear any in-memory caches because they may be out of sync with the underlying data store.

If the store does not have any underlying persistence (e.g in-memory store) then this should be a no-op.

Implementors

impl CryptoStore for MemoryStore

type Error = Infallible