Page MenuHomePhabricator
Differential D3945

[Identity] Add new types to handle tokens
ClosedPublic
Actions

Authored by varun on May 6 2022, 7:15 AM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Mar 21, 8:37 AM
Unknown Object (File)
Wed, Mar 19, 8:47 PM
Unknown Object (File)
Wed, Mar 19, 5:13 PM
Unknown Object (File)
Sat, Mar 15, 9:19 AM
Unknown Object (File)
Sat, Mar 8, 11:17 PM
Unknown Object (File)
Sat, Mar 8, 11:17 PM
Unknown Object (File)
Sat, Mar 8, 11:17 PM
Unknown Object (File)
Sat, Mar 8, 11:17 PM
View All Files
Subscribers
• abosh
• adrian
ashoat
atul
• benschac
• jon

Details

Reviewers
• jim
• karol
tomek
ashoat
Commits
rCOMM71d308d9abbc: [Identity] Add new types to handle tokens
Summary

Our DatabaseClient will fetch user tokens from DynamoDB. We need a struct to store the data pertaining to a token.

We use the chrono crate to handle date/time

Test Plan

cargo build

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

varun created this revision.May 6 2022, 7:15 AM
Herald added subscribers: • abosh, • adrian, ashoat. · View Herald TranscriptMay 6 2022, 7:15 AM
Harbormaster returned this revision to the author for changes because remote builds failed.May 6 2022, 7:15 AM
Harbormaster failed remote builds in B8856: Diff 12352!
varun updated this revision to Diff 12353.May 6 2022, 7:16 AM

rebase

Harbormaster completed remote builds in B8857: Diff 12353.May 6 2022, 7:23 AM
varun requested review of this revision.May 6 2022, 7:23 AM
varun added a parent revision: D3921: [Identity] Implement database client method to get pake registration.May 6 2022, 10:34 AM
varun added a child revision: D3957: [Identity] DatabaseClient method to get user token.
varun updated this revision to Diff 12374.May 6 2022, 10:43 AM

Split new types out into new token module

varun added 1 blocking reviewer(s): • jim.May 6 2022, 10:44 AM
Harbormaster completed remote builds in B8878: Diff 12374.May 6 2022, 10:47 AM
• karol requested changes to this revision.EditedMay 9 2022, 2:51 AM

Why you don't put [services] prefix in your revisions' names for the identity service? I thought we had a convention that we put a prefix depending on the "module" we work on. So, for instance, [web], [server], [native]. [services] Is at the same level, [identity] is deeper one level. Is there a particular reason you do not do this here? Has this rule changed?

services/identity/src/token.rs
9–12 ↗(On Diff #12374)

What is the reason to use Option here? Why token is not optional and the rest of the fields are?

This revision now requires changes to proceed.May 9 2022, 2:51 AM
ashoat added a subscriber: • jon.May 9 2022, 9:14 AM
In D3945#110907, @karol-bisztyga wrote:

Why you don't put [services] prefix in your revisions' names for the identity service? I thought we had a convention that we put a prefix depending on the "module" we work on. So, for instance, [web], [server], [native]. [services] Is at the same level, [identity] is deeper one level. Is there a particular reason you do not do this here? Has this rule changed?

I have this pattern but I've actually never pushed it as a rule. The other day @jonringer-comm asked me if he should prefix his commit titles with [nix], so this is coming up in multiple places. Open to creating a rule for this but curious for other perspectives

• karol added a comment.EditedMay 10 2022, 1:34 AM
In D3945#111222, @ashoat wrote:
In D3945#110907, @karol-bisztyga wrote:

Why you don't put [services] prefix in your revisions' names for the identity service? I thought we had a convention that we put a prefix depending on the "module" we work on. So, for instance, [web], [server], [native]. [services] Is at the same level, [identity] is deeper one level. Is there a particular reason you do not do this here? Has this rule changed?

I have this pattern but I've actually never pushed it as a rule. The other day @jonringer-comm asked me if he should prefix his commit titles with [nix], so this is coming up in multiple places. Open to creating a rule for this but curious for other perspectives

I see. For me, personally, it would be handier because I set my herald rule to detect any revisions with [services] in their names. If you decide to user other naming then fine but I think it will be better for everybody to use one, consistent pattern.

As a side note, maybe we could use tags?

ashoat added a subscriber: • benschac.May 10 2022, 6:09 AM

That is a really good point about Herald rules. @benschac was asking on ENG-1055 about whether we should come up with a new Herald rule, since we're no longer recommending subscribing to all diffs... this idea makes sense to me.

varun planned changes to this revision.May 10 2022, 11:01 AM

i'll use [services][identity] going forward. are herald rules case sensitive?

services/identity/src/token.rs
9–12 ↗(On Diff #12374)

We use this struct to hold data returned from DynamoDB, so we need to handle incomplete data. I think token should actually be wrapped in an Option too... will fix

varun updated this revision to Diff 12580.May 12 2022, 8:30 AM

Rename Token to AccessToken to be more precise, make token field optional (to handle incomplete data in DynamoDB)

Harbormaster completed remote builds in B9037: Diff 12580.May 12 2022, 8:35 AM
ashoat accepted this revision.May 12 2022, 12:52 PM

Accepting to preempt somebody adding me due to dependency change

• karol requested changes to this revision.May 16 2022, 1:00 AM

back to you

services/identity/src/token.rs
9–12 ↗(On Diff #12374)

Sorry, but I don't really understand.

  1. This seems to be inconsistent with https://phabricator.ashoat.com/D3573?vs=on&id=11131:
  2. where's userID?
  3. why do you use just auth_type? I don't see pakePasswordCiphertext/walletAddress.
  4. What's the primary key here?
This revision now requires changes to proceed.May 16 2022, 1:00 AM
varun planned changes to this revision.May 19 2022, 11:21 AM
varun added inline comments.
services/identity/src/token.rs
9–12 ↗(On Diff #12374)
  1. I was passing userID and deviceID to functions as separate args in addition to the Token struct, but perhaps that's confusing. I can include all of it in the Token struct.
  1. https://phabricator.ashoat.com/D3573?vs=on&id=11902#toc in a later revision than the one you linked I realized we didn't actually need to store that stuff in the token table
  1. primary key is the userID (partition key) + deviceID (sort key)
varun updated this revision to Diff 12964.May 19 2022, 11:21 AM

add userID and deviceID to AccessToken struct

Harbormaster completed remote builds in B9357: Diff 12964.May 19 2022, 11:27 AM
• karol accepted this revision.May 20 2022, 12:36 AM
• karol added inline comments.
services/identity/src/token.rs
9–12 ↗(On Diff #12374)

Thanks, I think having args more explicit in the struct is more readable.

tomek accepted this revision.May 23 2022, 3:04 AM
• jim accepted this revision.May 24 2022, 12:21 PM
This revision is now accepted and ready to land.May 24 2022, 12:21 PM
Closed by commit rCOMM71d308d9abbc: [Identity] Add new types to handle tokens (authored by varun). · Explain WhyMay 25 2022, 10:58 AM
This revision was automatically updated to reflect the committed changes.
varun added a commit: rCOMM71d308d9abbc: [Identity] Add new types to handle tokens.

Revision Contents
Changeset List

PathSize
services/
identity/
1 line
src/
1 line
15 lines

Diff 13124

View Options

services/identity/Cargo.lock

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _groupBy from 'lodash/fp/groupBy.js'; import _groupBy from 'lodash/fp/groupBy.js';
import _keyBy from 'lodash/fp/keyBy.js'; import _keyBy from 'lodash/fp/keyBy.js';
import _omit from 'lodash/fp/omit.js'; import _omit from 'lodash/fp/omit.js';
import _partition from 'lodash/fp/partition.js'; import _partition from 'lodash/fp/partition.js';
import _sortBy from 'lodash/fp/sortBy.js'; import _sortBy from 'lodash/fp/sortBy.js';
import _memoize from 'lodash/memoize.js'; import _memoize from 'lodash/memoize.js';
import _throttle from 'lodash/throttle.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect'; import { createSelector } from 'reselect';
import uuid from 'uuid';
import { import {
createLocalMessageActionType, createLocalMessageActionType,
sendMultimediaMessageActionTypes, sendMultimediaMessageActionTypes,
legacySendMultimediaMessage, legacySendMultimediaMessage,
sendTextMessageActionTypes, sendTextMessageActionTypes,
sendTextMessage, sendTextMessage,
} from 'lib/actions/message-actions.js'; } from 'lib/actions/message-actions.js';
import { queueReportsActionType } from 'lib/actions/report-actions.js'; import { queueReportsActionType } from 'lib/actions/report-actions.js';
import { newThread } from 'lib/actions/thread-actions.js'; import { newThread } from 'lib/actions/thread-actions.js';
import { import {
uploadMultimedia, uploadMultimedia,
uploadMediaMetadata, uploadMediaMetadata,
updateMultimediaMessageMediaActionType, updateMultimediaMessageMediaActionType,
deleteUpload, deleteUpload,
blobServiceUpload,
type MultimediaUploadCallbacks, type MultimediaUploadCallbacks,
type MultimediaUploadExtras, type MultimediaUploadExtras,
type BlobServiceUploadAction,
} from 'lib/actions/upload-actions.js'; } from 'lib/actions/upload-actions.js';
import { import {
useModalContext, useModalContext,
type PushModal, type PushModal,
} from 'lib/components/modal-provider.react.js'; } from 'lib/components/modal-provider.react.js';
import blobService from 'lib/facts/blob-service.js'; import blobService from 'lib/facts/blob-service.js';
import commStaffCommunity from 'lib/facts/comm-staff-community.js'; import commStaffCommunity from 'lib/facts/comm-staff-community.js';
import { getNextLocalUploadID } from 'lib/media/media-utils.js'; import { getNextLocalUploadID } from 'lib/media/media-utils.js';
Show All 15 Lines
import type { CalendarQuery } from 'lib/types/entry-types.js'; import type { CalendarQuery } from 'lib/types/entry-types.js';
import type { import type {
UploadMultimediaResult, UploadMultimediaResult,
UploadMediaMetadataRequest, UploadMediaMetadataRequest,
MediaMissionStep, MediaMissionStep,
MediaMissionFailure, MediaMissionFailure,
MediaMissionResult, MediaMissionResult,
MediaMission, MediaMission,
Dimensions,
} from 'lib/types/media-types.js'; } from 'lib/types/media-types.js';
import { messageTypes } from 'lib/types/message-types-enum.js'; import { messageTypes } from 'lib/types/message-types-enum.js';
import { import {
type RawMessageInfo, type RawMessageInfo,
type RawMultimediaMessageInfo, type RawMultimediaMessageInfo,
type SendMessageResult, type SendMessageResult,
type SendMessagePayload, type SendMessagePayload,
} from 'lib/types/message-types.js'; } from 'lib/types/message-types.js';
Show All 9 Linesimport {
type ThreadInfo, type ThreadInfo,
type RawThreadInfo, type RawThreadInfo,
} from 'lib/types/thread-types.js'; } from 'lib/types/thread-types.js';
import { import {
type DispatchActionPromise, type DispatchActionPromise,
useServerCall, useServerCall,
useDispatchActionPromise, useDispatchActionPromise,
} from 'lib/utils/action-utils.js'; } from 'lib/utils/action-utils.js';
import { toBase64URL } from 'lib/utils/base64.js';
import { import {
makeBlobServiceEndpointURL, makeBlobServiceEndpointURL,
isBlobServiceURI, isBlobServiceURI,
blobHashFromBlobServiceURI, blobHashFromBlobServiceURI,
} from 'lib/utils/blob-service.js'; } from 'lib/utils/blob-service.js';
import type { CallServerEndpointOptions } from 'lib/utils/call-server-endpoint.js';
import { getConfig } from 'lib/utils/config.js'; import { getConfig } from 'lib/utils/config.js';
import { getMessageForException, cloneError } from 'lib/utils/errors.js'; import { getMessageForException, cloneError } from 'lib/utils/errors.js';
import { generateReportID } from 'lib/utils/report-utils.js'; import { generateReportID } from 'lib/utils/report-utils.js';
import { handleHTTPResponseError } from 'lib/utils/services-utils.js';
import { import {
type PendingMultimediaUpload, type PendingMultimediaUpload,
type TypeaheadState, type TypeaheadState,
InputStateContext, InputStateContext,
} from './input-state.js'; } from './input-state.js';
import { encryptFile } from '../media/encryption-utils.js'; import { encryptFile } from '../media/encryption-utils.js';
import { generateThumbHash } from '../media/image-utils.js'; import { generateThumbHash } from '../media/image-utils.js';
Show All 21 Linestype Props = {
+dispatch: Dispatch, +dispatch: Dispatch,
+dispatchActionPromise: DispatchActionPromise, +dispatchActionPromise: DispatchActionPromise,
+calendarQuery: () => CalendarQuery, +calendarQuery: () => CalendarQuery,
+uploadMultimedia: ( +uploadMultimedia: (
multimedia: Object, multimedia: Object,
extras: MultimediaUploadExtras, extras: MultimediaUploadExtras,
callbacks: MultimediaUploadCallbacks, callbacks: MultimediaUploadCallbacks,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+blobServiceUpload: BlobServiceUploadAction,
+uploadMediaMetadata: ( +uploadMediaMetadata: (
input: UploadMediaMetadataRequest, input: UploadMediaMetadataRequest,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+deleteUpload: (id: string) => Promise<void>, +deleteUpload: (id: string) => Promise<void>,
+sendMultimediaMessage: ( +sendMultimediaMessage: (
threadID: string, threadID: string,
localID: string, localID: string,
mediaIDs: $ReadOnlyArray<string>, mediaIDs: $ReadOnlyArray<string>,
▲ Show 20 Lines • Show All 729 Lines • ▼ Show 20 Lines try {
(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(
encryptionKey && blobHash && dimensions, encryptionKey && blobHash && dimensions,
'incomplete encrypted upload', 'incomplete encrypted upload',
); );
uploadResult = await this.blobServiceUpload( uploadResult = await this.props.blobServiceUpload({
{ input: {
blobInput: {
type: 'file',
file: upload.file, file: upload.file,
},
blobHash, blobHash,
encryptionKey, encryptionKey,
dimensions, dimensions,
loop: false, loop: false,
...(thumbHash ? { thumbHash } : undefined), thumbHash,
}, },
{ ...callbacks }, callbacks,
); });
} else { } else {
let uploadExtras = { let uploadExtras = {
...upload.dimensions, ...upload.dimensions,
loop: false, loop: false,
thumbHash: upload.thumbHash, thumbHash: upload.thumbHash,
}; };
if (encryptionKey) { if (encryptionKey) {
uploadExtras = { ...uploadExtras, encryptionKey }; uploadExtras = { ...uploadExtras, encryptionKey };
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines this.setState(prevState => {
loop: result.loop, loop: result.loop,
}, },
}, },
}, },
}; };
}); });
} }
async blobServiceUpload(
input: {
+file: File,
+blobHash: string,
+encryptionKey: string,
+dimensions: Dimensions,
+loop?: boolean,
+thumbHash?: string,
},
options?: ?CallServerEndpointOptions,
): Promise<{
...UploadMultimediaResult,
+blobHolder: string,
}> {
const blobHolder = uuid.v4();
const blobHash = toBase64URL(input.blobHash);
// 1. Assign new holder for blob with given blobHash
let blobAlreadyExists: boolean;
try {
const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(assignHolderEndpoint),
{
method: assignHolderEndpoint.method,
body: JSON.stringify({
holder: blobHolder,
blob_hash: blobHash,
}),
headers: {
'content-type': 'application/json',
},
},
);
handleHTTPResponseError(assignHolderResponse);
const { data_exists: dataExistsResponse } =
await assignHolderResponse.json();
blobAlreadyExists = dataExistsResponse;
} catch (e) {
throw new Error(
`Failed to assign holder: ${
getMessageForException(e) ?? 'unknown error'
}`,
);
}
// 2. Upload blob contents if blob doesn't exist
if (!blobAlreadyExists) {
const formData = new FormData();
formData.append('blob_hash', blobHash);
formData.append('blob_data', input.file);
const xhr = new XMLHttpRequest();
const uploadEndpoint = blobService.httpEndpoints.UPLOAD_BLOB;
xhr.open(
uploadEndpoint.method,
makeBlobServiceEndpointURL(uploadEndpoint),
);
if (options?.timeout) {
xhr.timeout = options.timeout;
}
if (options && options.onProgress) {
const { onProgress } = options;
xhr.upload.onprogress = _throttle(
({ loaded, total }) => onProgress(loaded / total),
50,
);
}
let failed = false;
const responsePromise = new Promise((resolve, reject) => {
xhr.onload = () => {
if (failed) {
return;
}
resolve();
};
xhr.onabort = () => {
failed = true;
reject(new Error('request aborted'));
};
xhr.onerror = event => {
failed = true;
reject(event);
};
if (options && options.timeout) {
xhr.ontimeout = event => {
failed = true;
reject(event);
};
}
if (options && options.abortHandler) {
options.abortHandler(() => {
failed = true;
reject(new Error('request aborted'));
xhr.abort();
});
}
});
if (!failed) {
xhr.send(formData);
}
await responsePromise;
}
// 3. Send upload metadata to the keyserver, return response
const result = await this.props.uploadMediaMetadata({
...input.dimensions,
loop: input.loop ?? false,
blobHolder,
blobHash,
encryptionKey: input.encryptionKey,
mimeType: input.file.type,
filename: input.file.name,
thumbHash: input.thumbHash,
});
return { ...result, blobHolder };
}
handleAbortCallback( handleAbortCallback(
threadID: string, threadID: string,
localUploadID: string, localUploadID: string,
abort: () => void, abort: () => void,
) { ) {
this.setState(prevState => { this.setState(prevState => {
const newThreadID = this.getRealizedOrPendingThreadID(threadID); const newThreadID = this.getRealizedOrPendingThreadID(threadID);
const uploads = prevState.pendingUploads[newThreadID]; const uploads = prevState.pendingUploads[newThreadID];
▲ Show 20 Lines • Show All 533 Lines • ▼ Show 20 Lines React.memo<BaseProps>(function ConnectedInputStateContainer(props) {
const threadStoreThreadInfos = useSelector( const threadStoreThreadInfos = useSelector(
state => state.threadStore.threadInfos, state => state.threadStore.threadInfos,
); );
const pendingToRealizedThreadIDs = useSelector(state => const pendingToRealizedThreadIDs = useSelector(state =>
pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos), pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
); );
const calendarQuery = useSelector(nonThreadCalendarQuery); const calendarQuery = useSelector(nonThreadCalendarQuery);
const callUploadMultimedia = useServerCall(uploadMultimedia); const callUploadMultimedia = useServerCall(uploadMultimedia);
const callBlobServiceUpload = useServerCall(blobServiceUpload);
const callUploadMediaMetadata = useServerCall(uploadMediaMetadata); const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);
const callDeleteUpload = useServerCall(deleteUpload); const callDeleteUpload = useServerCall(deleteUpload);
const callSendMultimediaMessage = useServerCall( const callSendMultimediaMessage = useServerCall(
legacySendMultimediaMessage, legacySendMultimediaMessage,
); );
const callSendTextMessage = useServerCall(sendTextMessage); const callSendTextMessage = useServerCall(sendTextMessage);
const callNewThread = useServerCall(newThread); const callNewThread = useServerCall(newThread);
const dispatch = useDispatch(); const dispatch = useDispatch();
Show All 24 Lines return (
drafts={drafts} drafts={drafts}
viewerID={viewerID} viewerID={viewerID}
messageStoreMessages={messageStoreMessages} messageStoreMessages={messageStoreMessages}
threadStoreThreadInfos={threadStoreThreadInfos} threadStoreThreadInfos={threadStoreThreadInfos}
pendingRealizedThreadIDs={pendingToRealizedThreadIDs} pendingRealizedThreadIDs={pendingToRealizedThreadIDs}
calendarQuery={calendarQuery} calendarQuery={calendarQuery}
uploadMultimedia={callUploadMultimedia} uploadMultimedia={callUploadMultimedia}
uploadMediaMetadata={callUploadMediaMetadata} uploadMediaMetadata={callUploadMediaMetadata}
blobServiceUpload={callBlobServiceUpload}
deleteUpload={callDeleteUpload} deleteUpload={callDeleteUpload}
sendMultimediaMessage={callSendMultimediaMessage} sendMultimediaMessage={callSendMultimediaMessage}
sendTextMessage={callSendTextMessage} sendTextMessage={callSendTextMessage}
newThread={callNewThread} newThread={callNewThread}
dispatch={dispatch} dispatch={dispatch}
dispatchActionPromise={dispatchActionPromise} dispatchActionPromise={dispatchActionPromise}
pushModal={modalContext.pushModal} pushModal={modalContext.pushModal}
sendCallbacks={sendCallbacks} sendCallbacks={sendCallbacks}
registerSendCallback={registerSendCallback} registerSendCallback={registerSendCallback}
unregisterSendCallback={unregisterSendCallback} unregisterSendCallback={unregisterSendCallback}
textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc} textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
/> />
); );
}); });
export default ConnectedInputStateContainer; export default ConnectedInputStateContainer;
View Options

services/identity/Cargo.toml

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _groupBy from 'lodash/fp/groupBy.js'; import _groupBy from 'lodash/fp/groupBy.js';
import _keyBy from 'lodash/fp/keyBy.js'; import _keyBy from 'lodash/fp/keyBy.js';
import _omit from 'lodash/fp/omit.js'; import _omit from 'lodash/fp/omit.js';
import _partition from 'lodash/fp/partition.js'; import _partition from 'lodash/fp/partition.js';
import _sortBy from 'lodash/fp/sortBy.js'; import _sortBy from 'lodash/fp/sortBy.js';
import _memoize from 'lodash/memoize.js'; import _memoize from 'lodash/memoize.js';
import _throttle from 'lodash/throttle.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect'; import { createSelector } from 'reselect';
import uuid from 'uuid';
import { import {
createLocalMessageActionType, createLocalMessageActionType,
sendMultimediaMessageActionTypes, sendMultimediaMessageActionTypes,
legacySendMultimediaMessage, legacySendMultimediaMessage,
sendTextMessageActionTypes, sendTextMessageActionTypes,
sendTextMessage, sendTextMessage,
} from 'lib/actions/message-actions.js'; } from 'lib/actions/message-actions.js';
import { queueReportsActionType } from 'lib/actions/report-actions.js'; import { queueReportsActionType } from 'lib/actions/report-actions.js';
import { newThread } from 'lib/actions/thread-actions.js'; import { newThread } from 'lib/actions/thread-actions.js';
import { import {
uploadMultimedia, uploadMultimedia,
uploadMediaMetadata, uploadMediaMetadata,
updateMultimediaMessageMediaActionType, updateMultimediaMessageMediaActionType,
deleteUpload, deleteUpload,
blobServiceUpload,
type MultimediaUploadCallbacks, type MultimediaUploadCallbacks,
type MultimediaUploadExtras, type MultimediaUploadExtras,
type BlobServiceUploadAction,
} from 'lib/actions/upload-actions.js'; } from 'lib/actions/upload-actions.js';
import { import {
useModalContext, useModalContext,
type PushModal, type PushModal,
} from 'lib/components/modal-provider.react.js'; } from 'lib/components/modal-provider.react.js';
import blobService from 'lib/facts/blob-service.js'; import blobService from 'lib/facts/blob-service.js';
import commStaffCommunity from 'lib/facts/comm-staff-community.js'; import commStaffCommunity from 'lib/facts/comm-staff-community.js';
import { getNextLocalUploadID } from 'lib/media/media-utils.js'; import { getNextLocalUploadID } from 'lib/media/media-utils.js';
Show All 15 Lines
import type { CalendarQuery } from 'lib/types/entry-types.js'; import type { CalendarQuery } from 'lib/types/entry-types.js';
import type { import type {
UploadMultimediaResult, UploadMultimediaResult,
UploadMediaMetadataRequest, UploadMediaMetadataRequest,
MediaMissionStep, MediaMissionStep,
MediaMissionFailure, MediaMissionFailure,
MediaMissionResult, MediaMissionResult,
MediaMission, MediaMission,
Dimensions,
} from 'lib/types/media-types.js'; } from 'lib/types/media-types.js';
import { messageTypes } from 'lib/types/message-types-enum.js'; import { messageTypes } from 'lib/types/message-types-enum.js';
import { import {
type RawMessageInfo, type RawMessageInfo,
type RawMultimediaMessageInfo, type RawMultimediaMessageInfo,
type SendMessageResult, type SendMessageResult,
type SendMessagePayload, type SendMessagePayload,
} from 'lib/types/message-types.js'; } from 'lib/types/message-types.js';
Show All 9 Linesimport {
type ThreadInfo, type ThreadInfo,
type RawThreadInfo, type RawThreadInfo,
} from 'lib/types/thread-types.js'; } from 'lib/types/thread-types.js';
import { import {
type DispatchActionPromise, type DispatchActionPromise,
useServerCall, useServerCall,
useDispatchActionPromise, useDispatchActionPromise,
} from 'lib/utils/action-utils.js'; } from 'lib/utils/action-utils.js';
import { toBase64URL } from 'lib/utils/base64.js';
import { import {
makeBlobServiceEndpointURL, makeBlobServiceEndpointURL,
isBlobServiceURI, isBlobServiceURI,
blobHashFromBlobServiceURI, blobHashFromBlobServiceURI,
} from 'lib/utils/blob-service.js'; } from 'lib/utils/blob-service.js';
import type { CallServerEndpointOptions } from 'lib/utils/call-server-endpoint.js';
import { getConfig } from 'lib/utils/config.js'; import { getConfig } from 'lib/utils/config.js';
import { getMessageForException, cloneError } from 'lib/utils/errors.js'; import { getMessageForException, cloneError } from 'lib/utils/errors.js';
import { generateReportID } from 'lib/utils/report-utils.js'; import { generateReportID } from 'lib/utils/report-utils.js';
import { handleHTTPResponseError } from 'lib/utils/services-utils.js';
import { import {
type PendingMultimediaUpload, type PendingMultimediaUpload,
type TypeaheadState, type TypeaheadState,
InputStateContext, InputStateContext,
} from './input-state.js'; } from './input-state.js';
import { encryptFile } from '../media/encryption-utils.js'; import { encryptFile } from '../media/encryption-utils.js';
import { generateThumbHash } from '../media/image-utils.js'; import { generateThumbHash } from '../media/image-utils.js';
Show All 21 Linestype Props = {
+dispatch: Dispatch, +dispatch: Dispatch,
+dispatchActionPromise: DispatchActionPromise, +dispatchActionPromise: DispatchActionPromise,
+calendarQuery: () => CalendarQuery, +calendarQuery: () => CalendarQuery,
+uploadMultimedia: ( +uploadMultimedia: (
multimedia: Object, multimedia: Object,
extras: MultimediaUploadExtras, extras: MultimediaUploadExtras,
callbacks: MultimediaUploadCallbacks, callbacks: MultimediaUploadCallbacks,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+blobServiceUpload: BlobServiceUploadAction,
+uploadMediaMetadata: ( +uploadMediaMetadata: (
input: UploadMediaMetadataRequest, input: UploadMediaMetadataRequest,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+deleteUpload: (id: string) => Promise<void>, +deleteUpload: (id: string) => Promise<void>,
+sendMultimediaMessage: ( +sendMultimediaMessage: (
threadID: string, threadID: string,
localID: string, localID: string,
mediaIDs: $ReadOnlyArray<string>, mediaIDs: $ReadOnlyArray<string>,
▲ Show 20 Lines • Show All 729 Lines • ▼ Show 20 Lines try {
(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(
encryptionKey && blobHash && dimensions, encryptionKey && blobHash && dimensions,
'incomplete encrypted upload', 'incomplete encrypted upload',
); );
uploadResult = await this.blobServiceUpload( uploadResult = await this.props.blobServiceUpload({
{ input: {
blobInput: {
type: 'file',
file: upload.file, file: upload.file,
},
blobHash, blobHash,
encryptionKey, encryptionKey,
dimensions, dimensions,
loop: false, loop: false,
...(thumbHash ? { thumbHash } : undefined), thumbHash,
}, },
{ ...callbacks }, callbacks,
); });
} else { } else {
let uploadExtras = { let uploadExtras = {
...upload.dimensions, ...upload.dimensions,
loop: false, loop: false,
thumbHash: upload.thumbHash, thumbHash: upload.thumbHash,
}; };
if (encryptionKey) { if (encryptionKey) {
uploadExtras = { ...uploadExtras, encryptionKey }; uploadExtras = { ...uploadExtras, encryptionKey };
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines this.setState(prevState => {
loop: result.loop, loop: result.loop,
}, },
}, },
}, },
}; };
}); });
} }
async blobServiceUpload(
input: {
+file: File,
+blobHash: string,
+encryptionKey: string,
+dimensions: Dimensions,
+loop?: boolean,
+thumbHash?: string,
},
options?: ?CallServerEndpointOptions,
): Promise<{
...UploadMultimediaResult,
+blobHolder: string,
}> {
const blobHolder = uuid.v4();
const blobHash = toBase64URL(input.blobHash);
// 1. Assign new holder for blob with given blobHash
let blobAlreadyExists: boolean;
try {
const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(assignHolderEndpoint),
{
method: assignHolderEndpoint.method,
body: JSON.stringify({
holder: blobHolder,
blob_hash: blobHash,
}),
headers: {
'content-type': 'application/json',
},
},
);
handleHTTPResponseError(assignHolderResponse);
const { data_exists: dataExistsResponse } =
await assignHolderResponse.json();
blobAlreadyExists = dataExistsResponse;
} catch (e) {
throw new Error(
`Failed to assign holder: ${
getMessageForException(e) ?? 'unknown error'
}`,
);
}
// 2. Upload blob contents if blob doesn't exist
if (!blobAlreadyExists) {
const formData = new FormData();
formData.append('blob_hash', blobHash);
formData.append('blob_data', input.file);
const xhr = new XMLHttpRequest();
const uploadEndpoint = blobService.httpEndpoints.UPLOAD_BLOB;
xhr.open(
uploadEndpoint.method,
makeBlobServiceEndpointURL(uploadEndpoint),
);
if (options?.timeout) {
xhr.timeout = options.timeout;
}
if (options && options.onProgress) {
const { onProgress } = options;
xhr.upload.onprogress = _throttle(
({ loaded, total }) => onProgress(loaded / total),
50,
);
}
let failed = false;
const responsePromise = new Promise((resolve, reject) => {
xhr.onload = () => {
if (failed) {
return;
}
resolve();
};
xhr.onabort = () => {
failed = true;
reject(new Error('request aborted'));
};
xhr.onerror = event => {
failed = true;
reject(event);
};
if (options && options.timeout) {
xhr.ontimeout = event => {
failed = true;
reject(event);
};
}
if (options && options.abortHandler) {
options.abortHandler(() => {
failed = true;
reject(new Error('request aborted'));
xhr.abort();
});
}
});
if (!failed) {
xhr.send(formData);
}
await responsePromise;
}
// 3. Send upload metadata to the keyserver, return response
const result = await this.props.uploadMediaMetadata({
...input.dimensions,
loop: input.loop ?? false,
blobHolder,
blobHash,
encryptionKey: input.encryptionKey,
mimeType: input.file.type,
filename: input.file.name,
thumbHash: input.thumbHash,
});
return { ...result, blobHolder };
}
handleAbortCallback( handleAbortCallback(
threadID: string, threadID: string,
localUploadID: string, localUploadID: string,
abort: () => void, abort: () => void,
) { ) {
this.setState(prevState => { this.setState(prevState => {
const newThreadID = this.getRealizedOrPendingThreadID(threadID); const newThreadID = this.getRealizedOrPendingThreadID(threadID);
const uploads = prevState.pendingUploads[newThreadID]; const uploads = prevState.pendingUploads[newThreadID];
▲ Show 20 Lines • Show All 533 Lines • ▼ Show 20 Lines React.memo<BaseProps>(function ConnectedInputStateContainer(props) {
const threadStoreThreadInfos = useSelector( const threadStoreThreadInfos = useSelector(
state => state.threadStore.threadInfos, state => state.threadStore.threadInfos,
); );
const pendingToRealizedThreadIDs = useSelector(state => const pendingToRealizedThreadIDs = useSelector(state =>
pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos), pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
); );
const calendarQuery = useSelector(nonThreadCalendarQuery); const calendarQuery = useSelector(nonThreadCalendarQuery);
const callUploadMultimedia = useServerCall(uploadMultimedia); const callUploadMultimedia = useServerCall(uploadMultimedia);
const callBlobServiceUpload = useServerCall(blobServiceUpload);
const callUploadMediaMetadata = useServerCall(uploadMediaMetadata); const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);
const callDeleteUpload = useServerCall(deleteUpload); const callDeleteUpload = useServerCall(deleteUpload);
const callSendMultimediaMessage = useServerCall( const callSendMultimediaMessage = useServerCall(
legacySendMultimediaMessage, legacySendMultimediaMessage,
); );
const callSendTextMessage = useServerCall(sendTextMessage); const callSendTextMessage = useServerCall(sendTextMessage);
const callNewThread = useServerCall(newThread); const callNewThread = useServerCall(newThread);
const dispatch = useDispatch(); const dispatch = useDispatch();
Show All 24 Lines return (
drafts={drafts} drafts={drafts}
viewerID={viewerID} viewerID={viewerID}
messageStoreMessages={messageStoreMessages} messageStoreMessages={messageStoreMessages}
threadStoreThreadInfos={threadStoreThreadInfos} threadStoreThreadInfos={threadStoreThreadInfos}
pendingRealizedThreadIDs={pendingToRealizedThreadIDs} pendingRealizedThreadIDs={pendingToRealizedThreadIDs}
calendarQuery={calendarQuery} calendarQuery={calendarQuery}
uploadMultimedia={callUploadMultimedia} uploadMultimedia={callUploadMultimedia}
uploadMediaMetadata={callUploadMediaMetadata} uploadMediaMetadata={callUploadMediaMetadata}
blobServiceUpload={callBlobServiceUpload}
deleteUpload={callDeleteUpload} deleteUpload={callDeleteUpload}
sendMultimediaMessage={callSendMultimediaMessage} sendMultimediaMessage={callSendMultimediaMessage}
sendTextMessage={callSendTextMessage} sendTextMessage={callSendTextMessage}
newThread={callNewThread} newThread={callNewThread}
dispatch={dispatch} dispatch={dispatch}
dispatchActionPromise={dispatchActionPromise} dispatchActionPromise={dispatchActionPromise}
pushModal={modalContext.pushModal} pushModal={modalContext.pushModal}
sendCallbacks={sendCallbacks} sendCallbacks={sendCallbacks}
registerSendCallback={registerSendCallback} registerSendCallback={registerSendCallback}
unregisterSendCallback={unregisterSendCallback} unregisterSendCallback={unregisterSendCallback}
textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc} textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
/> />
); );
}); });
export default ConnectedInputStateContainer; export default ConnectedInputStateContainer;
View Options

services/identity/src/main.rs

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _groupBy from 'lodash/fp/groupBy.js'; import _groupBy from 'lodash/fp/groupBy.js';
import _keyBy from 'lodash/fp/keyBy.js'; import _keyBy from 'lodash/fp/keyBy.js';
import _omit from 'lodash/fp/omit.js'; import _omit from 'lodash/fp/omit.js';
import _partition from 'lodash/fp/partition.js'; import _partition from 'lodash/fp/partition.js';
import _sortBy from 'lodash/fp/sortBy.js'; import _sortBy from 'lodash/fp/sortBy.js';
import _memoize from 'lodash/memoize.js'; import _memoize from 'lodash/memoize.js';
import _throttle from 'lodash/throttle.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect'; import { createSelector } from 'reselect';
import uuid from 'uuid';
import { import {
createLocalMessageActionType, createLocalMessageActionType,
sendMultimediaMessageActionTypes, sendMultimediaMessageActionTypes,
legacySendMultimediaMessage, legacySendMultimediaMessage,
sendTextMessageActionTypes, sendTextMessageActionTypes,
sendTextMessage, sendTextMessage,
} from 'lib/actions/message-actions.js'; } from 'lib/actions/message-actions.js';
import { queueReportsActionType } from 'lib/actions/report-actions.js'; import { queueReportsActionType } from 'lib/actions/report-actions.js';
import { newThread } from 'lib/actions/thread-actions.js'; import { newThread } from 'lib/actions/thread-actions.js';
import { import {
uploadMultimedia, uploadMultimedia,
uploadMediaMetadata, uploadMediaMetadata,
updateMultimediaMessageMediaActionType, updateMultimediaMessageMediaActionType,
deleteUpload, deleteUpload,
blobServiceUpload,
type MultimediaUploadCallbacks, type MultimediaUploadCallbacks,
type MultimediaUploadExtras, type MultimediaUploadExtras,
type BlobServiceUploadAction,
} from 'lib/actions/upload-actions.js'; } from 'lib/actions/upload-actions.js';
import { import {
useModalContext, useModalContext,
type PushModal, type PushModal,
} from 'lib/components/modal-provider.react.js'; } from 'lib/components/modal-provider.react.js';
import blobService from 'lib/facts/blob-service.js'; import blobService from 'lib/facts/blob-service.js';
import commStaffCommunity from 'lib/facts/comm-staff-community.js'; import commStaffCommunity from 'lib/facts/comm-staff-community.js';
import { getNextLocalUploadID } from 'lib/media/media-utils.js'; import { getNextLocalUploadID } from 'lib/media/media-utils.js';
Show All 15 Lines
import type { CalendarQuery } from 'lib/types/entry-types.js'; import type { CalendarQuery } from 'lib/types/entry-types.js';
import type { import type {
UploadMultimediaResult, UploadMultimediaResult,
UploadMediaMetadataRequest, UploadMediaMetadataRequest,
MediaMissionStep, MediaMissionStep,
MediaMissionFailure, MediaMissionFailure,
MediaMissionResult, MediaMissionResult,
MediaMission, MediaMission,
Dimensions,
} from 'lib/types/media-types.js'; } from 'lib/types/media-types.js';
import { messageTypes } from 'lib/types/message-types-enum.js'; import { messageTypes } from 'lib/types/message-types-enum.js';
import { import {
type RawMessageInfo, type RawMessageInfo,
type RawMultimediaMessageInfo, type RawMultimediaMessageInfo,
type SendMessageResult, type SendMessageResult,
type SendMessagePayload, type SendMessagePayload,
} from 'lib/types/message-types.js'; } from 'lib/types/message-types.js';
Show All 9 Linesimport {
type ThreadInfo, type ThreadInfo,
type RawThreadInfo, type RawThreadInfo,
} from 'lib/types/thread-types.js'; } from 'lib/types/thread-types.js';
import { import {
type DispatchActionPromise, type DispatchActionPromise,
useServerCall, useServerCall,
useDispatchActionPromise, useDispatchActionPromise,
} from 'lib/utils/action-utils.js'; } from 'lib/utils/action-utils.js';
import { toBase64URL } from 'lib/utils/base64.js';
import { import {
makeBlobServiceEndpointURL, makeBlobServiceEndpointURL,
isBlobServiceURI, isBlobServiceURI,
blobHashFromBlobServiceURI, blobHashFromBlobServiceURI,
} from 'lib/utils/blob-service.js'; } from 'lib/utils/blob-service.js';
import type { CallServerEndpointOptions } from 'lib/utils/call-server-endpoint.js';
import { getConfig } from 'lib/utils/config.js'; import { getConfig } from 'lib/utils/config.js';
import { getMessageForException, cloneError } from 'lib/utils/errors.js'; import { getMessageForException, cloneError } from 'lib/utils/errors.js';
import { generateReportID } from 'lib/utils/report-utils.js'; import { generateReportID } from 'lib/utils/report-utils.js';
import { handleHTTPResponseError } from 'lib/utils/services-utils.js';
import { import {
type PendingMultimediaUpload, type PendingMultimediaUpload,
type TypeaheadState, type TypeaheadState,
InputStateContext, InputStateContext,
} from './input-state.js'; } from './input-state.js';
import { encryptFile } from '../media/encryption-utils.js'; import { encryptFile } from '../media/encryption-utils.js';
import { generateThumbHash } from '../media/image-utils.js'; import { generateThumbHash } from '../media/image-utils.js';
Show All 21 Linestype Props = {
+dispatch: Dispatch, +dispatch: Dispatch,
+dispatchActionPromise: DispatchActionPromise, +dispatchActionPromise: DispatchActionPromise,
+calendarQuery: () => CalendarQuery, +calendarQuery: () => CalendarQuery,
+uploadMultimedia: ( +uploadMultimedia: (
multimedia: Object, multimedia: Object,
extras: MultimediaUploadExtras, extras: MultimediaUploadExtras,
callbacks: MultimediaUploadCallbacks, callbacks: MultimediaUploadCallbacks,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+blobServiceUpload: BlobServiceUploadAction,
+uploadMediaMetadata: ( +uploadMediaMetadata: (
input: UploadMediaMetadataRequest, input: UploadMediaMetadataRequest,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+deleteUpload: (id: string) => Promise<void>, +deleteUpload: (id: string) => Promise<void>,
+sendMultimediaMessage: ( +sendMultimediaMessage: (
threadID: string, threadID: string,
localID: string, localID: string,
mediaIDs: $ReadOnlyArray<string>, mediaIDs: $ReadOnlyArray<string>,
▲ Show 20 Lines • Show All 729 Lines • ▼ Show 20 Lines try {
(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(
encryptionKey && blobHash && dimensions, encryptionKey && blobHash && dimensions,
'incomplete encrypted upload', 'incomplete encrypted upload',
); );
uploadResult = await this.blobServiceUpload( uploadResult = await this.props.blobServiceUpload({
{ input: {
blobInput: {
type: 'file',
file: upload.file, file: upload.file,
},
blobHash, blobHash,
encryptionKey, encryptionKey,
dimensions, dimensions,
loop: false, loop: false,
...(thumbHash ? { thumbHash } : undefined), thumbHash,
}, },
{ ...callbacks }, callbacks,
); });
} else { } else {
let uploadExtras = { let uploadExtras = {
...upload.dimensions, ...upload.dimensions,
loop: false, loop: false,
thumbHash: upload.thumbHash, thumbHash: upload.thumbHash,
}; };
if (encryptionKey) { if (encryptionKey) {
uploadExtras = { ...uploadExtras, encryptionKey }; uploadExtras = { ...uploadExtras, encryptionKey };
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines this.setState(prevState => {
loop: result.loop, loop: result.loop,
}, },
}, },
}, },
}; };
}); });
} }
async blobServiceUpload(
input: {
+file: File,
+blobHash: string,
+encryptionKey: string,
+dimensions: Dimensions,
+loop?: boolean,
+thumbHash?: string,
},
options?: ?CallServerEndpointOptions,
): Promise<{
...UploadMultimediaResult,
+blobHolder: string,
}> {
const blobHolder = uuid.v4();
const blobHash = toBase64URL(input.blobHash);
// 1. Assign new holder for blob with given blobHash
let blobAlreadyExists: boolean;
try {
const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(assignHolderEndpoint),
{
method: assignHolderEndpoint.method,
body: JSON.stringify({
holder: blobHolder,
blob_hash: blobHash,
}),
headers: {
'content-type': 'application/json',
},
},
);
handleHTTPResponseError(assignHolderResponse);
const { data_exists: dataExistsResponse } =
await assignHolderResponse.json();
blobAlreadyExists = dataExistsResponse;
} catch (e) {
throw new Error(
`Failed to assign holder: ${
getMessageForException(e) ?? 'unknown error'
}`,
);
}
// 2. Upload blob contents if blob doesn't exist
if (!blobAlreadyExists) {
const formData = new FormData();
formData.append('blob_hash', blobHash);
formData.append('blob_data', input.file);
const xhr = new XMLHttpRequest();
const uploadEndpoint = blobService.httpEndpoints.UPLOAD_BLOB;
xhr.open(
uploadEndpoint.method,
makeBlobServiceEndpointURL(uploadEndpoint),
);
if (options?.timeout) {
xhr.timeout = options.timeout;
}
if (options && options.onProgress) {
const { onProgress } = options;
xhr.upload.onprogress = _throttle(
({ loaded, total }) => onProgress(loaded / total),
50,
);
}
let failed = false;
const responsePromise = new Promise((resolve, reject) => {
xhr.onload = () => {
if (failed) {
return;
}
resolve();
};
xhr.onabort = () => {
failed = true;
reject(new Error('request aborted'));
};
xhr.onerror = event => {
failed = true;
reject(event);
};
if (options && options.timeout) {
xhr.ontimeout = event => {
failed = true;
reject(event);
};
}
if (options && options.abortHandler) {
options.abortHandler(() => {
failed = true;
reject(new Error('request aborted'));
xhr.abort();
});
}
});
if (!failed) {
xhr.send(formData);
}
await responsePromise;
}
// 3. Send upload metadata to the keyserver, return response
const result = await this.props.uploadMediaMetadata({
...input.dimensions,
loop: input.loop ?? false,
blobHolder,
blobHash,
encryptionKey: input.encryptionKey,
mimeType: input.file.type,
filename: input.file.name,
thumbHash: input.thumbHash,
});
return { ...result, blobHolder };
}
handleAbortCallback( handleAbortCallback(
threadID: string, threadID: string,
localUploadID: string, localUploadID: string,
abort: () => void, abort: () => void,
) { ) {
this.setState(prevState => { this.setState(prevState => {
const newThreadID = this.getRealizedOrPendingThreadID(threadID); const newThreadID = this.getRealizedOrPendingThreadID(threadID);
const uploads = prevState.pendingUploads[newThreadID]; const uploads = prevState.pendingUploads[newThreadID];
▲ Show 20 Lines • Show All 533 Lines • ▼ Show 20 Lines React.memo<BaseProps>(function ConnectedInputStateContainer(props) {
const threadStoreThreadInfos = useSelector( const threadStoreThreadInfos = useSelector(
state => state.threadStore.threadInfos, state => state.threadStore.threadInfos,
); );
const pendingToRealizedThreadIDs = useSelector(state => const pendingToRealizedThreadIDs = useSelector(state =>
pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos), pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
); );
const calendarQuery = useSelector(nonThreadCalendarQuery); const calendarQuery = useSelector(nonThreadCalendarQuery);
const callUploadMultimedia = useServerCall(uploadMultimedia); const callUploadMultimedia = useServerCall(uploadMultimedia);
const callBlobServiceUpload = useServerCall(blobServiceUpload);
const callUploadMediaMetadata = useServerCall(uploadMediaMetadata); const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);
const callDeleteUpload = useServerCall(deleteUpload); const callDeleteUpload = useServerCall(deleteUpload);
const callSendMultimediaMessage = useServerCall( const callSendMultimediaMessage = useServerCall(
legacySendMultimediaMessage, legacySendMultimediaMessage,
); );
const callSendTextMessage = useServerCall(sendTextMessage); const callSendTextMessage = useServerCall(sendTextMessage);
const callNewThread = useServerCall(newThread); const callNewThread = useServerCall(newThread);
const dispatch = useDispatch(); const dispatch = useDispatch();
Show All 24 Lines return (
drafts={drafts} drafts={drafts}
viewerID={viewerID} viewerID={viewerID}
messageStoreMessages={messageStoreMessages} messageStoreMessages={messageStoreMessages}
threadStoreThreadInfos={threadStoreThreadInfos} threadStoreThreadInfos={threadStoreThreadInfos}
pendingRealizedThreadIDs={pendingToRealizedThreadIDs} pendingRealizedThreadIDs={pendingToRealizedThreadIDs}
calendarQuery={calendarQuery} calendarQuery={calendarQuery}
uploadMultimedia={callUploadMultimedia} uploadMultimedia={callUploadMultimedia}
uploadMediaMetadata={callUploadMediaMetadata} uploadMediaMetadata={callUploadMediaMetadata}
blobServiceUpload={callBlobServiceUpload}
deleteUpload={callDeleteUpload} deleteUpload={callDeleteUpload}
sendMultimediaMessage={callSendMultimediaMessage} sendMultimediaMessage={callSendMultimediaMessage}
sendTextMessage={callSendTextMessage} sendTextMessage={callSendTextMessage}
newThread={callNewThread} newThread={callNewThread}
dispatch={dispatch} dispatch={dispatch}
dispatchActionPromise={dispatchActionPromise} dispatchActionPromise={dispatchActionPromise}
pushModal={modalContext.pushModal} pushModal={modalContext.pushModal}
sendCallbacks={sendCallbacks} sendCallbacks={sendCallbacks}
registerSendCallback={registerSendCallback} registerSendCallback={registerSendCallback}
unregisterSendCallback={unregisterSendCallback} unregisterSendCallback={unregisterSendCallback}
textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc} textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
/> />
); );
}); });
export default ConnectedInputStateContainer; export default ConnectedInputStateContainer;
View Options

services/identity/src/token.rs

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _groupBy from 'lodash/fp/groupBy.js'; import _groupBy from 'lodash/fp/groupBy.js';
import _keyBy from 'lodash/fp/keyBy.js'; import _keyBy from 'lodash/fp/keyBy.js';
import _omit from 'lodash/fp/omit.js'; import _omit from 'lodash/fp/omit.js';
import _partition from 'lodash/fp/partition.js'; import _partition from 'lodash/fp/partition.js';
import _sortBy from 'lodash/fp/sortBy.js'; import _sortBy from 'lodash/fp/sortBy.js';
import _memoize from 'lodash/memoize.js'; import _memoize from 'lodash/memoize.js';
import _throttle from 'lodash/throttle.js';
import * as React from 'react'; import * as React from 'react';
import { useDispatch } from 'react-redux'; import { useDispatch } from 'react-redux';
import { createSelector } from 'reselect'; import { createSelector } from 'reselect';
import uuid from 'uuid';
import { import {
createLocalMessageActionType, createLocalMessageActionType,
sendMultimediaMessageActionTypes, sendMultimediaMessageActionTypes,
legacySendMultimediaMessage, legacySendMultimediaMessage,
sendTextMessageActionTypes, sendTextMessageActionTypes,
sendTextMessage, sendTextMessage,
} from 'lib/actions/message-actions.js'; } from 'lib/actions/message-actions.js';
import { queueReportsActionType } from 'lib/actions/report-actions.js'; import { queueReportsActionType } from 'lib/actions/report-actions.js';
import { newThread } from 'lib/actions/thread-actions.js'; import { newThread } from 'lib/actions/thread-actions.js';
import { import {
uploadMultimedia, uploadMultimedia,
uploadMediaMetadata, uploadMediaMetadata,
updateMultimediaMessageMediaActionType, updateMultimediaMessageMediaActionType,
deleteUpload, deleteUpload,
blobServiceUpload,
type MultimediaUploadCallbacks, type MultimediaUploadCallbacks,
type MultimediaUploadExtras, type MultimediaUploadExtras,
type BlobServiceUploadAction,
} from 'lib/actions/upload-actions.js'; } from 'lib/actions/upload-actions.js';
import { import {
useModalContext, useModalContext,
type PushModal, type PushModal,
} from 'lib/components/modal-provider.react.js'; } from 'lib/components/modal-provider.react.js';
import blobService from 'lib/facts/blob-service.js'; import blobService from 'lib/facts/blob-service.js';
import commStaffCommunity from 'lib/facts/comm-staff-community.js'; import commStaffCommunity from 'lib/facts/comm-staff-community.js';
import { getNextLocalUploadID } from 'lib/media/media-utils.js'; import { getNextLocalUploadID } from 'lib/media/media-utils.js';
Show All 15 Lines
import type { CalendarQuery } from 'lib/types/entry-types.js'; import type { CalendarQuery } from 'lib/types/entry-types.js';
import type { import type {
UploadMultimediaResult, UploadMultimediaResult,
UploadMediaMetadataRequest, UploadMediaMetadataRequest,
MediaMissionStep, MediaMissionStep,
MediaMissionFailure, MediaMissionFailure,
MediaMissionResult, MediaMissionResult,
MediaMission, MediaMission,
Dimensions,
} from 'lib/types/media-types.js'; } from 'lib/types/media-types.js';
import { messageTypes } from 'lib/types/message-types-enum.js'; import { messageTypes } from 'lib/types/message-types-enum.js';
import { import {
type RawMessageInfo, type RawMessageInfo,
type RawMultimediaMessageInfo, type RawMultimediaMessageInfo,
type SendMessageResult, type SendMessageResult,
type SendMessagePayload, type SendMessagePayload,
} from 'lib/types/message-types.js'; } from 'lib/types/message-types.js';
Show All 9 Linesimport {
type ThreadInfo, type ThreadInfo,
type RawThreadInfo, type RawThreadInfo,
} from 'lib/types/thread-types.js'; } from 'lib/types/thread-types.js';
import { import {
type DispatchActionPromise, type DispatchActionPromise,
useServerCall, useServerCall,
useDispatchActionPromise, useDispatchActionPromise,
} from 'lib/utils/action-utils.js'; } from 'lib/utils/action-utils.js';
import { toBase64URL } from 'lib/utils/base64.js';
import { import {
makeBlobServiceEndpointURL, makeBlobServiceEndpointURL,
isBlobServiceURI, isBlobServiceURI,
blobHashFromBlobServiceURI, blobHashFromBlobServiceURI,
} from 'lib/utils/blob-service.js'; } from 'lib/utils/blob-service.js';
import type { CallServerEndpointOptions } from 'lib/utils/call-server-endpoint.js';
import { getConfig } from 'lib/utils/config.js'; import { getConfig } from 'lib/utils/config.js';
import { getMessageForException, cloneError } from 'lib/utils/errors.js'; import { getMessageForException, cloneError } from 'lib/utils/errors.js';
import { generateReportID } from 'lib/utils/report-utils.js'; import { generateReportID } from 'lib/utils/report-utils.js';
import { handleHTTPResponseError } from 'lib/utils/services-utils.js';
import { import {
type PendingMultimediaUpload, type PendingMultimediaUpload,
type TypeaheadState, type TypeaheadState,
InputStateContext, InputStateContext,
} from './input-state.js'; } from './input-state.js';
import { encryptFile } from '../media/encryption-utils.js'; import { encryptFile } from '../media/encryption-utils.js';
import { generateThumbHash } from '../media/image-utils.js'; import { generateThumbHash } from '../media/image-utils.js';
Show All 21 Linestype Props = {
+dispatch: Dispatch, +dispatch: Dispatch,
+dispatchActionPromise: DispatchActionPromise, +dispatchActionPromise: DispatchActionPromise,
+calendarQuery: () => CalendarQuery, +calendarQuery: () => CalendarQuery,
+uploadMultimedia: ( +uploadMultimedia: (
multimedia: Object, multimedia: Object,
extras: MultimediaUploadExtras, extras: MultimediaUploadExtras,
callbacks: MultimediaUploadCallbacks, callbacks: MultimediaUploadCallbacks,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+blobServiceUpload: BlobServiceUploadAction,
+uploadMediaMetadata: ( +uploadMediaMetadata: (
input: UploadMediaMetadataRequest, input: UploadMediaMetadataRequest,
) => Promise<UploadMultimediaResult>, ) => Promise<UploadMultimediaResult>,
+deleteUpload: (id: string) => Promise<void>, +deleteUpload: (id: string) => Promise<void>,
+sendMultimediaMessage: ( +sendMultimediaMessage: (
threadID: string, threadID: string,
localID: string, localID: string,
mediaIDs: $ReadOnlyArray<string>, mediaIDs: $ReadOnlyArray<string>,
▲ Show 20 Lines • Show All 729 Lines • ▼ Show 20 Lines try {
(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(
encryptionKey && blobHash && dimensions, encryptionKey && blobHash && dimensions,
'incomplete encrypted upload', 'incomplete encrypted upload',
); );
uploadResult = await this.blobServiceUpload( uploadResult = await this.props.blobServiceUpload({
{ input: {
blobInput: {
type: 'file',
file: upload.file, file: upload.file,
},
blobHash, blobHash,
encryptionKey, encryptionKey,
dimensions, dimensions,
loop: false, loop: false,
...(thumbHash ? { thumbHash } : undefined), thumbHash,
}, },
{ ...callbacks }, callbacks,
); });
} else { } else {
let uploadExtras = { let uploadExtras = {
...upload.dimensions, ...upload.dimensions,
loop: false, loop: false,
thumbHash: upload.thumbHash, thumbHash: upload.thumbHash,
}; };
if (encryptionKey) { if (encryptionKey) {
uploadExtras = { ...uploadExtras, encryptionKey }; uploadExtras = { ...uploadExtras, encryptionKey };
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines this.setState(prevState => {
loop: result.loop, loop: result.loop,
}, },
}, },
}, },
}; };
}); });
} }
async blobServiceUpload(
input: {
+file: File,
+blobHash: string,
+encryptionKey: string,
+dimensions: Dimensions,
+loop?: boolean,
+thumbHash?: string,
},
options?: ?CallServerEndpointOptions,
): Promise<{
...UploadMultimediaResult,
+blobHolder: string,
}> {
const blobHolder = uuid.v4();
const blobHash = toBase64URL(input.blobHash);
// 1. Assign new holder for blob with given blobHash
let blobAlreadyExists: boolean;
try {
const assignHolderEndpoint = blobService.httpEndpoints.ASSIGN_HOLDER;
const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(assignHolderEndpoint),
{
method: assignHolderEndpoint.method,
body: JSON.stringify({
holder: blobHolder,
blob_hash: blobHash,
}),
headers: {
'content-type': 'application/json',
},
},
);
handleHTTPResponseError(assignHolderResponse);
const { data_exists: dataExistsResponse } =
await assignHolderResponse.json();
blobAlreadyExists = dataExistsResponse;
} catch (e) {
throw new Error(
`Failed to assign holder: ${
getMessageForException(e) ?? 'unknown error'
}`,
);
}
// 2. Upload blob contents if blob doesn't exist
if (!blobAlreadyExists) {
const formData = new FormData();
formData.append('blob_hash', blobHash);
formData.append('blob_data', input.file);
const xhr = new XMLHttpRequest();
const uploadEndpoint = blobService.httpEndpoints.UPLOAD_BLOB;
xhr.open(
uploadEndpoint.method,
makeBlobServiceEndpointURL(uploadEndpoint),
);
if (options?.timeout) {
xhr.timeout = options.timeout;
}
if (options && options.onProgress) {
const { onProgress } = options;
xhr.upload.onprogress = _throttle(
({ loaded, total }) => onProgress(loaded / total),
50,
);
}
let failed = false;
const responsePromise = new Promise((resolve, reject) => {
xhr.onload = () => {
if (failed) {
return;
}
resolve();
};
xhr.onabort = () => {
failed = true;
reject(new Error('request aborted'));
};
xhr.onerror = event => {
failed = true;
reject(event);
};
if (options && options.timeout) {
xhr.ontimeout = event => {
failed = true;
reject(event);
};
}
if (options && options.abortHandler) {
options.abortHandler(() => {
failed = true;
reject(new Error('request aborted'));
xhr.abort();
});
}
});
if (!failed) {
xhr.send(formData);
}
await responsePromise;
}
// 3. Send upload metadata to the keyserver, return response
const result = await this.props.uploadMediaMetadata({
...input.dimensions,
loop: input.loop ?? false,
blobHolder,
blobHash,
encryptionKey: input.encryptionKey,
mimeType: input.file.type,
filename: input.file.name,
thumbHash: input.thumbHash,
});
return { ...result, blobHolder };
}
handleAbortCallback( handleAbortCallback(
threadID: string, threadID: string,
localUploadID: string, localUploadID: string,
abort: () => void, abort: () => void,
) { ) {
this.setState(prevState => { this.setState(prevState => {
const newThreadID = this.getRealizedOrPendingThreadID(threadID); const newThreadID = this.getRealizedOrPendingThreadID(threadID);
const uploads = prevState.pendingUploads[newThreadID]; const uploads = prevState.pendingUploads[newThreadID];
▲ Show 20 Lines • Show All 533 Lines • ▼ Show 20 Lines React.memo<BaseProps>(function ConnectedInputStateContainer(props) {
const threadStoreThreadInfos = useSelector( const threadStoreThreadInfos = useSelector(
state => state.threadStore.threadInfos, state => state.threadStore.threadInfos,
); );
const pendingToRealizedThreadIDs = useSelector(state => const pendingToRealizedThreadIDs = useSelector(state =>
pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos), pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
); );
const calendarQuery = useSelector(nonThreadCalendarQuery); const calendarQuery = useSelector(nonThreadCalendarQuery);
const callUploadMultimedia = useServerCall(uploadMultimedia); const callUploadMultimedia = useServerCall(uploadMultimedia);
const callBlobServiceUpload = useServerCall(blobServiceUpload);
const callUploadMediaMetadata = useServerCall(uploadMediaMetadata); const callUploadMediaMetadata = useServerCall(uploadMediaMetadata);
const callDeleteUpload = useServerCall(deleteUpload); const callDeleteUpload = useServerCall(deleteUpload);
const callSendMultimediaMessage = useServerCall( const callSendMultimediaMessage = useServerCall(
legacySendMultimediaMessage, legacySendMultimediaMessage,
); );
const callSendTextMessage = useServerCall(sendTextMessage); const callSendTextMessage = useServerCall(sendTextMessage);
const callNewThread = useServerCall(newThread); const callNewThread = useServerCall(newThread);
const dispatch = useDispatch(); const dispatch = useDispatch();
Show All 24 Lines return (
drafts={drafts} drafts={drafts}
viewerID={viewerID} viewerID={viewerID}
messageStoreMessages={messageStoreMessages} messageStoreMessages={messageStoreMessages}
threadStoreThreadInfos={threadStoreThreadInfos} threadStoreThreadInfos={threadStoreThreadInfos}
pendingRealizedThreadIDs={pendingToRealizedThreadIDs} pendingRealizedThreadIDs={pendingToRealizedThreadIDs}
calendarQuery={calendarQuery} calendarQuery={calendarQuery}
uploadMultimedia={callUploadMultimedia} uploadMultimedia={callUploadMultimedia}
uploadMediaMetadata={callUploadMediaMetadata} uploadMediaMetadata={callUploadMediaMetadata}
blobServiceUpload={callBlobServiceUpload}
deleteUpload={callDeleteUpload} deleteUpload={callDeleteUpload}
sendMultimediaMessage={callSendMultimediaMessage} sendMultimediaMessage={callSendMultimediaMessage}
sendTextMessage={callSendTextMessage} sendTextMessage={callSendTextMessage}
newThread={callNewThread} newThread={callNewThread}
dispatch={dispatch} dispatch={dispatch}
dispatchActionPromise={dispatchActionPromise} dispatchActionPromise={dispatchActionPromise}
pushModal={modalContext.pushModal} pushModal={modalContext.pushModal}
sendCallbacks={sendCallbacks} sendCallbacks={sendCallbacks}
registerSendCallback={registerSendCallback} registerSendCallback={registerSendCallback}
unregisterSendCallback={unregisterSendCallback} unregisterSendCallback={unregisterSendCallback}
textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc} textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
/> />
); );
}); });
export default ConnectedInputStateContainer; export default ConnectedInputStateContainer;