Page MenuHomePhabricator
Differential D11583

[web] update `WorkerCryptoStore` to handle session version
ClosedPublic
Actions

Authored by kamil on Apr 8 2024, 6:47 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Apr 6, 9:08 AM
Unknown Object (File)
Mon, Mar 24, 5:57 AM
Unknown Object (File)
Tue, Mar 11, 1:54 AM
Unknown Object (File)
Mar 5 2025, 5:01 AM
Unknown Object (File)
Mar 5 2025, 5:01 AM
Unknown Object (File)
Mar 5 2025, 5:01 AM
Unknown Object (File)
Mar 5 2025, 5:01 AM
Unknown Object (File)
Mar 5 2025, 5:01 AM
View All 68 Files
Subscribers
ashoat

Details

Reviewers
bartek
marcin
tomek
Commits
rCOMMcab25122c49c: [web] update `WorkerCryptoStore` to handle session version
Summary

Updates in-memory CryptoStore to work with session versions.

Depends on D11582

Test Plan

Tested in TBD

Diff Detail

Repository
rCOMM Comm
Branch
publish-session-resetting
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

kamil created this revision.Apr 8 2024, 6:47 AM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptApr 8 2024, 6:47 AM
Harbormaster failed remote builds in B28055: Diff 38905!Apr 8 2024, 7:24 AM
kamil added a child revision: D11586: [web] update session creation code to handle versioning.Apr 8 2024, 7:25 AM
kamil updated this revision to Diff 38935.Apr 9 2024, 4:54 AM

rebase

Harbormaster completed remote builds in B28085: Diff 38935.Apr 9 2024, 5:13 AM
kamil published this revision for review.Apr 9 2024, 6:01 AM
kamil added inline comments.
web/shared-worker/worker/worker-crypto.js
439

updated in D11586

467

updated in D11586

marcin accepted this revision.Apr 10 2024, 6:31 AM
This revision is now accepted and ready to land.Apr 10 2024, 6:31 AM
Closed by commit rCOMMcab25122c49c: [web] update `WorkerCryptoStore` to handle session version (authored by kamil). · Explain WhyApr 11 2024, 4:47 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMMcab25122c49c: [web] update `WorkerCryptoStore` to handle session version.
ashoat added inline comments.Apr 12 2024, 6:36 AM
web/shared-worker/worker/worker-crypto.js
63 ↗(On Diff #39043)

Sorry for adding this comment late, but this could be made read-only

kamil added inline comments.Apr 22 2024, 3:51 AM
web/shared-worker/worker/worker-crypto.js
63 ↗(On Diff #39043)

If I recall correctly this was by design, so we can modify one session in in-memory cryptoStore (see line 74) without updating the entire object.

If you still think it's better to make this read-only and update rest of the code I can put up a diff

ashoat added inline comments.Apr 22 2024, 5:02 AM
web/shared-worker/worker/worker-crypto.js
63 ↗(On Diff #39043)

Thanks for explaining! Looks like it's been thought through, so it's fine to leave as-is

Revision Contents
Changeset List

PathSize
web/
shared-worker/
worker/
46 lines

Diff 38905

View Options

web/shared-worker/worker/worker-crypto.js

// @flow // @flow
import _memoize from 'lodash/memoize.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 { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js'; import { bindCookieAndUtilsIntoCallServerEndpoint } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint.js'; import type { BindServerCallsParams } from './action-utils.js';
import type { CallServerEndpointOptions } from './call-server-endpoint';
import { useSelector } from './redux-utils.js'; import { useSelector } from './redux-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint } from '../types/endpoints.js'; import type { Endpoint } from '../types/endpoints.js';
import type { KeyserverInfo } from '../types/keyserver-types.js'; import type { KeyserverInfo } from '../types/keyserver-types.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ConnectionStatus } from '../types/socket-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = ( export type CallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>> = (
endpoint: Endpoint, endpoint: Endpoint,
input: any, input: any,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => Promise<any>; ) => Promise<any>;
Show All 9 Lines | {
+keyserverIDExtractor: (...Args) => string, +keyserverIDExtractor: (...Args) => string,
}; };
export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = { export type KeyserverCall<Args: $ReadOnlyArray<mixed>, Return> = {
+actionFunc: ActionFunc<Args, Return>, +actionFunc: ActionFunc<Args, Return>,
+config: KeyserverCallConfig<Args>, +config: KeyserverCallConfig<Args>,
}; };
export type ExtractAndBindCookieAndUtilsParams< const boundCallServerEndpointSelector = createSelector(
Args: $ReadOnlyArray<mixed>, (state: BindServerCallsParams) => state.dispatch,
Return, (state: BindServerCallsParams) => state.cookie,
> = { (state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.connectionStatus,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionStatus: ConnectionStatus,
lastCommunicatedPlatformDetails: ?PlatformDetails,
) => {
return bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
});
},
ashoatUnsubmitted
Not Done
Inline Actions
lastCommunicatedPlatformDetails: ?PlatformDetails,
- ) => {
- return bindCookieAndUtilsIntoCallServerEndpoint({
- dispatch,
- cookie,
- urlPrefix,
- sessionID,
- currentUserInfo,
- connectionStatus,
- lastCommunicatedPlatformDetails,
- });
- },
+ ) => bindCookieAndUtilsIntoCallServerEndpoint({
+ dispatch,
+ cookie,
+ urlPrefix,
+ sessionID,
+ currentUserInfo,
+ connectionStatus,
+ lastCommunicatedPlatformDetails,
+ }),
);
export type BindKeyserverCallParams = {

Nit: shorthand

ashoat: Nit: shorthand
);
export type BindKeyserverCallParams = {
+dispatch: Dispatch, +dispatch: Dispatch,
+currentUserInfo: ?CurrentUserInfo, +currentUserInfo: ?CurrentUserInfo,
+keyserverInfos: { +[keyserverID: string]: KeyserverInfo }, +keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
+keyserverCall: KeyserverCall<Args, Return>,
}; };
function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>, Return>( export type GetCallKeyserverEndpointParams<Args: $ReadOnlyArray<mixed>> = {
params: ExtractAndBindCookieAndUtilsParams<Args, Return>, ...BindKeyserverCallParams,
): CallKeyserverEndpoint<Args> { +keyserverCallConfig: KeyserverCallConfig<Args>,
const { dispatch, keyserverInfos, currentUserInfo, keyserverCall } = params; };
const { config: serverCallConfig } = keyserverCall; function getCallKeyserverEndpoint<Args: $ReadOnlyArray<mixed>>(
params: GetCallKeyserverEndpointParams<Args>,
): CallKeyserverEndpoint<Args> {
const { dispatch, keyserverInfos, currentUserInfo, keyserverCallConfig } =
params;
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
args: Args, args: Args,
options?: ?CallServerEndpointOptions, options?: ?CallServerEndpointOptions,
) => { ) => {
// TODO // TODO
if (serverCallConfig.keyserverSelection === 'fanout') { if (keyserverCallConfig.keyserverSelection === 'fanout') {
return Promise.all([]); return Promise.all([]);
} }
const keyserverID = serverCallConfig.keyserverIDExtractor(...args); const keyserverID = keyserverCallConfig.keyserverIDExtractor(...args);
const { const {
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connection, connection,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
} = keyserverInfos[keyserverID]; } = keyserverInfos[keyserverID];
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({ const boundCallServerEndpoint = boundCallServerEndpointSelector({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
connectionStatus: connection.status, connectionStatus: connection.status,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
}); });
return boundCallServerEndpoint(endpoint, data, options); return boundCallServerEndpoint(endpoint, data, options);
}; };
} }
const baseCreateBoundKeyserverCallActionSelector = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
): (BindKeyserverCallParams => (...Args) => Promise<Return>) =>
createSelector(
(state: BindKeyserverCallParams) => state.dispatch,
(state: BindKeyserverCallParams) => state.currentUserInfo,
(state: BindKeyserverCallParams) => state.keyserverInfos,
(
dispatch: Dispatch,
currentUserInfo: ?CurrentUserInfo,
keyserverInfos: { +[keyserverID: string]: KeyserverInfo },
) => {
const callKeyserverEndpoint = getCallKeyserverEndpoint({
dispatch,
currentUserInfo,
keyserverInfos,
keyserverCallConfig: keyserverCall.config,
});
return keyserverCall.actionFunc(callKeyserverEndpoint);
},
);
type CreateBoundKeyserverCallActionSelectorType = <
Args: $ReadOnlyArray<mixed>,
Return,
>(
keyserverCall: KeyserverCall<Args, Return>,
) => BindKeyserverCallParams => (...Args) => Promise<Return>;
const createBoundKeyserverCallActionSelector: CreateBoundKeyserverCallActionSelectorType =
_memoize(baseCreateBoundKeyserverCallActionSelector);
function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>( function useKeyserverCall<Args: $ReadOnlyArray<mixed>, Return>(
keyserverCall: KeyserverCall<Args, Return>, keyserverCall: KeyserverCall<Args, Return>,
paramOverride?: ?$Shape<ExtractAndBindCookieAndUtilsParams<Args, Return>>, paramOverride?: ?$Shape<BindKeyserverCallParams>,
): (...Args) => Promise<Return> { ): (...Args) => Promise<Return> {
const dispatch = useDispatch(); const dispatch = useDispatch();
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
return React.useMemo(() => { return React.useMemo(
const callKeyserverEndpoint = getCallKeyserverEndpoint({ () =>
createBoundKeyserverCallActionSelector(keyserverCall)({
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverInfos, keyserverInfos,
keyserverCall,
...paramOverride, ...paramOverride,
}); }),
return keyserverCall.actionFunc(callKeyserverEndpoint);
}, [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride]); [dispatch, currentUserInfo, keyserverInfos, keyserverCall, paramOverride],
);
} }
export { useKeyserverCall }; export { useKeyserverCall };