[keyserver] Change blob upload functions to return more usable results
ClosedPublic
Actions

Authored by tomek on Dec 1 2023, 3:59 AM.

Details

Reviewers

michal
bartek
marcin
rohan

Commits

rCOMM48441ea35eca: [keyserver] Change blob upload functions to return more usable results

Summary

We would like to be able to differentiate between hash in use and a plain failure and to achieve that we need a different API

Depends on D10099

Test Plan

Run a script and check if both SUCCESS and HASH_IN_USE results are returned

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

tomek created this revision.Dec 1 2023, 3:59 AM

Herald added a subscriber: ashoat. · View Herald TranscriptDec 1 2023, 3:59 AM

tomek added a reviewer: marcin.Dec 1 2023, 3:59 AM

Harbormaster completed remote builds in B24683: Diff 34100.Dec 1 2023, 4:37 AM

tomek requested review of this revision.Dec 1 2023, 4:37 AM

tomek added a child revision: D10134: [keyserver] Create a blob while adding / editing an invite link.Dec 1 2023, 6:55 AM

marcin added inline comments.Dec 1 2023, 7:13 AM

keyserver/src/services/blob.js
36 ↗	(On Diff #34100)	I don't think we should ignore `status` and `statusText` in case of failure since we loos some meaningful information on what actually failed and make debugging harder. Please update types so that we can return more details information if blob upload fails.

Adding @marcin as blocking to make sure his concern is somehow addressed

keyserver/src/services/blob.js
36 ↗	(On Diff #34100)	Soon we'll have to support another status code here (401/403, see ENG-4765) so @marcin's comment makes sense. I don't have a single idea what's the best way here, maybe this kind of union? Also this touches a broader area - ENG-3841 and related tasks, so not sure what is actionable now.

I think @marcin and/or @bartek have more context here than I do, so I'll leave the review to them for this diff

Request changes to add error information to objects returned from functions.

This revision now requires changes to proceed.Dec 14 2023, 7:16 AM

Include status and text in a result

Harbormaster completed remote builds in B26411: Diff 36521.Feb 1 2024, 6:57 AM

bartek accepted this revision.Feb 4 2024, 11:36 PM

marcin accepted this revision.Feb 5 2024, 2:06 AM

This revision is now accepted and ready to land.Feb 5 2024, 2:06 AM

Rebase

Harbormaster failed remote builds in B26651: Diff 36848!Feb 8 2024, 6:46 AM

Fix Flow

Harbormaster failed remote builds in B26687: Diff 36901!Feb 9 2024, 2:51 AM

Rebase

Harbormaster completed remote builds in B26820: Diff 37063.Feb 14 2024, 4:05 AM

Closed by commit rCOMM48441ea35eca: [keyserver] Change blob upload functions to return more usable results (authored by tomek). · Explain WhyFeb 14 2024, 7:58 AM

This revision was automatically updated to reflect the committed changes.

tomek added a commit: rCOMM48441ea35eca: [keyserver] Change blob upload functions to return more usable results.

Revision Contents
Changeset List

Path

Size

keyserver/

src/

services/

blob.js

71 lines

Diff 37085

View Options

keyserver/src/services/blob.js

	Show All 22 Lines
	} from '../../types/minimally-encoded-thread-permissions-types.js';			} from '../../types/minimally-encoded-thread-permissions-types.js';
	import { joinThreadSubscription } from '../../types/subscription-types.js';			import { joinThreadSubscription } from '../../types/subscription-types.js';
	import type { ThickMemberInfo } from '../../types/thread-types.js';			import type { ThickMemberInfo } from '../../types/thread-types.js';
	import { updateTypes } from '../../types/update-types-enum.js';			import { updateTypes } from '../../types/update-types-enum.js';
	import type { ClientUpdateInfo } from '../../types/update-types.js';			import type { ClientUpdateInfo } from '../../types/update-types.js';
	import { values } from '../../utils/objects.js';			import { values } from '../../utils/objects.js';
	import { roleIsDefaultRole, userIsMember } from '../thread-utils.js';			import { roleIsDefaultRole, userIsMember } from '../thread-utils.js';

	const addMembersSpec: DMOperationSpec<DMAddMembersOperation> = Object.freeze({			function createAddNewMembersResults(
	processDMOperation: async (
	dmOperation: DMAddMembersOperation,			dmOperation: DMAddMembersOperation,
	viewerID: string,			viewerID: string,
	utilities: ProcessDMOperationUtilities,			utilities: ProcessDMOperationUtilities,
	) => {			): {
				+rawMessageInfos: Array<RawMessageInfo>,
				+updateInfos: Array<ClientUpdateInfo>,
				+threadInfo: ?ThickRawThreadInfo,
				} {
	const { editorID, time, messageID, addedUserIDs, existingThreadDetails } =			const { editorID, time, messageID, addedUserIDs, existingThreadDetails } =
	dmOperation;			dmOperation;
	const addMembersMessage = {			const addMembersMessage = {
	type: messageTypes.ADD_MEMBERS,			type: messageTypes.ADD_MEMBERS,
	id: messageID,			id: messageID,
	threadID: existingThreadDetails.threadID,			threadID: existingThreadDetails.threadID,
	creatorID: editorID,			creatorID: editorID,
	time,			time,
	addedUserIDs: [...addedUserIDs],			addedUserIDs: [...addedUserIDs],
	};			};

	const viewerIsAdded = addedUserIDs.includes(viewerID);			const viewerIsAdded = addedUserIDs.includes(viewerID);
	const updateInfos: Array<ClientUpdateInfo> = [];			const updateInfos: Array<ClientUpdateInfo> = [];
	const rawMessageInfos: Array<RawMessageInfo> = [];			const rawMessageInfos: Array<RawMessageInfo> = [];
				let resultThreadInfo: ?ThickRawThreadInfo;
	if (viewerIsAdded) {			if (viewerIsAdded) {
	const newThread = createThickRawThreadInfo(			const newThread = createThickRawThreadInfo(
	{			{
	...existingThreadDetails,			...existingThreadDetails,
	allMemberIDs: [			allMemberIDs: [...existingThreadDetails.allMemberIDs, ...addedUserIDs],
	...existingThreadDetails.allMemberIDs,
	...addedUserIDs,
	],
	},			},
	viewerID,			viewerID,
	);			);
				resultThreadInfo = newThread;
	updateInfos.push(			updateInfos.push(
	{			{
	type: updateTypes.JOIN_THREAD,			type: updateTypes.JOIN_THREAD,
	id: uuid.v4(),			id: uuid.v4(),
	time,			time,
	threadInfo: newThread,			threadInfo: newThread,
	rawMessageInfos: [addMembersMessage],			rawMessageInfos: [addMembersMessage],
	truncationStatus: messageTruncationStatus.EXHAUSTIVE,			truncationStatus: messageTruncationStatus.EXHAUSTIVE,
	rawEntryInfos: [],			rawEntryInfos: [],
	},			},
	{			{
	type: updateTypes.UPDATE_THREAD_READ_STATUS,			type: updateTypes.UPDATE_THREAD_READ_STATUS,
	id: uuid.v4(),			id: uuid.v4(),
	time,			time,
	threadID: existingThreadDetails.threadID,			threadID: existingThreadDetails.threadID,
	unread: true,			unread: true,
	},			},
	);			);
	} else {			} else {
	const currentThreadInfoOptional =			const currentThreadInfoOptional =
	utilities.threadInfos[existingThreadDetails.threadID];			utilities.threadInfos[existingThreadDetails.threadID];
	if (!currentThreadInfoOptional \|\| !currentThreadInfoOptional.thick) {			if (!currentThreadInfoOptional \|\| !currentThreadInfoOptional.thick) {
	// We can't perform this operation now. It should be queued for later.			// We can't perform this operation now. It should be queued for later.
	return {			return {
	rawMessageInfos: [],			rawMessageInfos: [],
	updateInfos: [],			updateInfos: [],
				threadInfo: null,
	};			};
	}			}
	const currentThreadInfo: ThickRawThreadInfo = currentThreadInfoOptional;			const currentThreadInfo: ThickRawThreadInfo = currentThreadInfoOptional;
	const defaultRoleID = values(currentThreadInfo.roles).find(role =>			const defaultRoleID = values(currentThreadInfo.roles).find(role =>
	roleIsDefaultRole(role),			roleIsDefaultRole(role),
	)?.id;			)?.id;
	invariant(defaultRoleID, 'Default role ID must exist');			invariant(defaultRoleID, 'Default role ID must exist');
	const { membershipPermissions } = createRoleAndPermissionForThickThreads(			const { membershipPermissions } = createRoleAndPermissionForThickThreads(
	currentThreadInfo.type,			currentThreadInfo.type,
	currentThreadInfo.id,			currentThreadInfo.id,
	defaultRoleID,			defaultRoleID,
	);			);
	const newMembers = addedUserIDs			const newMembers = addedUserIDs
	.filter(userID => !userIsMember(currentThreadInfo, userID))			.filter(userID => !userIsMember(currentThreadInfo, userID))
	.map(userID =>			.map(userID =>
	minimallyEncodeMemberInfo<ThickMemberInfo>({			minimallyEncodeMemberInfo<ThickMemberInfo>({
	id: userID,			id: userID,
	role: defaultRoleID,			role: defaultRoleID,
	permissions: membershipPermissions,			permissions: membershipPermissions,
	isSender: editorID === viewerID,			isSender: editorID === viewerID,
	subscription: joinThreadSubscription,			subscription: joinThreadSubscription,
	}),			}),
	);			);

	const newThreadInfo = {			const newThreadInfo = {
	...currentThreadInfo,			...currentThreadInfo,
	members: [...currentThreadInfo.members, ...newMembers],			members: [...currentThreadInfo.members, ...newMembers],
	};			};
				resultThreadInfo = newThreadInfo;
	updateInfos.push(			updateInfos.push(
	{			{
	type: updateTypes.UPDATE_THREAD,			type: updateTypes.UPDATE_THREAD,
	id: uuid.v4(),			id: uuid.v4(),
	time,			time,
	threadInfo: newThreadInfo,			threadInfo: newThreadInfo,
	},			},
	{			{
	type: updateTypes.UPDATE_THREAD_READ_STATUS,			type: updateTypes.UPDATE_THREAD_READ_STATUS,
	id: uuid.v4(),			id: uuid.v4(),
	time,			time,
	threadID: existingThreadDetails.threadID,			threadID: existingThreadDetails.threadID,
	unread: true,			unread: true,
	},			},
	);			);
	rawMessageInfos.push(addMembersMessage);			rawMessageInfos.push(addMembersMessage);
	}			}
	return {			return {
	rawMessageInfos,			rawMessageInfos,
	updateInfos,			updateInfos,
				threadInfo: resultThreadInfo,
	};			};
				}

				const addMembersSpec: DMOperationSpec<DMAddMembersOperation> = Object.freeze({
				processDMOperation: async (
				dmOperation: DMAddMembersOperation,
				viewerID: string,
				utilities: ProcessDMOperationUtilities,
				) => {
				const { rawMessageInfos, updateInfos } = createAddNewMembersResults(
				dmOperation,
				viewerID,
				utilities,
				);
				return { rawMessageInfos, updateInfos };
	},			},
	});			});

	export { addMembersSpec };			export { addMembersSpec, createAddNewMembersResults };

[keyserver] Change blob upload functions to return more usable resultsClosedPublicActions