Page MenuHomePhabricator
Differential D11992

[keyserver] Update thread avatar assigner to check new user_container column
ClosedPublic
Actions

Authored by ashoat on May 10 2024, 8:45 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Apr 12, 11:25 AM
Unknown Object (File)
Sat, Apr 12, 8:51 AM
Unknown Object (File)
Sat, Apr 12, 4:14 AM
Unknown Object (File)
Fri, Apr 11, 2:40 AM
Unknown Object (File)
Mar 21 2025, 5:47 PM
Unknown Object (File)
Mar 10 2025, 5:37 AM
Unknown Object (File)
Feb 28 2025, 3:52 PM
Unknown Object (File)
Feb 28 2025, 3:52 PM
View All Files
Subscribers
None

Details

Reviewers
tomek
Commits
rCOMMdabcb103e7ca: [keyserver] Update thread avatar assigner to check new user_container column
Summary

We should not assign an upload as a thread avatar if it's already assigned as a user avatar.

Depends on D11991

Test Plan

I tested the whole stack with the following steps:

  1. Ran the migration on a backup of my production keyserver database from September 2023. Confirm that the uploads table has the new column, that it has an index, and that it's populated for all cases where the old column matched a user. Confirm that only 32 rows were updated, which matched the number of users with avatars in a prior query
  2. Create a brand new database. Confirm that the Confirm that the uploads table has the new column, and that it has an index. Make sure DESCRIBE uploads; matches what it looked like in step 1
  3. Run the migration on my local multi-keyserver testing database. Make sure I'm still able to log in with an existing user. Confirm I can change the existing user's avatar to a photo and that there are no errors in the logs. Confirm that the avatar is still there if I log out and back in
  4. On the same database, try creating a new user with a photo avatar and confirm that it works, and that there are no errors in the logs. Confirm that the avatar is still there if I log out and back in
  5. Ran git grep container in the keyserver folder and reviewed every result to consider whether it needs to be updated

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
keyserver/
src/
updaters/
2 lines

Diff 40116

View Options

keyserver/src/updaters/thread-updaters.js

  • This file was added.
// @flow
import invariant from 'invariant';
import t, { type TInterface } from 'tcomb';
import {
type CommonNativeNotifInputData,
commonNativeNotifInputDataValidator,
} from './android-notif-creators.js';
import {
prepareEncryptedAPNsVisualNotifications,
prepareEncryptedAPNsSilentNotifications,
} from './crypto.js';
import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
import {
hasMinCodeVersion,
FUTURE_CODE_VERSION,
} from '../shared/version-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import { messageTypes } from '../types/message-types-enum.js';
import {
type NotificationTargetDevice,
type EncryptedNotifUtilsAPI,
type TargetedAPNsNotification,
type APNsVisualNotification,
type APNsNotificationHeaders,
type SenderDeviceDescriptor,
} from '../types/notif-types.js';
import { tShape } from '../utils/validation-utils.js';
export const apnMaxNotificationPayloadByteSize = 4096;
export type APNsNotifInputData = {
...CommonNativeNotifInputData,
+badgeOnly: boolean,
+uniqueID: string,
};
export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
tShape<APNsNotifInputData>({
...commonNativeNotifInputDataValidator.meta.props,
badgeOnly: t.Boolean,
uniqueID: t.String,
});
async function createAPNsVisualNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotifInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
senderDeviceDescriptor,
notifTexts,
newRawMessageInfos,
threadID,
collapseKey,
badgeOnly,
unreadCount,
platformDetails,
uniqueID,
} = inputData;
const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
platformDetails,
{ native: 222 },
);
const isNonCollapsibleTextNotification =
newRawMessageInfos.every(
newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
) && !collapseKey;
const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
native: 267,
});
const canDecryptIOSNotif =
platformDetails.platform === 'ios' &&
(canDecryptAllIOSNotifs ||
(isNonCollapsibleTextNotification &&
canDecryptNonCollapsibleTextIOSNotifs));
const canDecryptMacOSNotifs =
platformDetails.platform === 'macos' &&
hasMinCodeVersion(platformDetails, {
web: 47,
majorDesktop: 9,
});
let apsDictionary = {
'thread-id': threadID,
};
if (unreadCount !== undefined && unreadCount !== null) {
apsDictionary = {
...apsDictionary,
badge: unreadCount,
};
}
const { merged, ...rest } = notifTexts;
// We don't include alert's body on macos because we
// handle displaying the notification ourselves and
// we don't want macOS to display it automatically.
if (!badgeOnly && platformDetails.platform !== 'macos') {
apsDictionary = {
...apsDictionary,
alert: merged,
sound: 'default',
};
}
if (hasMinCodeVersion(platformDetails, { native: 198 })) {
apsDictionary = {
...apsDictionary,
'mutable-content': 1,
};
}
let notificationPayload = {
...rest,
id: uniqueID,
threadID,
};
let notificationHeaders: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-id': uniqueID,
'apns-push-type': 'alert',
};
if (collapseKey && (canDecryptAllIOSNotifs || canDecryptMacOSNotifs)) {
notificationPayload = {
...notificationPayload,
collapseID: collapseKey,
};
} else if (collapseKey) {
notificationHeaders = {
...notificationHeaders,
'apns-collapse-id': collapseKey,
};
}
const notification = {
...notificationPayload,
headers: notificationHeaders,
aps: apsDictionary,
};
const messageInfos = JSON.stringify(newRawMessageInfos);
const copyWithMessageInfos = {
...notification,
messageInfos,
};
const notificationSizeValidator = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return (
encryptedNotifUtilsAPI.getNotifByteSize(
JSON.stringify(notifSansHeaders),
) <= apnMaxNotificationPayloadByteSize
);
};
const serializeAPNsNotif = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return JSON.stringify(notifSansHeaders);
};
const shouldBeEncrypted = canDecryptIOSNotif || canDecryptMacOSNotifs;
if (!shouldBeEncrypted) {
const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
? copyWithMessageInfos
: notification;
return devices.map(({ deliveryID }) => ({
notification: notificationToSend,
deliveryID,
}));
}
// The `messageInfos` field in notification payload is
// not used on MacOS so we can return early.
if (platformDetails.platform === 'macos') {
const macOSNotifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return macOSNotifsWithoutMessageInfos.map(
({ notification: notif, deliveryID }) => ({
notification: notif,
deliveryID,
}),
);
}
const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
copyWithMessageInfos,
platformDetails.codeVersion,
notificationSizeValidator,
);
const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
.map(({ cryptoID, deliveryID }) => ({
cryptoID,
deliveryID,
}));
if (devicesWithExcessiveSizeNoHolders.length === 0) {
return notifsWithMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
}
const canQueryBlobService = hasMinCodeVersion(platformDetails, {
native: 331,
});
let blobHash, blobHolders, encryptionKey, blobUploadError;
if (canQueryBlobService) {
({ blobHash, blobHolders, encryptionKey, blobUploadError } =
await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
serializeAPNsNotif(copyWithMessageInfos),
devicesWithExcessiveSizeNoHolders.length,
));
}
if (blobUploadError) {
console.warn(
`Failed to upload payload of notification: ${uniqueID} ` +
`due to error: ${blobUploadError}`,
);
}
let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
let notificationWithBlobMetadata = notification;
if (
blobHash &&
encryptionKey &&
blobHolders &&
blobHolders.length === devicesWithExcessiveSize.length
) {
notificationWithBlobMetadata = {
...notification,
blobHash,
encryptionKey,
};
devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
...devicesWithExcessiveSize[idx],
blobHolder: holder,
}));
}
const notifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devicesWithExcessiveSize,
notificationWithBlobMetadata,
platformDetails.codeVersion,
);
const targetedNotifsWithMessageInfos = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
return [
...targetedNotifsWithMessageInfos,
...targetedNotifsWithoutMessageInfos,
];
}
type APNsNotificationRescindInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+rescindID?: string,
+badge?: number,
+threadID: string,
+platformDetails: PlatformDetails,
};
async function createAPNsNotificationRescind(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotificationRescindInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
badge,
rescindID,
threadID,
platformDetails,
senderDeviceDescriptor,
} = inputData;
invariant(
(rescindID && badge !== null && badge !== undefined) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread rescind not support for this client version',
);
const apnsTopic = getAPNsNotificationTopic(platformDetails);
let notification;
if (
rescindID &&
badge !== null &&
badge !== undefined &&
hasMinCodeVersion(platformDetails, { native: 198 })
) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else if (rescindID && badge !== null && badge !== undefined) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'background',
'apns-priority': 5,
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
},
threadID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
}
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
notification,
deliveryID,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
type APNsBadgeOnlyNotificationInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+badge?: number,
+threadID?: string,
+platformDetails: PlatformDetails,
};
async function createAPNsBadgeOnlyNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsBadgeOnlyNotificationInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const { senderDeviceDescriptor, platformDetails, threadID, badge } =
inputData;
invariant(
(!threadID && badge !== undefined && badge !== null) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread badge updates not support for this client version',
);
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
native: 222,
web: 47,
majorDesktop: 9,
});
const headers: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-push-type': 'alert',
};
let notification;
if (shouldBeEncrypted && threadID) {
notification = {
headers,
threadID,
aps: {
'mutable-content': 1,
},
};
} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
notification = {
headers,
aps: {
'badge': badge,
'mutable-content': 1,
},
};
} else {
invariant(
badge !== null && badge !== undefined,
'badge update must contain either badge count or threadID',
);
notification = {
headers,
aps: {
badge,
},
};
}
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
deliveryID,
notification,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
export {
createAPNsBadgeOnlyNotification,
createAPNsNotificationRescind,
createAPNsVisualNotification,
};