Page MenuHomePhabricator
Files F3384041

D11373.id38278.diff
No OneTemporary
Actions

D11373.id38278.diff
View Options

diff --git a/web/grpc/identity-service-client-proxy.js b/web/grpc/identity-service-client-proxy.js
deleted file mode 100644
--- a/web/grpc/identity-service-client-proxy.js
+++ /dev/null
@@ -1,125 +0,0 @@
-// @flow
-
-import type {
- OneTimeKeysResultValues,
- SignedPrekeys,
-} from 'lib/types/crypto-types.js';
-import type {
- SignedDeviceList,
- SignedMessage,
- IdentityServiceClient,
- IdentityServiceAuthLayer,
- DeviceOlmOutboundKeys,
- IdentityAuthResult,
- UserDevicesOlmInboundKeys,
- UserDevicesOlmOutboundKeys,
-} from 'lib/types/identity-service-types.js';
-import { getConfig } from 'lib/utils/config.js';
-
-import {
- type CommSharedWorker,
- getCommSharedWorker,
-} from '../shared-worker/shared-worker-provider.js';
-import { getOpaqueWasmPath } from '../shared-worker/utils/constants.js';
-import {
- workerRequestMessageTypes,
- workerResponseMessageTypes,
-} from '../types/worker-types.js';
-
-class IdentityServiceClientSharedProxy implements IdentityServiceClient {
- sharedWorkerPromise: Promise<CommSharedWorker>;
-
- constructor(authLayer: ?IdentityServiceAuthLayer) {
- this.sharedWorkerPromise = (async () => {
- const sharedWorker = await getCommSharedWorker();
- await sharedWorker.schedule({
- type: workerRequestMessageTypes.CREATE_IDENTITY_SERVICE_CLIENT,
- opaqueWasmPath: getOpaqueWasmPath(),
- platformDetails: getConfig().platformDetails,
- authLayer,
- });
-
- return sharedWorker;
- })();
- }
-
- proxyToWorker<T>(
- method: $Keys<IdentityServiceClient>,
- ): (...args: $ReadOnlyArray<mixed>) => Promise<T> {
- return async (...args: $ReadOnlyArray<mixed>) => {
- const sharedWorker = await this.sharedWorkerPromise;
- const result = await sharedWorker.schedule({
- type: workerRequestMessageTypes.CALL_IDENTITY_CLIENT_METHOD,
- method,
- args,
- });
-
- if (!result) {
- throw new Error(`Worker identity call didn't return expected message`);
- } else if (
- result.type !== workerResponseMessageTypes.CALL_IDENTITY_CLIENT_METHOD
- ) {
- throw new Error(
- `Worker identity call didn't return expected message. Instead got: ${JSON.stringify(
- result,
- )}`,
- );
- }
-
- // Worker should return a message with the corresponding return type
- return (result.result: any);
- };
- }
-
- deleteUser: () => Promise<void> = this.proxyToWorker('deleteUser');
-
- getKeyserverKeys: (keyserverID: string) => Promise<DeviceOlmOutboundKeys> =
- this.proxyToWorker('getKeyserverKeys');
-
- getOutboundKeysForUser: (
- userID: string,
- ) => Promise<UserDevicesOlmOutboundKeys[]> = this.proxyToWorker(
- 'getOutboundKeysForUser',
- );
-
- getInboundKeysForUser: (
- userID: string,
- ) => Promise<UserDevicesOlmInboundKeys> = this.proxyToWorker(
- 'getInboundKeysForUser',
- );
-
- uploadOneTimeKeys: (oneTimeKeys: OneTimeKeysResultValues) => Promise<void> =
- this.proxyToWorker('uploadOneTimeKeys');
-
- logInPasswordUser: (
- username: string,
- password: string,
- ) => Promise<IdentityAuthResult> = this.proxyToWorker('logInPasswordUser');
-
- logInWalletUser: (
- walletAddress: string,
- siweMessage: string,
- siweSignature: string,
- ) => Promise<IdentityAuthResult> = this.proxyToWorker('logInWalletUser');
-
- uploadKeysForRegisteredDeviceAndLogIn: (
- userID: string,
- nonceChallengeResponse: SignedMessage,
- ) => Promise<IdentityAuthResult> = this.proxyToWorker(
- 'uploadKeysForRegisteredDeviceAndLogIn',
- );
-
- generateNonce: () => Promise<string> = this.proxyToWorker('generateNonce');
-
- publishWebPrekeys: (prekeys: SignedPrekeys) => Promise<void> =
- this.proxyToWorker('publishWebPrekeys');
-
- getDeviceListHistoryForUser: (
- userID: string,
- sinceTimestamp?: number,
- ) => Promise<$ReadOnlyArray<SignedDeviceList>> = this.proxyToWorker(
- 'getDeviceListHistoryForUser',
- );
-}
-
-export { IdentityServiceClientSharedProxy };
diff --git a/web/grpc/identity-service-context-provider.react.js b/web/grpc/identity-service-context-provider.react.js
--- a/web/grpc/identity-service-context-provider.react.js
+++ b/web/grpc/identity-service-context-provider.react.js
@@ -1,18 +1,30 @@
// @flow
+import _isEqual from 'lodash/fp/isEqual.js';
import * as React from 'react';
import {
IdentityClientContext,
type AuthMetadata,
} from 'lib/shared/identity-client-context.js';
+import type {
+ IdentityServiceClient,
+ IdentityServiceAuthLayer,
+} from 'lib/types/identity-service-types.js';
import { getConfig } from 'lib/utils/config.js';
+import { getContentSigningKey } from 'lib/utils/crypto-utils.js';
-import { IdentityServiceClientSharedProxy } from './identity-service-client-proxy.js';
-import { IdentityServiceClientWrapper } from './identity-service-client-wrapper.js';
-import { useGetDeviceKeyUpload } from '../account/account-hooks.js';
-import { usingSharedWorker } from '../crypto/olm-api.js';
import { useSelector } from '../redux/redux-utils.js';
+import { getCommSharedWorker } from '../shared-worker/shared-worker-provider.js';
+import { getOpaqueWasmPath } from '../shared-worker/utils/constants.js';
+import {
+ workerRequestMessageTypes,
+ workerResponseMessageTypes,
+} from '../types/worker-types.js';
+
+type CreateMethodWorkerProxy = <Return>(
+ method: $Keys<IdentityServiceClient>,
+) => (...args: $ReadOnlyArray<mixed>) => Promise<Return>;
type Props = {
+children: React.Node,
@@ -22,41 +34,105 @@
const userID = useSelector(state => state.currentUserInfo?.id);
const accessToken = useSelector(state => state.commServicesAccessToken);
- const deviceID = useSelector(
- state => state.cryptoStore?.primaryIdentityKeys.ed25519,
- );
- const getDeviceKeyUpload = useGetDeviceKeyUpload();
-
- const client = React.useMemo(() => {
- let authLayer = null;
- if (userID && deviceID && accessToken) {
- authLayer = {
- userID,
- deviceID,
- commServicesAccessToken: accessToken,
- };
- }
- if (usingSharedWorker) {
- return new IdentityServiceClientSharedProxy(authLayer);
- } else {
- return new IdentityServiceClientWrapper(
- getConfig().platformDetails,
- null,
- authLayer,
- getDeviceKeyUpload,
- );
- }
- }, [accessToken, deviceID, getDeviceKeyUpload, userID]);
-
- const getAuthMetadata = React.useCallback<() => Promise<AuthMetadata>>(
- async () => ({
+
+ const getAuthMetadata = React.useCallback<
+ () => Promise<AuthMetadata>,
+ >(async () => {
+ const contentSigningKey = await getContentSigningKey();
+ return {
userID,
- deviceID,
+ deviceID: contentSigningKey,
accessToken,
- }),
- [accessToken, deviceID, userID],
+ };
+ }, [accessToken, userID]);
+
+ const workerClientAuthMetadata = React.useRef<?AuthMetadata>(null);
+ const ensureThatWorkerClientAuthMetadataIsCurrent =
+ React.useCallback(async () => {
+ const sharedWorker = await getCommSharedWorker();
+ const authMetadata = await getAuthMetadata();
+
+ if (!_isEqual(authMetadata, workerClientAuthMetadata.current)) {
+ workerClientAuthMetadata.current = authMetadata;
+
+ let authLayer: ?IdentityServiceAuthLayer = null;
+ if (
+ authMetadata.userID &&
+ authMetadata.deviceID &&
+ authMetadata.accessToken
+ ) {
+ authLayer = {
+ userID: authMetadata.userID,
+ deviceID: authMetadata.deviceID,
+ commServicesAccessToken: authMetadata.accessToken,
+ };
+ }
+
+ await sharedWorker.schedule({
+ type: workerRequestMessageTypes.CREATE_IDENTITY_SERVICE_CLIENT,
+ opaqueWasmPath: getOpaqueWasmPath(),
+ platformDetails: getConfig().platformDetails,
+ authLayer,
+ });
+ }
+ }, [getAuthMetadata]);
+
+ React.useEffect(() => {
+ void ensureThatWorkerClientAuthMetadataIsCurrent();
+ }, [ensureThatWorkerClientAuthMetadataIsCurrent]);
+
+ const proxyMethodToWorker: CreateMethodWorkerProxy = React.useCallback(
+ method =>
+ async (...args: $ReadOnlyArray<mixed>) => {
+ await ensureThatWorkerClientAuthMetadataIsCurrent();
+
+ const sharedWorker = await getCommSharedWorker();
+ const result = await sharedWorker.schedule({
+ type: workerRequestMessageTypes.CALL_IDENTITY_CLIENT_METHOD,
+ method,
+ args,
+ });
+
+ if (!result) {
+ throw new Error(
+ `Worker identity call didn't return expected message`,
+ );
+ } else if (
+ result.type !== workerResponseMessageTypes.CALL_IDENTITY_CLIENT_METHOD
+ ) {
+ throw new Error(
+ `Worker identity call didn't return expected message. Instead got: ${JSON.stringify(
+ result,
+ )}`,
+ );
+ }
+
+ // Worker should return a message with the corresponding return type
+ return (result.result: any);
+ },
+ [ensureThatWorkerClientAuthMetadataIsCurrent],
);
+ const client = React.useMemo<IdentityServiceClient>(() => {
+ return {
+ deleteUser: proxyMethodToWorker('deleteUser'),
+ getKeyserverKeys: proxyMethodToWorker('getKeyserverKeys'),
+ getOutboundKeysForUser: proxyMethodToWorker('getOutboundKeysForUser'),
+ getInboundKeysForUser: proxyMethodToWorker('getInboundKeysForUser'),
+ uploadOneTimeKeys: proxyMethodToWorker('uploadOneTimeKeys'),
+ logInPasswordUser: proxyMethodToWorker('logInPasswordUser'),
+ logInWalletUser: proxyMethodToWorker('logInWalletUser'),
+ uploadKeysForRegisteredDeviceAndLogIn: proxyMethodToWorker(
+ 'uploadKeysForRegisteredDeviceAndLogIn',
+ ),
+ generateNonce: proxyMethodToWorker('generateNonce'),
+ publishWebPrekeys: proxyMethodToWorker('publishWebPrekeys'),
+ getDeviceListHistoryForUser: proxyMethodToWorker(
+ 'getDeviceListHistoryForUser',
+ ),
+ };
+ }, [proxyMethodToWorker]);
+
const value = React.useMemo(
() => ({
identityClient: client,

File Metadata

Mime Type
text/plain
Expires
Fri, Nov 29, 7:08 PM (21 h, 27 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2597856
Default Alt Text
D11373.id38278.diff (10 KB)

Event Timeline