Page MenuHomePhabricator
Differential D11604

[keyserver] Update `updateRelationshipInputValidator` to accept both traditional/farcaster requests
AbandonedPublicDraft
Actions

Authored by atul on Apr 9 2024, 7:50 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Apr 12, 5:29 AM
Unknown Object (File)
Wed, Mar 26, 9:42 AM
Unknown Object (File)
Mar 14 2025, 9:53 PM
Unknown Object (File)
Mar 14 2025, 10:57 AM
Unknown Object (File)
Mar 8 2025, 2:06 AM
Unknown Object (File)
Mar 8 2025, 2:05 AM
Unknown Object (File)
Mar 8 2025, 2:05 AM
Unknown Object (File)
Feb 10 2025, 8:29 PM
View All 46 Files
Subscribers
ashoat

Details

Reviewers
varun
ginsu
will
tomek
Summary

Update updateRelationshipInputValidator to support both traditional and farcaster requests.

Changes will still need to be made within responder to handle farcaster requests, this just ensures that validation won't fail.

Depends on D11603

Test Plan

Tested implicitly by traditional/farcaster requests later in the stack. Could also add unit tests.

Diff Detail

Repository
rCOMM Comm
Branch
master
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
keyserver/
src/
responders/
8 lines

Diff 38960

View Options

keyserver/src/responders/relationship-responders.js

Show First 20 Lines • Show All 268 Lines • ▼ Show 20 Linesclass InputStateContainer extends React.PureComponent<Props, State> {
} }
static completedMessageIDs(state: State): Set<string> { static completedMessageIDs(state: State): Set<string> {
const completed = new Map<string, boolean>(); const completed = new Map<string, boolean>();
for (const threadID in state.pendingUploads) { for (const threadID in state.pendingUploads) {
const pendingUploads = state.pendingUploads[threadID]; const pendingUploads = state.pendingUploads[threadID];
for (const localUploadID in pendingUploads) { for (const localUploadID in pendingUploads) {
const upload = pendingUploads[localUploadID]; const upload = pendingUploads[localUploadID];
const { messageID, serverID, failed } = upload; const { messageID, canBeSent, failed } = upload;
if (!messageID || !messageID.startsWith(localIDPrefix)) { if (!messageID || !messageID.startsWith(localIDPrefix)) {
continue; continue;
} }
if (!serverID || failed) { if (!canBeSent || failed) {
completed.set(messageID, false); completed.set(messageID, false);
continue; continue;
} }
if (completed.get(messageID) === undefined) { if (completed.get(messageID) === undefined) {
completed.set(messageID, true); completed.set(messageID, true);
} }
} }
} }
▲ Show 20 Lines • Show All 569 Lines • ▼ Show 20 Lines return {
messageID: null, messageID: null,
failed: false, failed: false,
file: encryptionResult?.file ?? fixedFile, file: encryptionResult?.file ?? fixedFile,
mediaType: encryptionResult ? 'encrypted_photo' : mediaType, mediaType: encryptionResult ? 'encrypted_photo' : mediaType,
dimensions, dimensions,
uri: encryptionResult?.uri ?? uri, uri: encryptionResult?.uri ?? uri,
loop: false, loop: false,
uriIsReal: false, uriIsReal: false,
canBeSent: false,
blobHolder: null, blobHolder: null,
blobHash: encryptionResult?.sha256Hash, blobHash: encryptionResult?.sha256Hash,
encryptionKey: encryptionResult?.encryptionKey, encryptionKey: encryptionResult?.encryptionKey,
thumbHash, thumbHash,
progressPercent: 0, progressPercent: 0,
abort: null, abort: null,
steps, steps,
selectTime, selectTime,
Show All 10 Lines ): Promise<mixed> {
return Promise.all( return Promise.all(
uploads.map(upload => this.uploadFile(threadInfo, upload)), uploads.map(upload => this.uploadFile(threadInfo, upload)),
); );
} }
async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) { async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const { selectTime, localID, encryptionKey } = upload; const { selectTime, localID, encryptionKey } = upload;
const threadID = threadInfo.id; const threadID = threadInfo.id;
const isThickThread = threadTypeIsThick(threadInfo.type);
const isEncrypted = const isEncrypted =
!!encryptionKey && !!encryptionKey &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video'); upload.mediaType === 'encrypted_video');
const steps = [...upload.steps]; const steps = [...upload.steps];
let userTime; let userTime;
Show All 25 Lines async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const uploadStart = Date.now(); const uploadStart = Date.now();
try { try {
const callbacks = { const callbacks = {
onProgress: (percent: number) => onProgress: (percent: number) =>
this.setProgress(threadID, localID, percent), this.setProgress(threadID, localID, percent),
abortHandler: (abort: () => void) => abortHandler: (abort: () => void) =>
this.handleAbortCallback(threadID, localID, abort), this.handleAbortCallback(threadID, localID, abort),
}; };
const isThickThread = threadTypeIsThick(threadInfo.type);
const useBlobService = isThickThread || this.useBlobServiceUploads; const useBlobService = isThickThread || this.useBlobServiceUploads;
if ( if (
useBlobService && useBlobService &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video') upload.mediaType === 'encrypted_video')
) { ) {
const { blobHash, dimensions, thumbHash } = upload; const { blobHash, dimensions, thumbHash } = upload;
invariant( invariant(
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
serverID: result.id, serverID: result.id,
blobHolder: result.blobHolder, blobHolder: result.blobHolder,
abort: null, abort: null,
// For thin threads we can send message right after serverID
// is present, but for thick threads we need to wait until
// a "real" Blob URI is assigned to the message.
canBeSent: !isThickThread,
}, },
}, },
}, },
}; };
}); });
if (encryptionKey) { if (encryptionKey) {
const authMetadata = await identityContext.getAuthMetadata(); const authMetadata = await identityContext.getAuthMetadata();
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
uri: result.uri, uri: result.uri,
mediaType: outputMediaType, mediaType: outputMediaType,
dimensions: result.dimensions, dimensions: result.dimensions,
uriIsReal: true,
loop: result.loop, loop: result.loop,
uriIsReal: true,
canBeSent: true,
}, },
}, },
}, },
}; };
}); });
} }
handleAbortCallback( handleAbortCallback(
▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines