Page MenuHomePhabricator
Differential D9941

[keyserver] Split uploading blob and assigning holders
ClosedPublic
Actions

Authored by tomek on Nov 21 2023, 6:55 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Mar 9, 1:59 AM
Unknown Object (File)
Wed, Feb 26, 10:45 AM
Unknown Object (File)
Feb 22 2025, 7:36 AM
Unknown Object (File)
Feb 20 2025, 9:39 PM
Unknown Object (File)
Jan 22 2025, 11:42 PM
Unknown Object (File)
Jan 22 2025, 11:42 PM
Unknown Object (File)
Jan 22 2025, 11:38 PM
Unknown Object (File)
Jan 22 2025, 8:15 PM
View All 93 Files
Subscribers
ashoat

Details

Reviewers
kamil
marcin
Commits
rCOMM19bc53760b95: [keyserver] Split uploading blob and assigning holders
Summary

For some callers it might be desirable to choose the ordering of these operations and perform them sequentially.

Depends on D9940

Test Plan

Check if calling the new function has the same result as the old one.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
keyserver/
src/
services/
54 lines

Diff 33581

View Options

keyserver/src/services/blob.js

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
function reassignMessagesToRealizedThreads( function reassignMessagesToRealizedThreads(
messageStore: MessageStore, messageStore: MessageStore,
threadInfos: RawThreadInfos, threadInfos: RawThreadInfos,
): ReassignmentResult { ): ReassignmentResult {
const pendingToRealizedThreadIDs = const pendingToRealizedThreadIDs =
pendingToRealizedThreadIDsSelector(threadInfos); pendingToRealizedThreadIDsSelector(threadInfos);
const messageStoreOperations: MessageStoreOperation[] = []; const messageStoreOperations: MessageStoreOperation[] = [];
const messages = {}; const messages: { [string]: RawMessageInfo } = {};
for (const storeMessageID in messageStore.messages) { for (const storeMessageID in messageStore.messages) {
const message = messageStore.messages[storeMessageID]; const message = messageStore.messages[storeMessageID];
const newThreadID = pendingToRealizedThreadIDs.get(message.threadID); const newThreadID = pendingToRealizedThreadIDs.get(message.threadID);
messages[storeMessageID] = newThreadID messages[storeMessageID] = newThreadID
? { ? {
...message, ...message,
threadID: newThreadID, threadID: newThreadID,
time: threadInfos[newThreadID]?.creationTime ?? message.time, time: threadInfos[newThreadID]?.creationTime ?? message.time,
} }
: message; : message;
if (!newThreadID) { if (!newThreadID) {
continue; continue;
} }
const updateMsgOperation: ReplaceMessageOperation = { const updateMsgOperation: ReplaceMessageOperation = {
type: 'replace', type: 'replace',
payload: { id: storeMessageID, messageInfo: messages[storeMessageID] }, payload: { id: storeMessageID, messageInfo: messages[storeMessageID] },
}; };
messageStoreOperations.push(updateMsgOperation); messageStoreOperations.push(updateMsgOperation);
} }
const threads = {}; const threads: { [string]: ThreadMessageInfo } = {};
const reassignedThreadIDs = []; const reassignedThreadIDs = [];
const updatedThreads = {}; const updatedThreads: { [string]: ThreadMessageInfo } = {};
const threadsToRemove = []; const threadsToRemove = [];
for (const threadID in messageStore.threads) { for (const threadID in messageStore.threads) {
const threadMessageInfo = messageStore.threads[threadID]; const threadMessageInfo = messageStore.threads[threadID];
const newThreadID = pendingToRealizedThreadIDs.get(threadID); const newThreadID = pendingToRealizedThreadIDs.get(threadID);
if (!newThreadID) { if (!newThreadID) {
threads[threadID] = threadMessageInfo; threads[threadID] = threadMessageInfo;
continue; continue;
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linestype MergeNewMessagesResult = {
+messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>, +messageStoreOperations: $ReadOnlyArray<MessageStoreOperation>,
+messageStore: MessageStore, +messageStore: MessageStore,
}; };
// oldMessageStore is from the old state // oldMessageStore is from the old state
// newMessageInfos, truncationStatus come from server // newMessageInfos, truncationStatus come from server
function mergeNewMessages( function mergeNewMessages(
oldMessageStore: MessageStore, oldMessageStore: MessageStore,
newMessageInfos: $ReadOnlyArray<RawMessageInfo>, newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
truncationStatus: { [threadID: string]: MessageTruncationStatus }, truncationStatus: { +[threadID: string]: MessageTruncationStatus },
threadInfos: RawThreadInfos, threadInfos: RawThreadInfos,
): MergeNewMessagesResult { ): MergeNewMessagesResult {
const { const {
messageStoreOperations: updateWithLatestThreadInfosOps, messageStoreOperations: updateWithLatestThreadInfosOps,
messageStore: messageStoreUpdatedWithLatestThreadInfos, messageStore: messageStoreUpdatedWithLatestThreadInfos,
reassignedThreadIDs, reassignedThreadIDs,
} = updateMessageStoreWithLatestThreadInfos(oldMessageStore, threadInfos); } = updateMessageStoreWithLatestThreadInfos(oldMessageStore, threadInfos);
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines): MergeNewMessagesResult {
)(unshimmedNewMessagesOfWatchedThreads); )(unshimmedNewMessagesOfWatchedThreads);
const newMessageOps: MessageStoreOperation[] = []; const newMessageOps: MessageStoreOperation[] = [];
const threadsToMessageIDs = mapThreadsToMessageIDsFromOrderedMessageInfos( const threadsToMessageIDs = mapThreadsToMessageIDsFromOrderedMessageInfos(
orderedNewMessageInfos, orderedNewMessageInfos,
); );
const oldMessageInfosToCombine = []; const oldMessageInfosToCombine = [];
const threadsThatNeedMessageIDsResorted = []; const threadsThatNeedMessageIDsResorted = [];
const local = {}; const local: { [string]: LocalMessageInfo } = {};
const updatedThreads = {}; const updatedThreads: { [string]: ThreadMessageInfo } = {};
const threads = _flow( const threads = _flow(
_mapValuesWithKeys((messageIDs: string[], threadID: string) => { _mapValuesWithKeys((messageIDs: string[], threadID: string) => {
const oldThread = updatedMessageStore.threads[threadID]; const oldThread = updatedMessageStore.threads[threadID];
const truncate = truncationStatus[threadID]; const truncate = truncationStatus[threadID];
if (!oldThread) { if (!oldThread) {
updatedThreads[threadID] = { updatedThreads[threadID] = {
...newThread(), ...newThread(),
messageIDs, messageIDs,
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines): UpdateMessageStoreWithLatestThreadInfosResult {
const { const {
messageStore: reassignedMessageStore, messageStore: reassignedMessageStore,
messageStoreOperations: reassignMessagesOps, messageStoreOperations: reassignMessagesOps,
reassignedThreadIDs, reassignedThreadIDs,
} = reassignMessagesToRealizedThreads(messageStore, threadInfos); } = reassignMessagesToRealizedThreads(messageStore, threadInfos);
messageStoreOperations.push(...reassignMessagesOps); messageStoreOperations.push(...reassignMessagesOps);
const watchedIDs = [...threadWatcher.getWatchedIDs(), ...reassignedThreadIDs]; const watchedIDs = [...threadWatcher.getWatchedIDs(), ...reassignedThreadIDs];
const filteredThreads = {}; const filteredThreads: { [string]: ThreadMessageInfo } = {};
const threadsToRemoveMessagesFrom = []; const threadsToRemoveMessagesFrom = [];
const messageIDsToRemove = []; const messageIDsToRemove = [];
for (const threadID in reassignedMessageStore.threads) { for (const threadID in reassignedMessageStore.threads) {
const threadMessageInfo = reassignedMessageStore.threads[threadID]; const threadMessageInfo = reassignedMessageStore.threads[threadID];
const threadInfo = threadInfos[threadID]; const threadInfo = threadInfos[threadID];
if (isThreadWatched(threadID, threadInfo, watchedIDs)) { if (isThreadWatched(threadID, threadInfo, watchedIDs)) {
filteredThreads[threadID] = threadMessageInfo; filteredThreads[threadID] = threadMessageInfo;
} else { } else {
threadsToRemoveMessagesFrom.push(threadID); threadsToRemoveMessagesFrom.push(threadID);
messageIDsToRemove.push(...threadMessageInfo.messageIDs); messageIDsToRemove.push(...threadMessageInfo.messageIDs);
} }
} }
const updatedThreads = {}; const updatedThreads: { [string]: ThreadMessageInfo } = {};
for (const threadID in threadInfos) { for (const threadID in threadInfos) {
const threadInfo = threadInfos[threadID]; const threadInfo = threadInfos[threadID];
if ( if (
isThreadWatched(threadID, threadInfo, watchedIDs) && isThreadWatched(threadID, threadInfo, watchedIDs) &&
!filteredThreads[threadID] !filteredThreads[threadID]
) { ) {
filteredThreads[threadID] = newThread(); filteredThreads[threadID] = newThread();
updatedThreads[threadID] = filteredThreads[threadID]; updatedThreads[threadID] = filteredThreads[threadID];
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 Lines return mergeNewMessages(
[action.payload.messageInfo], [action.payload.messageInfo],
{ {
[action.payload.messageInfo.threadID]: [action.payload.messageInfo.threadID]:
messageTruncationStatus.UNCHANGED, messageTruncationStatus.UNCHANGED,
}, },
newThreadInfos, newThreadInfos,
); );
} else if (action.type === registerActionTypes.success) { } else if (action.type === registerActionTypes.success) {
const truncationStatuses = {}; const truncationStatuses: { [string]: MessageTruncationStatus } = {};
for (const messageInfo of action.payload.rawMessageInfos) { for (const messageInfo of action.payload.rawMessageInfos) {
truncationStatuses[messageInfo.threadID] = truncationStatuses[messageInfo.threadID] =
messageTruncationStatus.EXHAUSTIVE; messageTruncationStatus.EXHAUSTIVE;
} }
return mergeNewMessages( return mergeNewMessages(
messageStore, messageStore,
action.payload.rawMessageInfos, action.payload.rawMessageInfos,
truncationStatuses, truncationStatuses,
Show All 32 Lines ) {
return mergeNewMessages( return mergeNewMessages(
messageStore, messageStore,
messagesResult.rawMessageInfos, messagesResult.rawMessageInfos,
messagesResult.truncationStatuses, messagesResult.truncationStatuses,
newThreadInfos, newThreadInfos,
); );
} else if (action.type === sendEditMessageActionTypes.success) { } else if (action.type === sendEditMessageActionTypes.success) {
const { newMessageInfos } = action.payload; const { newMessageInfos } = action.payload;
const truncationStatuses = {}; const truncationStatuses: { [string]: MessageTruncationStatus } = {};
for (const messageInfo of newMessageInfos) { for (const messageInfo of newMessageInfos) {
truncationStatuses[messageInfo.threadID] = truncationStatuses[messageInfo.threadID] =
messageTruncationStatus.UNCHANGED; messageTruncationStatus.UNCHANGED;
} }
return mergeNewMessages( return mergeNewMessages(
messageStore, messageStore,
newMessageInfos, newMessageInfos,
truncationStatuses, truncationStatuses,
▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Lines return {
messageStore: { messageStore: {
...messageStore, ...messageStore,
messages: processedMessageStore.messages, messages: processedMessageStore.messages,
threads: processedMessageStore.threads, threads: processedMessageStore.threads,
local, local,
}, },
}; };
} else if (action.type === saveMessagesActionType) { } else if (action.type === saveMessagesActionType) {
const truncationStatuses = {}; const truncationStatuses: { [string]: MessageTruncationStatus } = {};
for (const messageInfo of action.payload.rawMessageInfos) { for (const messageInfo of action.payload.rawMessageInfos) {
truncationStatuses[messageInfo.threadID] = truncationStatuses[messageInfo.threadID] =
messageTruncationStatus.UNCHANGED; messageTruncationStatus.UNCHANGED;
} }
const { messageStoreOperations, messageStore: newMessageStore } = const { messageStoreOperations, messageStore: newMessageStore } =
mergeNewMessages( mergeNewMessages(
messageStore, messageStore,
action.payload.rawMessageInfos, action.payload.rawMessageInfos,
Show All 10 Lines return {
// RawMessageInfo, so we want to make sure we still fetch it // RawMessageInfo, so we want to make sure we still fetch it
currentAsOf: messageStore.currentAsOf, currentAsOf: messageStore.currentAsOf,
}, },
}; };
} else if (action.type === messageStorePruneActionType) { } else if (action.type === messageStorePruneActionType) {
const now = Date.now(); const now = Date.now();
const messageIDsToPrune = []; const messageIDsToPrune = [];
const updatedThreads = {}; const updatedThreads: { [string]: ThreadMessageInfo } = {};
for (const threadID of action.payload.threadIDs) { for (const threadID of action.payload.threadIDs) {
let thread = messageStore.threads[threadID]; let thread = messageStore.threads[threadID];
if (!thread) { if (!thread) {
continue; continue;
} }
thread = { ...thread, lastPruned: now }; thread = { ...thread, lastPruned: now };
const newMessageIDs = [...thread.messageIDs]; const newMessageIDs = [...thread.messageIDs];
▲ Show 20 Lines • Show All 355 Lines • ▼ Show 20 Lines ) {
} }
const threadsNeedMsgIDsResorting = new Set(); const threadsNeedMsgIDsResorting = new Set();
const actionPayloadMessages = const actionPayloadMessages =
messageStoreOpsHandlers.translateClientDBData(payloadMessages); messageStoreOpsHandlers.translateClientDBData(payloadMessages);
// When starting the app on native, we filter out any local-only multimedia // When starting the app on native, we filter out any local-only multimedia
// messages because the relevant context is no longer available // messages because the relevant context is no longer available
const messageIDsToBeRemoved = []; const messageIDsToBeRemoved = [];
const threadsToAdd = {}; const threadsToAdd: { [string]: ThreadMessageInfo } = {};
for (const id in actionPayloadMessages) { for (const id in actionPayloadMessages) {
const message = actionPayloadMessages[id]; const message = actionPayloadMessages[id];
const { threadID } = message; const { threadID } = message;
let existingThread = threads[threadID]; let existingThread = threads[threadID];
if (!existingThread) { if (!existingThread) {
existingThread = newThread(); existingThread = newThread();
threadsToAdd[threadID] = existingThread; threadsToAdd[threadID] = existingThread;
} }
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines