Paths

Table of Contentst

-
native/account/
-
account/
-
restore-password-account-screen.react.js
-
restore-prompt-screen.react.js

[native] Fall back to v1 login when the user doesn't have a backup
ClosedPublic
Actions

Authored by tomek on Dec 20 2024, 9:04 AM.

Details

Reviewers

kamil
bartek

Commits

rCOMM5b761cf201c9: [native] Fall back to v1 login when the user doesn't have a backup

Summary

Check if the user has a backup. When they don't have it, use the v1 login flow.

https://linear.app/comm/issue/ENG-9620/client-restore-flow-fall-back-to-v1-when-missing-backup

Depends on D14165

Test Plan

Because pf https://linear.app/comm/issue/ENG-10039/allow-checking-if-a-user-has-a-backup I had to hack it a bit: instead of calling retrieveLatestBackupInfo I hardcoded its return value to null. Then for both password and SIWE user verified that it is possible to log in.

Diff Detail

Repository

rCOMM Comm

Branch

restore4

Lint

No Lint Coverage

Unit

No Test Coverage

Event Timeline

tomek created this revision.Dec 20 2024, 9:04 AM

Herald added a subscriber: ashoat. · View Herald TranscriptDec 20 2024, 9:04 AM

Harbormaster completed remote builds in B33190: Diff 46594.Dec 20 2024, 9:22 AM

tomek requested review of this revision.Dec 20 2024, 9:22 AM

ashoat added inline comments.Dec 25 2024, 8:46 AM

native/account/restore-password-account-screen.react.js
52	At some point we'll probably want to rename `usePasswordLogIn` (and associated hooks) to reflect that they are v1 / legacy

tomek added a child revision: D14182: [native] Update device list as a part of the restoration.Jan 7 2025, 1:21 AM

kamil accepted this revision.Jan 7 2025, 6:49 AM

kamil added 1 blocking reviewer(s): bartek.

kamil added inline comments.

native/account/restore-prompt-screen.react.js
57	After skipping the regeneration of the social proof duringthe restore is done, this will have to change but for now looks good

Because pf https://linear.app/comm/issue/ENG-10039/allow-checking-if-a-user-has-a-backup I had to hack it a bit: instead of calling retrieveLatestBackupInfo I hardcoded its return value to null. Then for both password and SIWE user verified that it is possible to log in.

I'm going to put up a diff which makes it behave as described in my inline comment

native/account/restore-password-account-screen.react.js
62–70	Assuming `retrieveLatestBackupInfo` returns `null` only if user exists, but doesn't have backup, this code is okay. If user with given username cannot be found by Backup Service, it should throw `user_not_found` which is caught below

This revision is now accepted and ready to land.Jan 7 2025, 7:20 AM

tomek added inline comments.Jan 8 2025, 9:21 AM

native/account/restore-password-account-screen.react.js
52	Created https://linear.app/comm/issue/ENG-10074/rename-legacy-v1-functions-and-utils to track.

Closed by commit rCOMM5b761cf201c9: [native] Fall back to v1 login when the user doesn't have a backup (authored by tomek). · Explain WhyJan 8 2025, 9:30 AM

This revision was automatically updated to reflect the committed changes.

tomek added a commit: rCOMM5b761cf201c9: [native] Fall back to v1 login when the user doesn't have a backup.

Revision Contents
Changeset List

Path

Size

native/

account/

restore-password-account-screen.react.js

85 lines

restore-prompt-screen.react.js

43 lines

Diff 46594

View Options

native/account/restore-password-account-screen.react.js

// @flow		// @flow

import * as FileSystem from 'expo-file-system';		import * as FileSystem from 'expo-file-system';
import invariant from 'invariant';		import invariant from 'invariant';
import * as React from 'react';		import * as React from 'react';
import { Platform } from 'react-native';		import { Platform } from 'react-native';
import { useDispatch } from 'react-redux';		import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect';		import { createSelector } from 'reselect';
import * as uuid from 'uuid';

import {		import {
createLocalMessageActionType,		createLocalMessageActionType,
sendMultimediaMessageActionTypes,		sendMultimediaMessageActionTypes,
sendMultimediaMessage,		sendMultimediaMessage,
sendTextMessageActionTypes,		sendTextMessageActionTypes,
sendTextMessage,		sendTextMessage,
} from 'lib/actions/message-actions.js';		} from 'lib/actions/message-actions.js';
import { queueReportsActionType } from 'lib/actions/report-actions.js';		import { queueReportsActionType } from 'lib/actions/report-actions.js';
import { newThread } from 'lib/actions/thread-actions.js';		import { newThread } from 'lib/actions/thread-actions.js';
import {		import {
uploadMultimedia,		uploadMultimedia,
uploadMediaMetadata,		uploadMediaMetadata,
updateMultimediaMessageMediaActionType,		updateMultimediaMessageMediaActionType,
		blobServiceUpload,
type MultimediaUploadCallbacks,		type MultimediaUploadCallbacks,
type MultimediaUploadExtras,		type MultimediaUploadExtras,
		type BlobServiceUploadAction,
} from 'lib/actions/upload-actions.js';		} from 'lib/actions/upload-actions.js';
import blobService from 'lib/facts/blob-service.js';
import commStaffCommunity from 'lib/facts/comm-staff-community.js';		import commStaffCommunity from 'lib/facts/comm-staff-community.js';
import { pathFromURI, replaceExtension } from 'lib/media/file-utils.js';		import { pathFromURI, replaceExtension } from 'lib/media/file-utils.js';
import {		import {
isLocalUploadID,		isLocalUploadID,
getNextLocalUploadID,		getNextLocalUploadID,
} from 'lib/media/media-utils.js';		} from 'lib/media/media-utils.js';
import { videoDurationLimit } from 'lib/media/video-utils.js';		import { videoDurationLimit } from 'lib/media/video-utils.js';
import {		import {
Show All 10 Lines	import {
createRealThreadFromPendingThread,		createRealThreadFromPendingThread,
threadIsPending,		threadIsPending,
threadIsPendingSidebar,		threadIsPendingSidebar,
patchThreadInfoToIncludeMentionedMembersOfParent,		patchThreadInfoToIncludeMentionedMembersOfParent,
threadInfoInsideCommunity,		threadInfoInsideCommunity,
} from 'lib/shared/thread-utils.js';		} from 'lib/shared/thread-utils.js';
import type { CalendarQuery } from 'lib/types/entry-types.js';		import type { CalendarQuery } from 'lib/types/entry-types.js';
import type {		import type {
Dimensions,
UploadMultimediaResult,		UploadMultimediaResult,
Media,		Media,
NativeMediaSelection,		NativeMediaSelection,
MediaMissionResult,		MediaMissionResult,
MediaMission,		MediaMission,
UploadMediaMetadataRequest,		UploadMediaMetadataRequest,
} from 'lib/types/media-types.js';		} from 'lib/types/media-types.js';
import { messageTypes } from 'lib/types/message-types-enum.js';		import { messageTypes } from 'lib/types/message-types-enum.js';
Show All 21 Lines	import {
type NewThreadResult,		type NewThreadResult,
type ThreadInfo,		type ThreadInfo,
} from 'lib/types/thread-types.js';		} from 'lib/types/thread-types.js';
import {		import {
type DispatchActionPromise,		type DispatchActionPromise,
useServerCall,		useServerCall,
useDispatchActionPromise,		useDispatchActionPromise,
} from 'lib/utils/action-utils.js';		} from 'lib/utils/action-utils.js';
import { toBase64URL } from 'lib/utils/base64.js';
import { makeBlobServiceEndpointURL } from 'lib/utils/blob-service.js';
import type {		import type {
CallServerEndpointOptions,		CallServerEndpointOptions,
CallServerEndpointResponse,		CallServerEndpointResponse,
} from 'lib/utils/call-server-endpoint.js';		} from 'lib/utils/call-server-endpoint.js';
import { getConfig } from 'lib/utils/config.js';		import { getConfig } from 'lib/utils/config.js';
import { getMessageForException, cloneError } from 'lib/utils/errors.js';		import { getMessageForException, cloneError } from 'lib/utils/errors.js';
import { values } from 'lib/utils/objects.js';		import { values } from 'lib/utils/objects.js';
import {		import {
generateReportID,		generateReportID,
useIsReportEnabled,		useIsReportEnabled,
} from 'lib/utils/report-utils.js';		} from 'lib/utils/report-utils.js';
import { handleHTTPResponseError } from 'lib/utils/services-utils.js';

import {		import {
type EditInputBarMessageParameters,		type EditInputBarMessageParameters,
InputStateContext,		InputStateContext,
type PendingMultimediaUploads,		type PendingMultimediaUploads,
type MultimediaProcessingStep,		type MultimediaProcessingStep,
} from './input-state.js';		} from './input-state.js';
import { encryptMedia } from '../media/encryption-utils.js';		import { encryptMedia } from '../media/encryption-utils.js';
import { disposeTempFile } from '../media/file-utils.js';		import { disposeTempFile } from '../media/file-utils.js';
import { processMedia } from '../media/media-utils.js';		import { processMedia } from '../media/media-utils.js';
import { displayActionResultModal } from '../navigation/action-result-modal.js';		import { displayActionResultModal } from '../navigation/action-result-modal.js';
import { useCalendarQuery } from '../navigation/nav-selectors.js';		import { useCalendarQuery } from '../navigation/nav-selectors.js';
import { useSelector } from '../redux/redux-utils.js';		import { useSelector } from '../redux/redux-utils.js';
		import blobServiceUploadHandler from '../utils/blob-service-upload.js';
import { useStaffCanSee } from '../utils/staff-utils.js';		import { useStaffCanSee } from '../utils/staff-utils.js';

type MediaIDs =		type MediaIDs =
\| { +type: 'photo', +localMediaID: string }		\| { +type: 'photo', +localMediaID: string }
\| { +type: 'video', +localMediaID: string, +localThumbnailID: string };		\| { +type: 'video', +localMediaID: string, +localThumbnailID: string };
type UploadFileInput = {		type UploadFileInput = {
+selection: NativeMediaSelection,		+selection: NativeMediaSelection,
+ids: MediaIDs,		+ids: MediaIDs,
Show All 18 Lines	type Props = {
+uploadMultimedia: (		+uploadMultimedia: (
multimedia: Object,		multimedia: Object,
extras: MultimediaUploadExtras,		extras: MultimediaUploadExtras,
callbacks: MultimediaUploadCallbacks,		callbacks: MultimediaUploadCallbacks,
) => Promise<UploadMultimediaResult>,		) => Promise<UploadMultimediaResult>,
+uploadMediaMetadata: (		+uploadMediaMetadata: (
input: UploadMediaMetadataRequest,		input: UploadMediaMetadataRequest,
) => Promise<UploadMultimediaResult>,		) => Promise<UploadMultimediaResult>,
		+blobServiceUpload: BlobServiceUploadAction,
+sendMultimediaMessage: (		+sendMultimediaMessage: (
threadID: string,		threadID: string,
localID: string,		localID: string,
mediaMessageContents: $ReadOnlyArray<MediaMessageServerDBContent>,		mediaMessageContents: $ReadOnlyArray<MediaMessageServerDBContent>,
sidebarCreation?: boolean,		sidebarCreation?: boolean,
) => Promise<SendMessageResult>,		) => Promise<SendMessageResult>,
+sendTextMessage: (		+sendTextMessage: (
threadID: string,		threadID: string,
▲ Show 20 Lines • Show All 669 Lines • ▼ Show 20 Lines	): Promise<?string> {
try {		try {
const uploadPromises = [];		const uploadPromises = [];
if (		if (
this.useBlobServiceUploads &&		this.useBlobServiceUploads &&
(processedMedia.mediaType === 'encrypted_photo' \|\|		(processedMedia.mediaType === 'encrypted_photo' \|\|
processedMedia.mediaType === 'encrypted_video')		processedMedia.mediaType === 'encrypted_video')
) {		) {
uploadPromises.push(		uploadPromises.push(
this.blobServiceUpload(		this.props.blobServiceUpload({
{		input: {
		blobInput: {
		type: 'uri',
uri: uploadURI,		uri: uploadURI,
filename: filename,		filename: filename,
mimeType: mime,		mimeType: mime,
		},
blobHash: processedMedia.blobHash,		blobHash: processedMedia.blobHash,
encryptionKey: processedMedia.encryptionKey,		encryptionKey: processedMedia.encryptionKey,
dimensions: processedMedia.dimensions,		dimensions: processedMedia.dimensions,
thumbHash:		thumbHash:
processedMedia.mediaType === 'encrypted_photo'		processedMedia.mediaType === 'encrypted_photo'
? processedMedia.thumbHash		? processedMedia.thumbHash
: null,		: null,
},		},
{		callbacks: {
		blobServiceUploadHandler,
onProgress: (percent: number) => {		onProgress: (percent: number) => {
this.setProgress(		this.setProgress(
localMessageID,		localMessageID,
localMediaID,		localMediaID,
'uploading',		'uploading',
percent,		percent,
);		);
},		},
},		},
),		}),
);		);

if (processedMedia.mediaType === 'encrypted_video') {		if (processedMedia.mediaType === 'encrypted_video') {
uploadPromises.push(		uploadPromises.push(
this.blobServiceUpload({		this.props.blobServiceUpload({
		input: {
		blobInput: {
		type: 'uri',
uri: processedMedia.uploadThumbnailURI,		uri: processedMedia.uploadThumbnailURI,
filename: replaceExtension(`thumb${filename}`, 'jpg'),		filename: replaceExtension(`thumb${filename}`, 'jpg'),
mimeType: 'image/jpeg',		mimeType: 'image/jpeg',
		},
blobHash: processedMedia.thumbnailBlobHash,		blobHash: processedMedia.thumbnailBlobHash,
encryptionKey: processedMedia.thumbnailEncryptionKey,		encryptionKey: processedMedia.thumbnailEncryptionKey,
loop: false,		loop: false,
dimensions: processedMedia.dimensions,		dimensions: processedMedia.dimensions,
thumbHash: processedMedia.thumbHash,		thumbHash: processedMedia.thumbHash,
		},
		callbacks: {
		blobServiceUploadHandler,
		},
}),		}),
);		);
}		}
[uploadResult, uploadThumbnailResult] = await Promise.all(		[uploadResult, uploadThumbnailResult] = await Promise.all(
uploadPromises,		uploadPromises,
);		);
} else {		} else {
uploadPromises.push(		uploadPromises.push(
▲ Show 20 Lines • Show All 265 Lines • ▼ Show 20 Lines	this.setState(prevState => {
pendingUploads: {		pendingUploads: {
...prevState.pendingUploads,		...prevState.pendingUploads,
[localMessageID]: newPendingUploads,		[localMessageID]: newPendingUploads,
},		},
};		};
});		});
}		}

async blobServiceUpload(
input: {
+uri: string,
+filename: string,
+mimeType: string,
+blobHash: string,
+encryptionKey: string,
+dimensions: Dimensions,
+loop?: boolean,
+thumbHash: ?string,
},
options?: ?CallServerEndpointOptions,
): Promise<void> {
const newHolder = uuid.v4();
const blobHash = toBase64URL(input.blobHash);

// 1. Assign new holder for blob with given blobHash
let blobAlreadyExists: boolean;
try {
const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(assignHolderEndpoint),
{
method: assignHolderEndpoint.method,
body: JSON.stringify({
holder: newHolder,
blob_hash: blobHash,
}),
headers: {
'content-type': 'application/json',
},
},
);

handleHTTPResponseError(assignHolderResponse);
const { data_exists: dataExistsResponse } =
await assignHolderResponse.json();
blobAlreadyExists = dataExistsResponse;
} catch (e) {
throw new Error(
`Failed to assign holder: ${
getMessageForException(e) ?? 'unknown error'
}`,
);
}

// 2. Upload blob contents if blob doesn't exist
if (!blobAlreadyExists) {
let path = input.uri;
if (Platform.OS === 'android') {
const resolvedPath = pathFromURI(input.uri);
if (resolvedPath) {
path = resolvedPath;
}
}
const uploadEndpoint = blobService.httpEndpoints.UPLOAD_BLOB;
const { method } = uploadEndpoint;
const uploadTask = FileSystem.createUploadTask(
makeBlobServiceEndpointURL(uploadEndpoint),
path,
{
uploadType: FileSystem.FileSystemUploadType.MULTIPART,
fieldName: 'blob_data',
httpMethod: method,
parameters: { blob_hash: blobHash },
},
uploadProgress => {
if (options && options.onProgress) {
const { totalByteSent, totalBytesExpectedToSend } = uploadProgress;
options.onProgress(totalByteSent / totalBytesExpectedToSend);
}
},
);
if (options && options.abortHandler) {
options.abortHandler(() => uploadTask.cancelAsync());
}
try {
await uploadTask.uploadAsync();
} catch (e) {
throw new Error(
`Failed to upload blob: ${
getMessageForException(e) ?? 'unknown error'
}`,
);
}
}

// 3. Send upload metadata to the keyserver, return response
const { filename, mimeType, loop, dimensions, encryptionKey, thumbHash } =
input;
return await this.props.uploadMediaMetadata({
...dimensions,
filename,
mimeType,
blobHolder: newHolder,
blobHash,
encryptionKey,
loop: loop ?? false,
...(thumbHash ? { thumbHash } : null),
});
}

uploadBlob = async (		uploadBlob = async (
url: string,		url: string,
cookie: ?string,		cookie: ?string,
sessionID: ?string,		sessionID: ?string,
input: { [key: string]: mixed },		input: { [key: string]: mixed },
options?: ?CallServerEndpointOptions,		options?: ?CallServerEndpointOptions,
): Promise<CallServerEndpointResponse> => {		): Promise<CallServerEndpointResponse> => {
invariant(		invariant(
▲ Show 20 Lines • Show All 522 Lines • ▼ Show 20 Lines	const ongoingMessageCreation = useSelector(
mediaCreationLoadingStatusSelector(state),		mediaCreationLoadingStatusSelector(state),
textCreationLoadingStatusSelector(state),		textCreationLoadingStatusSelector(state),
) === 'loading',		) === 'loading',
);		);
const hasWiFi = useSelector(state => state.connectivity.hasWiFi);		const hasWiFi = useSelector(state => state.connectivity.hasWiFi);
const calendarQuery = useCalendarQuery();		const calendarQuery = useCalendarQuery();
const callUploadMultimedia = useServerCall(uploadMultimedia);		const callUploadMultimedia = useServerCall(uploadMultimedia);
const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);		const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);
		const callBlobServiceUpload = useServerCall(blobServiceUpload);
const callSendMultimediaMessage = useServerCall(sendMultimediaMessage);		const callSendMultimediaMessage = useServerCall(sendMultimediaMessage);
const callSendTextMessage = useServerCall(sendTextMessage);		const callSendTextMessage = useServerCall(sendTextMessage);
const callNewThread = useServerCall(newThread);		const callNewThread = useServerCall(newThread);
const dispatchActionPromise = useDispatchActionPromise();		const dispatchActionPromise = useDispatchActionPromise();
const dispatch = useDispatch();		const dispatch = useDispatch();
const mediaReportsEnabled = useIsReportEnabled('mediaReports');		const mediaReportsEnabled = useIsReportEnabled('mediaReports');
const staffCanSee = useStaffCanSee();		const staffCanSee = useStaffCanSee();
const textMessageCreationSideEffectsFunc =		const textMessageCreationSideEffectsFunc =
useMessageCreationSideEffectsFunc(messageTypes.TEXT);		useMessageCreationSideEffectsFunc(messageTypes.TEXT);

return (		return (
<InputStateContainer		<InputStateContainer
{...props}		{...props}
uploadMediaMetadata={callUploadMediaMetadata}		uploadMediaMetadata={callUploadMediaMetadata}
viewerID={viewerID}		viewerID={viewerID}
nextLocalID={nextLocalID}		nextLocalID={nextLocalID}
messageStoreMessages={messageStoreMessages}		messageStoreMessages={messageStoreMessages}
ongoingMessageCreation={ongoingMessageCreation}		ongoingMessageCreation={ongoingMessageCreation}
hasWiFi={hasWiFi}		hasWiFi={hasWiFi}
mediaReportsEnabled={mediaReportsEnabled}		mediaReportsEnabled={mediaReportsEnabled}
calendarQuery={calendarQuery}		calendarQuery={calendarQuery}
uploadMultimedia={callUploadMultimedia}		uploadMultimedia={callUploadMultimedia}
		blobServiceUpload={callBlobServiceUpload}
sendMultimediaMessage={callSendMultimediaMessage}		sendMultimediaMessage={callSendMultimediaMessage}
sendTextMessage={callSendTextMessage}		sendTextMessage={callSendTextMessage}
newThread={callNewThread}		newThread={callNewThread}
dispatchActionPromise={dispatchActionPromise}		dispatchActionPromise={dispatchActionPromise}
dispatch={dispatch}		dispatch={dispatch}
staffCanSee={staffCanSee}		staffCanSee={staffCanSee}
textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}		textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
/>		/>
);		);
});		});

export default ConnectedInputStateContainer;		export default ConnectedInputStateContainer;