Page MenuHomePhabricator
Differential D11280

[lib] Add a reducer that handles successful ops processing
ClosedPublic
Actions

Authored by tomek on Mar 8 2024, 1:00 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Mar 30, 2:40 AM
Unknown Object (File)
Sun, Mar 30, 1:41 AM
Unknown Object (File)
Sun, Mar 30, 12:00 AM
Unknown Object (File)
Sat, Mar 29, 11:13 AM
Unknown Object (File)
Fri, Mar 28, 4:19 PM
Unknown Object (File)
Fri, Mar 28, 1:46 PM
Unknown Object (File)
Wed, Mar 26, 11:42 PM
Unknown Object (File)
Feb 27 2025, 9:53 PM
View All Files
Subscribers
ashoat

Details

Reviewers
kamil
inka
will
Commits
rCOMMbac8331a77bc: [lib] Add a reducer that handles successful ops processing
Summary

Remove the front of the queue when we are noticed that the processing was successful

https://linear.app/comm/issue/ENG-7102/reduce-the-action-this-should-filter-the-ops-out-from-the-array

Depends on D11279

Test Plan

Tests

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

tomek created this revision.Mar 8 2024, 1:00 AM
Herald added a subscriber: ashoat. · View Herald TranscriptMar 8 2024, 1:00 AM
Harbormaster completed remote builds in B27398: Diff 37942.Mar 8 2024, 1:16 AM
tomek requested review of this revision.Mar 8 2024, 1:16 AM
tomek added a child revision: D11281: [lib] Add an optional ID field to all the actions.Mar 8 2024, 2:28 AM
kamil accepted this revision.Mar 11 2024, 4:13 AM
kamil added inline comments.
lib/reducers/db-ops-reducer.js
7 ↗(On Diff #37942)
This revision is now accepted and ready to land.Mar 11 2024, 4:13 AM
tomek updated this revision to Diff 38261.Mar 21 2024, 5:04 AM

Rename, rebase

Harbormaster completed remote builds in B27640: Diff 38261.Mar 21 2024, 5:19 AM
tomek updated this revision to Diff 38266.Mar 21 2024, 8:08 AM

Simplify reducer logic

Harbormaster completed remote builds in B27645: Diff 38266.Mar 21 2024, 8:23 AM
tomek updated this revision to Diff 38367.Mar 27 2024, 8:45 AM

Simplify

tomek edited the summary of this revision. (Show Details)Mar 27 2024, 8:47 AM
Harbormaster completed remote builds in B27704: Diff 38367.Mar 27 2024, 9:01 AM
Closed by commit rCOMMbac8331a77bc: [lib] Add a reducer that handles successful ops processing (authored by tomek). · Explain WhyMar 28 2024, 8:11 AM
This revision was automatically updated to reflect the committed changes.
tomek added a commit: rCOMMbac8331a77bc: [lib] Add a reducer that handles successful ops processing.

Revision Contents
Changeset List

PathSize
lib/
reducers/
18 lines
34 lines
2 lines

Diff 38453

View Options

lib/reducers/db-ops-reducer.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines
View Options

lib/reducers/db-ops-reducer.test.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines
View Options

lib/reducers/master-reducer.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import * as React from 'react'; import * as React from 'react';
import { usePeerOlmSessionsCreatorContext } from '../components/peer-olm-session-creator-provider.react.js';
import { import {
useBroadcastDeviceListUpdates, useBroadcastDeviceListUpdates,
useBroadcastAccountDeletion, useBroadcastAccountDeletion,
} from '../hooks/peer-list-hooks.js'; } from '../hooks/peer-list-hooks.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
} from '../keyserver-conn/call-single-keyserver-endpoint.js'; } from '../keyserver-conn/call-single-keyserver-endpoint.js';
Show All 12 Lines
} from '../shared/crypto-utils.js'; } from '../shared/crypto-utils.js';
import { fetchLatestDeviceList } from '../shared/device-list-utils.js'; import { fetchLatestDeviceList } from '../shared/device-list-utils.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import threadWatcher from '../shared/thread-watcher.js'; import threadWatcher from '../shared/thread-watcher.js';
import { import {
permissionsAndAuthRelatedRequestTimeout, permissionsAndAuthRelatedRequestTimeout,
callIdentityServiceTimeout, callIdentityServiceTimeout,
} from '../shared/timeouts.js'; } from '../shared/timeouts.js';
import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js'; import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
import type { import type {
LegacyLogInInfo, LegacyLogInInfo,
LegacyLogInResult, LegacyLogInResult,
LegacyRegisterResult, LegacyRegisterResult,
LegacyRegisterInfo, LegacyRegisterInfo,
UpdateUserSettingsRequest, UpdateUserSettingsRequest,
PolicyAcknowledgmentRequest, PolicyAcknowledgmentRequest,
ClaimUsernameRequest, ClaimUsernameRequest,
Show All 26 Lines
} from '../types/search-types.js'; } from '../types/search-types.js';
import type { PreRequestUserState } from '../types/session-types.js'; import type { PreRequestUserState } from '../types/session-types.js';
import type { import type {
SubscriptionUpdateRequest, SubscriptionUpdateRequest,
SubscriptionUpdateResult, SubscriptionUpdateResult,
} from '../types/subscription-types.js'; } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { RawThreadInfos } from '../types/thread-types.js';
import { import {
peerToPeerMessageTypes,
type EncryptedMessage,
} from '../types/tunnelbroker/peer-to-peer-message-types.js';
import {
userActionsP2PMessageTypes, userActionsP2PMessageTypes,
type PrimaryDeviceLogoutP2PMessage, type PrimaryDeviceLogoutP2PMessage,
type SecondaryDeviceLogoutP2PMessage, type SecondaryDeviceLogoutP2PMessage,
} from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js'; } from '../types/tunnelbroker/user-actions-peer-to-peer-message-types.js';
import type { import type {
CurrentUserInfo, CurrentUserInfo,
UserInfo, UserInfo,
PasswordUpdate, PasswordUpdate,
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
}); });
function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> { function usePrimaryDeviceLogOut(): () => Promise<LogOutResult> {
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { sendMessageToDevice } = useTunnelbroker();
const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates(); const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
const foreignPeerDevices = useSelector(getForeignPeerDevices); const foreignPeerDevices = useSelector(getForeignPeerDevices);
const logOut = useLogOut(primaryDeviceLogOutOptions); const logOut = useLogOut(primaryDeviceLogOutOptions);
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID: thisDeviceID } = authMetadata; const { userID, deviceID: thisDeviceID } = authMetadata;
if (!thisDeviceID || !userID) { if (!thisDeviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
const { const {
devices: [primaryDeviceID, ...secondaryDevices], devices: [primaryDeviceID, ...secondaryDevices],
} = await fetchLatestDeviceList(identityClient, userID); } = await fetchLatestDeviceList(identityClient, userID);
if (thisDeviceID !== primaryDeviceID) { if (thisDeviceID !== primaryDeviceID) {
throw new Error('Used primary device logout on a non-primary device'); throw new Error('Used primary device logout on a non-primary device');
} }
// create and send Olm Tunnelbroker messages to secondaryDevices
const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount();
const messageContents: PrimaryDeviceLogoutP2PMessage = { const messageContents: PrimaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_PRIMARY_DEVICE,
}; };
for (const deviceID of secondaryDevices) { const recipients = secondaryDevices.map(deviceID => ({ userID, deviceID }));
try { await broadcastEphemeralMessage(
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents),
deviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, deviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
deviceID, recipients,
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID: thisDeviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn(
`Error sending primary device logout message to device ${deviceID}:`,
err,
);
}
}
}
// - logOut() performs device list update by calling Identity RPC // - logOut() performs device list update by calling Identity RPC
// - broadcastDeviceListUpdates asks peers to download it from identity // - broadcastDeviceListUpdates asks peers to download it from identity
// so we need to call them in this order to make sure peers have latest // so we need to call them in this order to make sure peers have latest
// device list. // device list.
// We're relying on Tunnelbroker session stil existing after calling logout // We're relying on Tunnelbroker session stil existing after calling logout
// and auth metadata not yet cleared at this point. // and auth metadata not yet cleared at this point.
const logOutResult = await logOut(); const logOutResult = await logOut();
await broadcastDeviceListUpdates(foreignPeerDevices); await broadcastDeviceListUpdates(foreignPeerDevices);
return logOutResult; return logOutResult;
}, [ }, [
createOlmSessionsWithPeer,
broadcastDeviceListUpdates, broadcastDeviceListUpdates,
broadcastEphemeralMessage,
foreignPeerDevices, foreignPeerDevices,
identityContext, identityContext,
logOut, logOut,
sendMessageToDevice,
]); ]);
} }
const secondaryDeviceLogOutOptions = Object.freeze({ const secondaryDeviceLogOutOptions = Object.freeze({
logOutType: 'secondary_device', logOutType: 'secondary_device',
}); });
function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> { function useSecondaryDeviceLogOut(): () => Promise<LogOutResult> {
const { sendMessageToDevice } = useTunnelbroker();
const logOut = useLogOut(secondaryDeviceLogOutOptions); const logOut = useLogOut(secondaryDeviceLogOutOptions);
const identityContext = React.useContext(IdentityClientContext); const identityContext = React.useContext(IdentityClientContext);
if (!identityContext) { if (!identityContext) {
throw new Error('Identity service client is not initialized'); throw new Error('Identity service client is not initialized');
} }
const { createOlmSessionsWithPeer } = usePeerOlmSessionsCreatorContext(); const { broadcastEphemeralMessage } = usePeerToPeerCommunication();
return React.useCallback(async () => { return React.useCallback(async () => {
const { identityClient, getAuthMetadata } = identityContext; const { identityClient, getAuthMetadata } = identityContext;
const authMetadata = await getAuthMetadata(); const authMetadata = await getAuthMetadata();
const { userID, deviceID } = authMetadata; const { userID, deviceID } = authMetadata;
if (!deviceID || !userID) { if (!deviceID || !userID) {
throw new Error('No auth metadata'); throw new Error('No auth metadata');
} }
// get current device list and primary device ID // get current device list and primary device ID
const { devices } = await fetchLatestDeviceList(identityClient, userID); const { devices } = await fetchLatestDeviceList(identityClient, userID);
const primaryDeviceID = devices[0]; const primaryDeviceID = devices[0];
if (deviceID === primaryDeviceID) { if (deviceID === primaryDeviceID) {
throw new Error('Used secondary device logout on primary device'); throw new Error('Used secondary device logout on primary device');
} }
// create and send Olm Tunnelbroker message to primary device // create and send Olm Tunnelbroker message to primary device
const { olmAPI } = getConfig(); const { olmAPI } = getConfig();
await olmAPI.initializeCryptoAccount(); await olmAPI.initializeCryptoAccount();
const messageContents: SecondaryDeviceLogoutP2PMessage = { const messageContents: SecondaryDeviceLogoutP2PMessage = {
type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE, type: userActionsP2PMessageTypes.LOG_OUT_SECONDARY_DEVICE,
}; };
try { const recipient = { userID, deviceID: primaryDeviceID };
const encryptedData = await olmAPI.encrypt( await broadcastEphemeralMessage(
JSON.stringify(messageContents),
primaryDeviceID,
);
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch {
try {
await createOlmSessionsWithPeer(userID, primaryDeviceID);
const encryptedData = await olmAPI.encrypt(
JSON.stringify(messageContents), JSON.stringify(messageContents),
primaryDeviceID, [recipient],
authMetadata,
); );
const encryptedMessage: EncryptedMessage = {
type: peerToPeerMessageTypes.ENCRYPTED_MESSAGE,
senderInfo: { deviceID, userID },
encryptedData,
};
await sendMessageToDevice({
deviceID: primaryDeviceID,
payload: JSON.stringify(encryptedMessage),
});
} catch (err) {
console.warn('Error sending secondary device logout message:', err);
}
}
// log out of identity service, keyserver and visually // log out of identity service, keyserver and visually
return logOut(); return logOut();
}, [createOlmSessionsWithPeer, identityContext, sendMessageToDevice, logOut]); }, [identityContext, broadcastEphemeralMessage, logOut]);
} }
const claimUsernameActionTypes = Object.freeze({ const claimUsernameActionTypes = Object.freeze({
started: 'CLAIM_USERNAME_STARTED', started: 'CLAIM_USERNAME_STARTED',
success: 'CLAIM_USERNAME_SUCCESS', success: 'CLAIM_USERNAME_SUCCESS',
failed: 'CLAIM_USERNAME_FAILED', failed: 'CLAIM_USERNAME_FAILED',
}); });
const claimUsername = const claimUsername =
▲ Show 20 Lines • Show All 1,028 Lines • Show Last 20 Lines