Paths

Table of Contentst

-
services/identity/src/
-
identity/
-
src/
1/2
database.rs

[identity] Add devices to the new list after login and register
ClosedPublic
Actions

Authored by bartek on Dec 7 2023, 12:38 AM.

Details

Reviewers

varun
michal

Commits

rCOMMb87de1144e69: [identity] Add devices to the new list after login and register

Summary

Updated LoginUser and RegisterUser DDB calls to double-write new device info to both "legacy" and new device list.

Depends on D10220

Test Plan

Used keyserver to first register, then login (after restart). Used awslocal dynamodb scan to inspect both tables - both were updated successfully.

Diff Detail

Repository

rCOMM Comm

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

bartek created this revision.Dec 7 2023, 12:38 AM

bartek held this revision as a draft.

Herald added subscribers: tomek, ashoat. · View Herald TranscriptDec 7 2023, 12:38 AM

I know the code is nearly duplicated: both password- and wallet- functions are nearly identical.
This is going to be refactored anyway when fully migrated to the new device list.
Now this is the least intrusive way to plug the new device list into existing codebase without introducing too much mess.

Harbormaster completed remote builds in B24849: Diff 34371.Dec 7 2023, 2:02 AM

bartek added a child revision: D10246: [identity] Add function to delete all user devices data.Dec 8 2023, 4:40 AM

varun accepted this revision.Dec 8 2023, 12:22 PM

This revision is now accepted and ready to land.Dec 8 2023, 12:22 PM

Rebase

Harbormaster completed remote builds in B24968: Diff 34506.Dec 12 2023, 1:12 AM

bartek removed a child revision: D10246: [identity] Add function to delete all user devices data.Jan 5 2024, 12:54 AM

bartek edited parent revisions, added: D10301: [identity] Add GetDeviceListForUser RPC; removed: D10220: [identity] Add function to add new device to the list.

bartek added a child revision: D10303: [identity] Augment get_keys_for_user to use devices table.

bartek edited child revisions, added: D10302: [identity] Make set_prekey() update devices table too; removed: D10303: [identity] Augment get_keys_for_user to use devices table.

Closed by commit rCOMMb87de1144e69: [identity] Add devices to the new list after login and register (authored by bartek). · Explain WhyJan 15 2024, 6:53 AM

This revision was automatically updated to reflect the committed changes.

bartek added a commit: rCOMMb87de1144e69: [identity] Add devices to the new list after login and register.

Revision Contents
Changeset List

Path

Size

services/

identity/

src/

database.rs

73 lines

Diff 34506

View Options

services/identity/src/database.rs

	// @flow			// @flow

	import invariant from 'invariant';			import invariant from 'invariant';
	import * as React from 'react';			import * as React from 'react';

	import { logOutActionTypes, useLogOut } from '../actions/user-actions.js';			import {
				keyserverAuthActionTypes,
				logOutActionTypes,
				useKeyserverAuth,
				useLogOut,
				} from '../actions/user-actions.js';
				import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
				import { filterThreadIDsInFilterList } from '../reducers/calendar-filters-reducer.js';
	import {			import {
	connectionSelector,			connectionSelector,
	cookieSelector,			cookieSelector,
				deviceTokenSelector,
	} from '../selectors/keyserver-selectors.js';			} from '../selectors/keyserver-selectors.js';
	import { IdentityClientContext } from '../shared/identity-client-context.js';			import { IdentityClientContext } from '../shared/identity-client-context.js';
	import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';			import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
	import type { BaseSocketProps } from '../socket/socket.react.js';			import type { BaseSocketProps } from '../socket/socket.react.js';
				import { logInActionSources } from '../types/account-types.js';
	import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';			import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
	import { useSelector } from '../utils/redux-utils.js';			import { useSelector } from '../utils/redux-utils.js';
	import { usingCommServicesAccessToken } from '../utils/services-utils.js';			import { usingCommServicesAccessToken } from '../utils/services-utils.js';
	import { ashoatKeyserverID } from '../utils/validation-utils.js';			import { ashoatKeyserverID } from '../utils/validation-utils.js';

	type Props = {			type Props = {
	...BaseSocketProps,			...BaseSocketProps,
	+keyserverID: string,			+keyserverID: string,
	+socketComponent: React.ComponentType<BaseSocketProps>,			+socketComponent: React.ComponentType<BaseSocketProps>,
	};			};
	function KeyserverConnectionHandler(props: Props) {			function KeyserverConnectionHandler(props: Props) {
	const { socketComponent: Socket, keyserverID, ...rest } = props;			const { socketComponent: Socket, keyserverID, ...rest } = props;

	const dispatchActionPromise = useDispatchActionPromise();			const dispatchActionPromise = useDispatchActionPromise();
	const callLogOut = useLogOut();			const callLogOut = useLogOut();
				const keyserverAuth = useKeyserverAuth();

	const hasConnectionIssue = useSelector(			const hasConnectionIssue = useSelector(
	state => !!connectionSelector(keyserverID)(state)?.connectionIssue,			state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
	);			);
	const cookie = useSelector(cookieSelector(keyserverID));			const cookie = useSelector(cookieSelector(keyserverID));

				const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID));
				// We have an assumption that we should be always connected to Ashoat's
				// keyserver. It is possible that a token which it has is correct, so we can
				// try to use it. In worst case it is invalid and our push-handler will try
				// to fix it.
				ashoatUnsubmitted Not Done Inline Actions This logic is a bit confusing. I guess the reason we decided to store a separate `deviceToken` per keyserver is because we want to know if we've shared our `deviceToken` to that keyserver yet, not because we expect to have a different `deviceToken` per keyserver. It would probably make more sense if we have a `deviceTokenHasBeenUploaded: boolean` in `KeyserverInfo`, and a `deviceToken` field at the top level of Redux. But we'll likely end up removing `deviceToken`s from keyservers soon anyways... ashoat: This logic is a bit confusing. I guess the reason we decided to store a separate `deviceToken`…
				tomekAuthorUnsubmitted Done Inline Actions It would probably make more sense if we have a deviceTokenHasBeenUploaded: boolean in KeyserverInfo, and a deviceToken field at the top level of Redux. But we'll likely end up removing deviceTokens from keyservers soon anyways... Agree. But moving the token to Tunnelbroker will simplify it even more. For now, I don't think it is worth fixing now. tomek: > It would probably make more sense if we have a deviceTokenHasBeenUploaded: boolean in…
				const ashoatKeyserverDeviceToken = useSelector(
				deviceTokenSelector(ashoatKeyserverID),
				);
				const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken;

				const navInfo = useSelector(state => state.navInfo);
				const calendarFilters = useSelector(state => state.calendarFilters);
				const calendarQuery = React.useMemo(() => {
				const filters = filterThreadIDsInFilterList(
				calendarFilters,
				(threadID: string) => extractKeyserverIDFromID(threadID) === keyserverID,
				);
				return {
				startDate: navInfo.startDate,
				endDate: navInfo.endDate,
				filters,
				};
				}, [calendarFilters, keyserverID, navInfo.endDate, navInfo.startDate]);

	React.useEffect(() => {			React.useEffect(() => {
	if (hasConnectionIssue) {			if (hasConnectionIssue) {
	void dispatchActionPromise(logOutActionTypes, callLogOut());			void dispatchActionPromise(logOutActionTypes, callLogOut());
	}			}
	}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);			}, [callLogOut, hasConnectionIssue, dispatchActionPromise]);

	const identityContext = React.useContext(IdentityClientContext);			const identityContext = React.useContext(IdentityClientContext);
	invariant(identityContext, 'Identity context should be set');			invariant(identityContext, 'Identity context should be set');
	const { identityClient } = identityContext;			const { identityClient, getAuthMetadata } = identityContext;

	const olmSessionCreator = React.useContext(OlmSessionCreatorContext);			const olmSessionCreator = React.useContext(OlmSessionCreatorContext);
	invariant(olmSessionCreator, 'Olm session creator should be set');			invariant(olmSessionCreator, 'Olm session creator should be set');

	React.useEffect(() => {			React.useEffect(() => {
	if (!usingCommServicesAccessToken) {			if (!usingCommServicesAccessToken) {
	return;			return;
	}			}

	void (async () => {			void (async () => {
	try {			try {
	const keyserverKeys =			const keyserverKeys =
	await identityClient.getKeyserverKeys(keyserverID);			await identityClient.getKeyserverKeys(keyserverID);

	// eslint-disable-next-line no-unused-vars
	const [notifsSession, contentSession] = await Promise.all([			const [notifsSession, contentSession] = await Promise.all([
	olmSessionCreator.notificationsSessionCreator(			olmSessionCreator.notificationsSessionCreator(
	cookie,			cookie,
	keyserverKeys.identityKeysBlob.notificationIdentityPublicKeys,			keyserverKeys.identityKeysBlob.notificationIdentityPublicKeys,
	keyserverKeys.notifInitializationInfo,			keyserverKeys.notifInitializationInfo,
	keyserverID,			keyserverID,
	),			),
	olmSessionCreator.contentSessionCreator(			olmSessionCreator.contentSessionCreator(
	keyserverKeys.identityKeysBlob.primaryIdentityPublicKeys,			keyserverKeys.identityKeysBlob.primaryIdentityPublicKeys,
	keyserverKeys.contentInitializationInfo,			keyserverKeys.contentInitializationInfo,
	),			),
	]);			]);

				const { userID, deviceID } = await getAuthMetadata();
				invariant(userID, 'userID should be set');
				invariant(deviceID, 'deviceID should be set');

				const deviceTokenUpdateInput = deviceToken
				? { [keyserverID]: { deviceToken } }
				: {};

				await dispatchActionPromise(
				keyserverAuthActionTypes,
				keyserverAuth({
				userID,
				deviceID,
				doNotRegister: false,
				calendarQuery,
				deviceTokenUpdateInput,
				logInActionSource: process.env.BROWSER
				? logInActionSources.keyserverAuthFromWeb
				: logInActionSources.keyserverAuthFromNative,
				keyserverData: {
				[keyserverID]: {
				initialContentEncryptedMessage: contentSession,
				initialNotificationsEncryptedMessage: notifsSession,
				},
				},
				}),
				);
	} catch (e) {			} catch (e) {
	console.log(			console.log(
	`Error getting keys for keyserver with id ${keyserverID}`,			`Error while authenticating to keyserver with id ${keyserverID}`,
	e,			e,
	);			);
	}			}
	})();			})();
	}, [keyserverID, identityClient, olmSessionCreator, cookie]);			}, [
				keyserverID,
				identityClient,
				olmSessionCreator,
				cookie,
				getAuthMetadata,
				dispatchActionPromise,
				keyserverAuth,
				deviceToken,
				calendarQuery,
				]);

	if (keyserverID !== ashoatKeyserverID) {			if (keyserverID !== ashoatKeyserverID) {
	return null;			return null;
	}			}
	return <Socket {...rest} />;			return <Socket {...rest} />;
	}			}

	const Handler: React.ComponentType<Props> = React.memo<Props>(			const Handler: React.ComponentType<Props> = React.memo<Props>(
	KeyserverConnectionHandler,			KeyserverConnectionHandler,
	);			);

	export default Handler;			export default Handler;

[identity] Add devices to the new list after login and registerClosedPublicActions