[identity] remove duplicate debug log for HTTP requests
ClosedPublic
Actions

Authored by will on Apr 30 2024, 1:21 PM.

Details

Reviewers

varun
bartek

Commits

rCOMM3e1a4ed50f83: [identity] remove duplicate debug log for HTTP requests

Summary

Missed on original implementation. We have two identical debug logs for incoming HTTP requests

Test Plan

cargo check

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

will created this revision.Apr 30 2024, 1:21 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptApr 30 2024, 1:21 PM

Harbormaster completed remote builds in B28613: Diff 39717.Apr 30 2024, 1:39 PM

will requested review of this revision.Apr 30 2024, 1:39 PM

varun accepted this revision.Apr 30 2024, 1:41 PM

varun added inline comments.

services/identity/src/websockets/mod.rs
80 ↗	(On Diff #39717)	don't we want to log this before we potentially return in the above if statement?

This revision is now accepted and ready to land.Apr 30 2024, 1:41 PM

will added inline comments.May 1 2024, 8:47 AM

services/identity/src/websockets/mod.rs
80 ↗	(On Diff #39717)	Fair point. I'll move the below debug log and land

review feedback

Harbormaster completed remote builds in B28614: Diff 39718.May 1 2024, 9:08 AM

Closed by commit rCOMM3e1a4ed50f83: [identity] remove duplicate debug log for HTTP requests (authored by will). · Explain WhyMay 1 2024, 9:12 AM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM3e1a4ed50f83: [identity] remove duplicate debug log for HTTP requests.

Revision Contents
Changeset List

Path

Size

services/

identity/

src/

websockets/

mod.rs

9 lines

Diff 39720

View Options

services/identity/src/websockets/mod.rs

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

[identity] remove duplicate debug log for HTTP requestsClosedPublicActions