Page MenuHomePhabricator
Differential D3457

[tunnelbroker] Remove repeated Dockerfile instructions
ClosedPublic
Actions

Authored by • jim on Mar 17 2022, 3:57 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Mar 16, 7:08 PM
Unknown Object (File)
Mon, Mar 10, 9:52 PM
Unknown Object (File)
Mon, Mar 10, 9:47 PM
Unknown Object (File)
Mon, Mar 10, 9:46 PM
Unknown Object (File)
Mon, Mar 10, 9:45 PM
Unknown Object (File)
Sun, Mar 2, 5:35 PM
Unknown Object (File)
Feb 23 2025, 3:13 AM
Unknown Object (File)
Feb 22 2025, 7:27 PM
View All Files
Subscribers
• adrian
atul
• benschac

Details

Reviewers
ashoat
• max
• karol
varun
tomek
Commits
rCOMMc6c122495d64: [tunnelbroker] Remove repeated Dockerfile instructions
Summary

Packages are installed in tunnelbroker Dockerfile which are already
installed in the base image.

Follow-up to D3268.

Test Plan

npm run build-all in services

Diff Detail

Repository
rCOMM Comm
Branch
remove-apt-install
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
services/
tunnelbroker/
8 lines

Diff 10510

View Options

services/tunnelbroker/Dockerfile

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