Page MenuHomePhabricator
Differential D13442

[terraform] Bump staging Backup to 0.4.3
ClosedPublic
Actions

Authored by bartek on Sep 23 2024, 10:42 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 1, 7:31 AM
Unknown Object (File)
Sun, Mar 16, 12:54 AM
Unknown Object (File)
Feb 21 2025, 5:49 AM
Unknown Object (File)
Feb 18 2025, 12:33 AM
Unknown Object (File)
Jan 27 2025, 7:17 AM
Unknown Object (File)
Jan 27 2025, 7:17 AM
Unknown Object (File)
Jan 27 2025, 7:17 AM
Unknown Object (File)
Jan 27 2025, 7:17 AM
View All 55 Files
Subscribers
tomek

Details

Reviewers
varun
will
kamil
ashoat
Commits
rCOMM381e03574ac1: [terraform] Bump staging Backup to 0.4.3
Summary

ENG-9295

Test Plan

terraform plan

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
services/
terraform/
remote/
2 lines

Diff 44477

View Options

services/terraform/remote/service_backup.tf

// @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,
}; };