Page MenuHomePhabricator
Differential D11264

[lib] Extract invalidateKeyserverSession in useKeyserverRecoveryLogIn
ClosedPublic
Actions

Authored by ashoat on Mar 6 2024, 4:25 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Mar 18, 6:29 PM
Unknown Object (File)
Feb 28 2025, 8:23 PM
Unknown Object (File)
Feb 28 2025, 8:22 PM
Unknown Object (File)
Feb 3 2025, 3:05 PM
Unknown Object (File)
Feb 3 2025, 1:27 PM
Unknown Object (File)
Jan 30 2025, 1:56 PM
Unknown Object (File)
Jan 30 2025, 1:56 PM
Unknown Object (File)
Jan 24 2025, 7:08 PM
View All 63 Files
Subscribers
None

Details

Reviewers
inka
tomek
Commits
rCOMMa3aef35f71b5: [lib] Extract invalidateKeyserverSession in useKeyserverRecoveryLogIn
Summary

In the next diff, I'll add some code that will call logOut in this newly extracted callback. Instead of repeating it, I decided to extract it to a single place first.

Test Plan

This diff is a simple refactor. In addition to the following test plan I used for the next diff, I also made sure that Flow/ESLint were satisfied with the refactor.

  • I hacked legacy-recover-keyserver-session.js to use the wrong password so the session recovery would fail
  • I started the iOS simulator and logged in using a test user
  • I opened the Redux Dev Tools
  • I deleted the test user's cookie from the MariaDB database: DELETE FROM cookies WHERE user = 6390578 AND platform = 'ios'
  • I sent a message as the test user
  • I confirmed that session recovery was triggered in the Redux dev tools
  • I confirmed that after session recovery failed, the user was logged out in the UI
  • Via Redux dev tools, I confirmed that after session recovery failed, LOG_OUT_STARTED and LOG_OUT_SUCCESS were dispatched

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
lib/
keyserver-conn/
35 lines

Diff 37954

View Options

lib/keyserver-conn/recovery-utils.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import uuid from 'uuid'; import uuid from 'uuid';
import blobService from '../facts/blob-service.js'; import blobService from '../facts/blob-service.js';
import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js'; import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import { IdentityClientContext } from '../shared/identity-client-context.js';
import type { AuthMetadata } from '../shared/identity-client-context.js';
import type { UploadMultimediaResult, Dimensions } from '../types/media-types'; import type { UploadMultimediaResult, Dimensions } from '../types/media-types';
import { toBase64URL } from '../utils/base64.js'; import { toBase64URL } from '../utils/base64.js';
import { import {
blobServiceUploadHandler, blobServiceUploadHandler,
type BlobServiceUploadHandler, type BlobServiceUploadHandler,
} from '../utils/blob-service-upload.js'; } from '../utils/blob-service-upload.js';
import { makeBlobServiceEndpointURL } from '../utils/blob-service.js'; import { makeBlobServiceEndpointURL } from '../utils/blob-service.js';
import type { CallSingleKeyserverEndpoint } from '../utils/call-single-keyserver-endpoint.js'; import type { CallSingleKeyserverEndpoint } from '../utils/call-single-keyserver-endpoint.js';
import { getMessageForException } from '../utils/errors.js'; import { getMessageForException } from '../utils/errors.js';
import { useKeyserverCall } from '../utils/keyserver-call.js'; import { useKeyserverCall } from '../utils/keyserver-call.js';
import { handleHTTPResponseError } from '../utils/services-utils.js'; import {
handleHTTPResponseError,
createDefaultHTTPRequestHeaders,
} from '../utils/services-utils.js';
import { type UploadBlob } from '../utils/upload-blob.js'; import { type UploadBlob } from '../utils/upload-blob.js';
export type MultimediaUploadCallbacks = Partial<{ export type MultimediaUploadCallbacks = Partial<{
+onProgress: (percent: number) => void, +onProgress: (percent: number) => void,
+abortHandler: (abort: () => void) => void, +abortHandler: (abort: () => void) => void,
+uploadBlob: UploadBlob, +uploadBlob: UploadBlob,
+blobServiceUploadHandler: BlobServiceUploadHandler, +blobServiceUploadHandler: BlobServiceUploadHandler,
+timeout: ?number, +timeout: ?number,
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines
export type BlobServiceUploadAction = (input: { export type BlobServiceUploadAction = (input: {
+uploadInput: BlobServiceUploadInput, +uploadInput: BlobServiceUploadInput,
+keyserverOrThreadID: string, +keyserverOrThreadID: string,
+callbacks?: MultimediaUploadCallbacks, +callbacks?: MultimediaUploadCallbacks,
}) => Promise<BlobServiceUploadResult>; }) => Promise<BlobServiceUploadResult>;
const blobServiceUpload = const blobServiceUpload =
(callKeyserverEndpoint: CallKeyserverEndpoint): BlobServiceUploadAction => (
callKeyserverEndpoint: CallKeyserverEndpoint,
authMetadata: AuthMetadata,
): BlobServiceUploadAction =>
async input => { async input => {
const { uploadInput, callbacks, keyserverOrThreadID } = input; const { uploadInput, callbacks, keyserverOrThreadID } = input;
const { encryptionKey, loop, dimensions, thumbHash, blobInput } = const { encryptionKey, loop, dimensions, thumbHash, blobInput } =
uploadInput; uploadInput;
const blobHolder = uuid.v4(); const blobHolder = uuid.v4();
const blobHash = toBase64URL(uploadInput.blobHash); const blobHash = toBase64URL(uploadInput.blobHash);
const defaultHeaders = createDefaultHTTPRequestHeaders(authMetadata);
// 1. Assign new holder for blob with given blobHash // 1. Assign new holder for blob with given blobHash
let blobAlreadyExists: boolean; let blobAlreadyExists: boolean;
try { try {
const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER; const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
const assignHolderResponse = await fetch( const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(assignHolderEndpoint), makeBlobServiceEndpointURL(assignHolderEndpoint),
{ {
method: assignHolderEndpoint.method, method: assignHolderEndpoint.method,
body: JSON.stringify({ body: JSON.stringify({
holder: blobHolder, holder: blobHolder,
blob_hash: blobHash, blob_hash: blobHash,
}), }),
headers: { headers: {
...defaultHeaders,
'content-type': 'application/json', 'content-type': 'application/json',
}, },
}, },
); );
handleHTTPResponseError(assignHolderResponse); handleHTTPResponseError(assignHolderResponse);
const { data_exists: dataExistsResponse } = const { data_exists: dataExistsResponse } =
await assignHolderResponse.json(); await assignHolderResponse.json();
blobAlreadyExists = dataExistsResponse; blobAlreadyExists = dataExistsResponse;
Show All 15 Lines if (!blobAlreadyExists) {
try { try {
await blobServiceUploadCallback( await blobServiceUploadCallback(
makeBlobServiceEndpointURL(uploadEndpoint), makeBlobServiceEndpointURL(uploadEndpoint),
uploadEndpoint.method, uploadEndpoint.method,
{ {
blobHash, blobHash,
blobInput, blobInput,
}, },
authMetadata,
{ ...callbacks }, { ...callbacks },
); );
} catch (e) { } catch (e) {
throw new Error( throw new Error(
`Failed to upload blob: ${ `Failed to upload blob: ${
getMessageForException(e) ?? 'unknown error' getMessageForException(e) ?? 'unknown error'
}`, }`,
); );
Show All 28 Lines return {
mediaType: response.mediaType, mediaType: response.mediaType,
dimensions: response.dimensions, dimensions: response.dimensions,
loop: response.loop, loop: response.loop,
blobHolder, blobHolder,
}; };
}; };
function useBlobServiceUpload(): BlobServiceUploadAction { function useBlobServiceUpload(): BlobServiceUploadAction {
return useKeyserverCall(blobServiceUpload); const identityContext = React.useContext(IdentityClientContext);
invariant(identityContext, 'Identity context should be set');
const { getAuthMetadata } = identityContext;
const blobUploadAction = React.useCallback(
(
callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
): BlobServiceUploadAction =>
async input => {
const authMetadata = await getAuthMetadata();
const authenticatedUploadAction = blobServiceUpload(
callSingleKeyserverEndpoint,
authMetadata,
);
return authenticatedUploadAction(input);
},
[getAuthMetadata],
);
return useKeyserverCall(blobUploadAction);
} }
export { export {
uploadMultimedia, uploadMultimedia,
useBlobServiceUpload, useBlobServiceUpload,
updateMultimediaMessageMediaActionType, updateMultimediaMessageMediaActionType,
useDeleteUpload, useDeleteUpload,
}; };