Page MenuHomePhabricator
Differential D11216

[lib][native] Use unified keyserver session recovery in native/socket.react.js
ClosedPublic
Actions

Authored by ashoat on Mar 3 2024, 8:49 PM.
Tags
None
Referenced Files
F5896560: D11216.id37841.diff
Thu, Apr 17, 11:08 AM
Unknown Object (File)
Wed, Apr 16, 9:47 AM
Unknown Object (File)
Wed, Apr 16, 4:10 AM
Unknown Object (File)
Tue, Apr 15, 1:36 PM
Unknown Object (File)
Tue, Apr 8, 9:03 PM
Unknown Object (File)
Tue, Apr 8, 8:31 PM
Unknown Object (File)
Mar 13 2025, 4:55 AM
Unknown Object (File)
Feb 20 2025, 7:36 PM
View All 67 Files
Subscribers
None

Details

Reviewers
inka
tomek
Commits
rCOMMb90d5f3e5aa8: [lib][native] Use unified keyserver session recovery in native/socket.react.js
Summary

Instead of dispatching a call from Socket, we should use the unified mechanism owned by KeyserverConnectionHandler. This way, we can avoid multiple simultaneous recoveries being dispatched at once.

Depends on D11215

Test Plan

Part 4.4 of this test plan: https://gist.github.com/Ashoat/75ab690d5c53cdd68a51b02e03e27c58

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
lib/
socket/
15 lines
types/
11 lines
native/
53 lines

Diff 37841

View Options

lib/socket/socket.react.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _memoize from 'lodash/memoize.js'; import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { createSelector } from 'reselect'; import { createSelector } from 'reselect';
import { useKeyserverCallInfos } from './keyserver-call-infos.js'; import {
useKeyserverCallInfos,
type KeyserverCallInfo,
} from './keyserver-call-infos.js';
import { import {
setNewSession, setNewSession,
type SingleKeyserverActionFunc, type SingleKeyserverActionFunc,
type ActionFunc, type ActionFunc,
setSessionRecoveryInProgressActionType,
} from './keyserver-conn-types.js'; } from './keyserver-conn-types.js';
import { import { canResolveKeyserverSessionInvalidation } from './recovery-utils.js';
canResolveKeyserverSessionInvalidation,
resolveKeyserverSessionInvalidation,
} from './recovery-utils.js';
import { logInActionSources } from '../types/account-types.js';
import type { PlatformDetails } from '../types/device-types.js'; import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js'; import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ClientSessionChange } from '../types/session-types.js'; import type { ClientSessionChange } from '../types/session-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesfunction CallKeyserverEndpointProvider(props: Props): React.Node {
) => CallSingleKeyserverEndpoint = React.useCallback(params => { ) => CallSingleKeyserverEndpoint = React.useCallback(params => {
const { const {
dispatch, dispatch,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
currentUserInfo, currentUserInfo,
isSocketConnected, isSocketConnected,
sessionRecoveryInProgress,
canRecoverSession, canRecoverSession,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
keyserverID, keyserverID,
} = params; } = params;
const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true); const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
const boundSetNewSession = ( const boundSetNewSession = (
sessionChange: ClientSessionChange, sessionChange: ClientSessionChange,
error: ?string, error: ?string,
Show All 15 Lines ) => CallSingleKeyserverEndpoint = React.useCallback(params => {
// request, to make sure that we're not in the middle of trying to recover // request, to make sure that we're not in the middle of trying to recover
// an invalidated cookie // an invalidated cookie
const waitIfCookieInvalidated = () => { const waitIfCookieInvalidated = () => {
if (!canResolveInvalidation) { if (!canResolveInvalidation) {
// If there is no way to resolve the session invalidation, // If there is no way to resolve the session invalidation,
// just let the caller callSingleKeyserverEndpoint instance continue // just let the caller callSingleKeyserverEndpoint instance continue
return Promise.resolve(null); return Promise.resolve(null);
} }
const ongoingRecoveryAttempt = if (!sessionRecoveryInProgress) {
ongoingRecoveryAttemptsRef.current.get(keyserverID);
if (!ongoingRecoveryAttempt) {
// Our cookie seems to be valid // Our cookie seems to be valid
return Promise.resolve(null); return Promise.resolve(null);
} }
const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
let keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
keyserverRecoveryAttempts = { waitingCalls: [] };
recoveryAttempts.set(keyserverID, keyserverRecoveryAttempts);
}
const ongoingRecoveryAttempts = keyserverRecoveryAttempts;
// Wait to run until we get our new cookie // Wait to run until we get our new cookie
return new Promise<?CallSingleKeyserverEndpoint>(r => return new Promise<?CallSingleKeyserverEndpoint>(r =>
ongoingRecoveryAttempt.waitingCalls.push(r), ongoingRecoveryAttempts.waitingCalls.push(r),
);
};
// These functions are helpers for cookieInvalidationRecovery, defined below
const attemptToResolveInvalidationHelper = async (
sessionChange: ClientSessionChange,
) => {
const newAnonymousCookie = sessionChange.cookie;
const newSessionChange = await resolveKeyserverSessionInvalidation(
dispatch,
newAnonymousCookie,
urlPrefix,
logInActionSources.cookieInvalidationResolutionAttempt,
keyserverID,
);
return newSessionChange
? bindCookieAndUtilsIntoCallSingleKeyserverEndpoint({
...params,
cookie: newSessionChange.cookie,
sessionID: newSessionChange.sessionID,
currentUserInfo: newSessionChange.currentUserInfo,
})
: null;
};
const attemptToResolveInvalidation = (
sessionChange: ClientSessionChange,
) => {
return new Promise<?CallSingleKeyserverEndpoint>(
// eslint-disable-next-line no-async-promise-executor
async (resolve, reject) => {
try {
const newCallSingleKeyserverEndpoint =
await attemptToResolveInvalidationHelper(sessionChange);
const ongoingRecoveryAttempt =
ongoingRecoveryAttemptsRef.current.get(keyserverID);
ongoingRecoveryAttemptsRef.current.delete(keyserverID);
const currentWaitingCalls =
ongoingRecoveryAttempt?.waitingCalls ?? [];
resolve(newCallSingleKeyserverEndpoint);
for (const func of currentWaitingCalls) {
func(newCallSingleKeyserverEndpoint);
}
} catch (e) {
reject(e);
}
},
); );
}; };
// If this function is called, callSingleKeyserverEndpoint got a response // If this function is called, callSingleKeyserverEndpoint got a response
// invalidating its cookie, and is wondering if it should just like... // invalidating its cookie, and is wondering if it should just like...
// give up? Or if there's a chance at redemption // give up? Or if there's a chance at redemption
const cookieInvalidationRecovery = ( const cookieInvalidationRecovery = (
sessionChange: ClientSessionChange, sessionChange: ClientSessionChange,
error: ?string, error: ?string,
) => { ) => {
if (!canResolveInvalidation) { if (!canResolveInvalidation) {
// When invalidation recovery is supported, we let that code call // When invalidation recovery is supported, we let that code call
// setNewSession. When it isn't supported, we call it directly here. // setNewSession. When it isn't supported, we call it directly here.
// Once usingCommServicesAccessToken is true, we should consider // Once usingCommServicesAccessToken is true, we should consider
// removing this call... see description of D10952 for details. // removing this call... see description of D10952 for details.
boundSetNewSession(sessionChange, error); boundSetNewSession(sessionChange, error);
// If there is no way to resolve the session invalidation, // If there is no way to resolve the session invalidation,
// just let the caller callSingleKeyserverEndpoint instance continue // just let the caller callSingleKeyserverEndpoint instance continue
return Promise.resolve(null); return Promise.resolve(null);
} }
if (!loggedIn) { if (!loggedIn) {
// We don't want to attempt any use native credentials of a logged out // We don't want to attempt any use native credentials of a logged out
// user to log-in after a cookieInvalidation while logged out // user to log-in after a cookieInvalidation while logged out
return Promise.resolve(null); return Promise.resolve(null);
} }
const ongoingRecoveryAttempt =
ongoingRecoveryAttemptsRef.current.get(keyserverID); const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
if (ongoingRecoveryAttempt) { let keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
keyserverRecoveryAttempts = { waitingCalls: [] };
recoveryAttempts.set(keyserverID, keyserverRecoveryAttempts);
}
if (!sessionRecoveryInProgress) {
dispatch({
type: setSessionRecoveryInProgressActionType,
payload: { sessionRecoveryInProgress: true, keyserverID },
});
}
const ongoingRecoveryAttempts = keyserverRecoveryAttempts;
return new Promise<?CallSingleKeyserverEndpoint>(r => return new Promise<?CallSingleKeyserverEndpoint>(r =>
ongoingRecoveryAttempt.waitingCalls.push(r), ongoingRecoveryAttempts.waitingCalls.push(r),
); );
}
ongoingRecoveryAttemptsRef.current.set(keyserverID, { waitingCalls: [] });
return attemptToResolveInvalidation(sessionChange);
}; };
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
options?: ?CallSingleKeyserverEndpointOptions, options?: ?CallSingleKeyserverEndpointOptions,
) => ) =>
callSingleKeyserverEndpoint( callSingleKeyserverEndpoint(
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines ): (ServerCallSelectorParams => CallSingleKeyserverEndpoint) =>
canRecoverSession, canRecoverSession,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
keyserverID, keyserverID,
}), }),
), ),
[bindCookieAndUtilsIntoCallSingleKeyserverEndpoint], [bindCookieAndUtilsIntoCallSingleKeyserverEndpoint],
); );
// SECTION 3: getBoundSingleKeyserverActionFunc // SECTION 3: getCallSingleKeyserverEndpoint
const dispatch = useDispatch(); const dispatch = useDispatch();
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const keyserverCallInfos = useKeyserverCallInfos(keyserverInfos); const keyserverCallInfos = useKeyserverCallInfos(keyserverInfos);
Show All 23 Lines const getCallSingleKeyserverEndpoint = React.useCallback(
[ [
createCallSingleKeyserverEndpointSelector, createCallSingleKeyserverEndpointSelector,
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverCallInfos, keyserverCallInfos,
], ],
); );
// SECTION 4: flush waitingCalls when sessionRecoveryInProgress flips to false
const prevKeyserverCallInfosRef = React.useRef<{
+[keyserverID: string]: KeyserverCallInfo,
}>(keyserverCallInfos);
React.useEffect(() => {
const sessionRecoveriesConcluded = new Set<string>();
const prevKeyserverCallInfos = prevKeyserverCallInfosRef.current;
for (const keyserverID in keyserverCallInfos) {
const prevKeyserverCallInfo = prevKeyserverCallInfos[keyserverID];
if (!prevKeyserverCallInfo) {
continue;
}
const keyserverCallInfo = keyserverCallInfos[keyserverID];
if (
!keyserverCallInfo.sessionRecoveryInProgress &&
prevKeyserverCallInfo.sessionRecoveryInProgress
) {
sessionRecoveriesConcluded.add(keyserverID);
}
}
for (const keyserverID of sessionRecoveriesConcluded) {
const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
const keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
continue;
}
const { waitingCalls } = keyserverRecoveryAttempts;
if (waitingCalls.length === 0) {
continue;
}
const { cookie } = keyserverCallInfos[keyserverID];
const hasUserCookie = cookie && cookie.startsWith('user=');
const boundCallSingleKeyserverEndpoint = hasUserCookie
? getCallSingleKeyserverEndpoint(keyserverID)
: null;
for (const waitingCall of waitingCalls) {
waitingCall(boundCallSingleKeyserverEndpoint);
}
}
prevKeyserverCallInfosRef.current = keyserverCallInfos;
}, [keyserverCallInfos, getCallSingleKeyserverEndpoint]);
// SECTION 5: getBoundSingleKeyserverActionFunc
const createBoundSingleKeyserverActionFuncSelector: CreateBoundSingleKeyserverActionFuncSelector = const createBoundSingleKeyserverActionFuncSelector: CreateBoundSingleKeyserverActionFuncSelector =
React.useCallback( React.useCallback(
actionFunc => actionFunc =>
createSelector( createSelector(
(params: SingleKeyserverActionFuncSelectorParams) => (params: SingleKeyserverActionFuncSelectorParams) =>
params.callSingleKeyserverEndpoint, params.callSingleKeyserverEndpoint,
actionFunc, actionFunc,
), ),
Show All 29 Lines React.useCallback(
}); });
}, },
[ [
createBoundSingleKeyserverActionFuncsCache, createBoundSingleKeyserverActionFuncsCache,
getCallSingleKeyserverEndpoint, getCallSingleKeyserverEndpoint,
], ],
); );
// SECTION 4: getBoundKeyserverActionFunc // SECTION 6: getBoundKeyserverActionFunc
const callKeyserverEndpoint = React.useCallback( const callKeyserverEndpoint = React.useCallback(
( (
endpoint: Endpoint, endpoint: Endpoint,
requests: { +[keyserverID: string]: ?{ +[string]: mixed } }, requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
options?: ?CallSingleKeyserverEndpointOptions, options?: ?CallSingleKeyserverEndpointOptions,
) => { ) => {
const makeCallToSingleKeyserver = (keyserverID: string) => { const makeCallToSingleKeyserver = (keyserverID: string) => {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines
View Options

lib/types/socket-types.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _memoize from 'lodash/memoize.js'; import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { createSelector } from 'reselect'; import { createSelector } from 'reselect';
import { useKeyserverCallInfos } from './keyserver-call-infos.js'; import {
useKeyserverCallInfos,
type KeyserverCallInfo,
} from './keyserver-call-infos.js';
import { import {
setNewSession, setNewSession,
type SingleKeyserverActionFunc, type SingleKeyserverActionFunc,
type ActionFunc, type ActionFunc,
setSessionRecoveryInProgressActionType,
} from './keyserver-conn-types.js'; } from './keyserver-conn-types.js';
import { import { canResolveKeyserverSessionInvalidation } from './recovery-utils.js';
canResolveKeyserverSessionInvalidation,
resolveKeyserverSessionInvalidation,
} from './recovery-utils.js';
import { logInActionSources } from '../types/account-types.js';
import type { PlatformDetails } from '../types/device-types.js'; import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js'; import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ClientSessionChange } from '../types/session-types.js'; import type { ClientSessionChange } from '../types/session-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesfunction CallKeyserverEndpointProvider(props: Props): React.Node {
) => CallSingleKeyserverEndpoint = React.useCallback(params => { ) => CallSingleKeyserverEndpoint = React.useCallback(params => {
const { const {
dispatch, dispatch,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
currentUserInfo, currentUserInfo,
isSocketConnected, isSocketConnected,
sessionRecoveryInProgress,
canRecoverSession, canRecoverSession,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
keyserverID, keyserverID,
} = params; } = params;
const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true); const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
const boundSetNewSession = ( const boundSetNewSession = (
sessionChange: ClientSessionChange, sessionChange: ClientSessionChange,
error: ?string, error: ?string,
Show All 15 Lines ) => CallSingleKeyserverEndpoint = React.useCallback(params => {
// request, to make sure that we're not in the middle of trying to recover // request, to make sure that we're not in the middle of trying to recover
// an invalidated cookie // an invalidated cookie
const waitIfCookieInvalidated = () => { const waitIfCookieInvalidated = () => {
if (!canResolveInvalidation) { if (!canResolveInvalidation) {
// If there is no way to resolve the session invalidation, // If there is no way to resolve the session invalidation,
// just let the caller callSingleKeyserverEndpoint instance continue // just let the caller callSingleKeyserverEndpoint instance continue
return Promise.resolve(null); return Promise.resolve(null);
} }
const ongoingRecoveryAttempt = if (!sessionRecoveryInProgress) {
ongoingRecoveryAttemptsRef.current.get(keyserverID);
if (!ongoingRecoveryAttempt) {
// Our cookie seems to be valid // Our cookie seems to be valid
return Promise.resolve(null); return Promise.resolve(null);
} }
const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
let keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
keyserverRecoveryAttempts = { waitingCalls: [] };
recoveryAttempts.set(keyserverID, keyserverRecoveryAttempts);
}
const ongoingRecoveryAttempts = keyserverRecoveryAttempts;
// Wait to run until we get our new cookie // Wait to run until we get our new cookie
return new Promise<?CallSingleKeyserverEndpoint>(r => return new Promise<?CallSingleKeyserverEndpoint>(r =>
ongoingRecoveryAttempt.waitingCalls.push(r), ongoingRecoveryAttempts.waitingCalls.push(r),
);
};
// These functions are helpers for cookieInvalidationRecovery, defined below
const attemptToResolveInvalidationHelper = async (
sessionChange: ClientSessionChange,
) => {
const newAnonymousCookie = sessionChange.cookie;
const newSessionChange = await resolveKeyserverSessionInvalidation(
dispatch,
newAnonymousCookie,
urlPrefix,
logInActionSources.cookieInvalidationResolutionAttempt,
keyserverID,
);
return newSessionChange
? bindCookieAndUtilsIntoCallSingleKeyserverEndpoint({
...params,
cookie: newSessionChange.cookie,
sessionID: newSessionChange.sessionID,
currentUserInfo: newSessionChange.currentUserInfo,
})
: null;
};
const attemptToResolveInvalidation = (
sessionChange: ClientSessionChange,
) => {
return new Promise<?CallSingleKeyserverEndpoint>(
// eslint-disable-next-line no-async-promise-executor
async (resolve, reject) => {
try {
const newCallSingleKeyserverEndpoint =
await attemptToResolveInvalidationHelper(sessionChange);
const ongoingRecoveryAttempt =
ongoingRecoveryAttemptsRef.current.get(keyserverID);
ongoingRecoveryAttemptsRef.current.delete(keyserverID);
const currentWaitingCalls =
ongoingRecoveryAttempt?.waitingCalls ?? [];
resolve(newCallSingleKeyserverEndpoint);
for (const func of currentWaitingCalls) {
func(newCallSingleKeyserverEndpoint);
}
} catch (e) {
reject(e);
}
},
); );
}; };
// If this function is called, callSingleKeyserverEndpoint got a response // If this function is called, callSingleKeyserverEndpoint got a response
// invalidating its cookie, and is wondering if it should just like... // invalidating its cookie, and is wondering if it should just like...
// give up? Or if there's a chance at redemption // give up? Or if there's a chance at redemption
const cookieInvalidationRecovery = ( const cookieInvalidationRecovery = (
sessionChange: ClientSessionChange, sessionChange: ClientSessionChange,
error: ?string, error: ?string,
) => { ) => {
if (!canResolveInvalidation) { if (!canResolveInvalidation) {
// When invalidation recovery is supported, we let that code call // When invalidation recovery is supported, we let that code call
// setNewSession. When it isn't supported, we call it directly here. // setNewSession. When it isn't supported, we call it directly here.
// Once usingCommServicesAccessToken is true, we should consider // Once usingCommServicesAccessToken is true, we should consider
// removing this call... see description of D10952 for details. // removing this call... see description of D10952 for details.
boundSetNewSession(sessionChange, error); boundSetNewSession(sessionChange, error);
// If there is no way to resolve the session invalidation, // If there is no way to resolve the session invalidation,
// just let the caller callSingleKeyserverEndpoint instance continue // just let the caller callSingleKeyserverEndpoint instance continue
return Promise.resolve(null); return Promise.resolve(null);
} }
if (!loggedIn) { if (!loggedIn) {
// We don't want to attempt any use native credentials of a logged out // We don't want to attempt any use native credentials of a logged out
// user to log-in after a cookieInvalidation while logged out // user to log-in after a cookieInvalidation while logged out
return Promise.resolve(null); return Promise.resolve(null);
} }
const ongoingRecoveryAttempt =
ongoingRecoveryAttemptsRef.current.get(keyserverID); const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
if (ongoingRecoveryAttempt) { let keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
keyserverRecoveryAttempts = { waitingCalls: [] };
recoveryAttempts.set(keyserverID, keyserverRecoveryAttempts);
}
if (!sessionRecoveryInProgress) {
dispatch({
type: setSessionRecoveryInProgressActionType,
payload: { sessionRecoveryInProgress: true, keyserverID },
});
}
const ongoingRecoveryAttempts = keyserverRecoveryAttempts;
return new Promise<?CallSingleKeyserverEndpoint>(r => return new Promise<?CallSingleKeyserverEndpoint>(r =>
ongoingRecoveryAttempt.waitingCalls.push(r), ongoingRecoveryAttempts.waitingCalls.push(r),
); );
}
ongoingRecoveryAttemptsRef.current.set(keyserverID, { waitingCalls: [] });
return attemptToResolveInvalidation(sessionChange);
}; };
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
options?: ?CallSingleKeyserverEndpointOptions, options?: ?CallSingleKeyserverEndpointOptions,
) => ) =>
callSingleKeyserverEndpoint( callSingleKeyserverEndpoint(
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines ): (ServerCallSelectorParams => CallSingleKeyserverEndpoint) =>
canRecoverSession, canRecoverSession,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
keyserverID, keyserverID,
}), }),
), ),
[bindCookieAndUtilsIntoCallSingleKeyserverEndpoint], [bindCookieAndUtilsIntoCallSingleKeyserverEndpoint],
); );
// SECTION 3: getBoundSingleKeyserverActionFunc // SECTION 3: getCallSingleKeyserverEndpoint
const dispatch = useDispatch(); const dispatch = useDispatch();
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const keyserverCallInfos = useKeyserverCallInfos(keyserverInfos); const keyserverCallInfos = useKeyserverCallInfos(keyserverInfos);
Show All 23 Lines const getCallSingleKeyserverEndpoint = React.useCallback(
[ [
createCallSingleKeyserverEndpointSelector, createCallSingleKeyserverEndpointSelector,
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverCallInfos, keyserverCallInfos,
], ],
); );
// SECTION 4: flush waitingCalls when sessionRecoveryInProgress flips to false
const prevKeyserverCallInfosRef = React.useRef<{
+[keyserverID: string]: KeyserverCallInfo,
}>(keyserverCallInfos);
React.useEffect(() => {
const sessionRecoveriesConcluded = new Set<string>();
const prevKeyserverCallInfos = prevKeyserverCallInfosRef.current;
for (const keyserverID in keyserverCallInfos) {
const prevKeyserverCallInfo = prevKeyserverCallInfos[keyserverID];
if (!prevKeyserverCallInfo) {
continue;
}
const keyserverCallInfo = keyserverCallInfos[keyserverID];
if (
!keyserverCallInfo.sessionRecoveryInProgress &&
prevKeyserverCallInfo.sessionRecoveryInProgress
) {
sessionRecoveriesConcluded.add(keyserverID);
}
}
for (const keyserverID of sessionRecoveriesConcluded) {
const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
const keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
continue;
}
const { waitingCalls } = keyserverRecoveryAttempts;
if (waitingCalls.length === 0) {
continue;
}
const { cookie } = keyserverCallInfos[keyserverID];
const hasUserCookie = cookie && cookie.startsWith('user=');
const boundCallSingleKeyserverEndpoint = hasUserCookie
? getCallSingleKeyserverEndpoint(keyserverID)
: null;
for (const waitingCall of waitingCalls) {
waitingCall(boundCallSingleKeyserverEndpoint);
}
}
prevKeyserverCallInfosRef.current = keyserverCallInfos;
}, [keyserverCallInfos, getCallSingleKeyserverEndpoint]);
// SECTION 5: getBoundSingleKeyserverActionFunc
const createBoundSingleKeyserverActionFuncSelector: CreateBoundSingleKeyserverActionFuncSelector = const createBoundSingleKeyserverActionFuncSelector: CreateBoundSingleKeyserverActionFuncSelector =
React.useCallback( React.useCallback(
actionFunc => actionFunc =>
createSelector( createSelector(
(params: SingleKeyserverActionFuncSelectorParams) => (params: SingleKeyserverActionFuncSelectorParams) =>
params.callSingleKeyserverEndpoint, params.callSingleKeyserverEndpoint,
actionFunc, actionFunc,
), ),
Show All 29 Lines React.useCallback(
}); });
}, },
[ [
createBoundSingleKeyserverActionFuncsCache, createBoundSingleKeyserverActionFuncsCache,
getCallSingleKeyserverEndpoint, getCallSingleKeyserverEndpoint,
], ],
); );
// SECTION 4: getBoundKeyserverActionFunc // SECTION 6: getBoundKeyserverActionFunc
const callKeyserverEndpoint = React.useCallback( const callKeyserverEndpoint = React.useCallback(
( (
endpoint: Endpoint, endpoint: Endpoint,
requests: { +[keyserverID: string]: ?{ +[string]: mixed } }, requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
options?: ?CallSingleKeyserverEndpointOptions, options?: ?CallSingleKeyserverEndpointOptions,
) => { ) => {
const makeCallToSingleKeyserver = (keyserverID: string) => { const makeCallToSingleKeyserver = (keyserverID: string) => {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines
View Options

native/socket.react.js

// @flow // @flow
import invariant from 'invariant'; import invariant from 'invariant';
import _memoize from 'lodash/memoize.js'; import _memoize from 'lodash/memoize.js';
import * as React from 'react'; import * as React from 'react';
import { createSelector } from 'reselect'; import { createSelector } from 'reselect';
import { useKeyserverCallInfos } from './keyserver-call-infos.js'; import {
useKeyserverCallInfos,
type KeyserverCallInfo,
} from './keyserver-call-infos.js';
import { import {
setNewSession, setNewSession,
type SingleKeyserverActionFunc, type SingleKeyserverActionFunc,
type ActionFunc, type ActionFunc,
setSessionRecoveryInProgressActionType,
} from './keyserver-conn-types.js'; } from './keyserver-conn-types.js';
import { import { canResolveKeyserverSessionInvalidation } from './recovery-utils.js';
canResolveKeyserverSessionInvalidation,
resolveKeyserverSessionInvalidation,
} from './recovery-utils.js';
import { logInActionSources } from '../types/account-types.js';
import type { PlatformDetails } from '../types/device-types.js'; import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js'; import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js';
import type { Dispatch } from '../types/redux-types.js'; import type { Dispatch } from '../types/redux-types.js';
import type { ClientSessionChange } from '../types/session-types.js'; import type { ClientSessionChange } from '../types/session-types.js';
import type { CurrentUserInfo } from '../types/user-types.js'; import type { CurrentUserInfo } from '../types/user-types.js';
import type { import type {
CallSingleKeyserverEndpoint, CallSingleKeyserverEndpoint,
CallSingleKeyserverEndpointOptions, CallSingleKeyserverEndpointOptions,
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesfunction CallKeyserverEndpointProvider(props: Props): React.Node {
) => CallSingleKeyserverEndpoint = React.useCallback(params => { ) => CallSingleKeyserverEndpoint = React.useCallback(params => {
const { const {
dispatch, dispatch,
cookie, cookie,
urlPrefix, urlPrefix,
sessionID, sessionID,
currentUserInfo, currentUserInfo,
isSocketConnected, isSocketConnected,
sessionRecoveryInProgress,
canRecoverSession, canRecoverSession,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
keyserverID, keyserverID,
} = params; } = params;
const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true); const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
const boundSetNewSession = ( const boundSetNewSession = (
sessionChange: ClientSessionChange, sessionChange: ClientSessionChange,
error: ?string, error: ?string,
Show All 15 Lines ) => CallSingleKeyserverEndpoint = React.useCallback(params => {
// request, to make sure that we're not in the middle of trying to recover // request, to make sure that we're not in the middle of trying to recover
// an invalidated cookie // an invalidated cookie
const waitIfCookieInvalidated = () => { const waitIfCookieInvalidated = () => {
if (!canResolveInvalidation) { if (!canResolveInvalidation) {
// If there is no way to resolve the session invalidation, // If there is no way to resolve the session invalidation,
// just let the caller callSingleKeyserverEndpoint instance continue // just let the caller callSingleKeyserverEndpoint instance continue
return Promise.resolve(null); return Promise.resolve(null);
} }
const ongoingRecoveryAttempt = if (!sessionRecoveryInProgress) {
ongoingRecoveryAttemptsRef.current.get(keyserverID);
if (!ongoingRecoveryAttempt) {
// Our cookie seems to be valid // Our cookie seems to be valid
return Promise.resolve(null); return Promise.resolve(null);
} }
const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
let keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
keyserverRecoveryAttempts = { waitingCalls: [] };
recoveryAttempts.set(keyserverID, keyserverRecoveryAttempts);
}
const ongoingRecoveryAttempts = keyserverRecoveryAttempts;
// Wait to run until we get our new cookie // Wait to run until we get our new cookie
return new Promise<?CallSingleKeyserverEndpoint>(r => return new Promise<?CallSingleKeyserverEndpoint>(r =>
ongoingRecoveryAttempt.waitingCalls.push(r), ongoingRecoveryAttempts.waitingCalls.push(r),
);
};
// These functions are helpers for cookieInvalidationRecovery, defined below
const attemptToResolveInvalidationHelper = async (
sessionChange: ClientSessionChange,
) => {
const newAnonymousCookie = sessionChange.cookie;
const newSessionChange = await resolveKeyserverSessionInvalidation(
dispatch,
newAnonymousCookie,
urlPrefix,
logInActionSources.cookieInvalidationResolutionAttempt,
keyserverID,
);
return newSessionChange
? bindCookieAndUtilsIntoCallSingleKeyserverEndpoint({
...params,
cookie: newSessionChange.cookie,
sessionID: newSessionChange.sessionID,
currentUserInfo: newSessionChange.currentUserInfo,
})
: null;
};
const attemptToResolveInvalidation = (
sessionChange: ClientSessionChange,
) => {
return new Promise<?CallSingleKeyserverEndpoint>(
// eslint-disable-next-line no-async-promise-executor
async (resolve, reject) => {
try {
const newCallSingleKeyserverEndpoint =
await attemptToResolveInvalidationHelper(sessionChange);
const ongoingRecoveryAttempt =
ongoingRecoveryAttemptsRef.current.get(keyserverID);
ongoingRecoveryAttemptsRef.current.delete(keyserverID);
const currentWaitingCalls =
ongoingRecoveryAttempt?.waitingCalls ?? [];
resolve(newCallSingleKeyserverEndpoint);
for (const func of currentWaitingCalls) {
func(newCallSingleKeyserverEndpoint);
}
} catch (e) {
reject(e);
}
},
); );
}; };
// If this function is called, callSingleKeyserverEndpoint got a response // If this function is called, callSingleKeyserverEndpoint got a response
// invalidating its cookie, and is wondering if it should just like... // invalidating its cookie, and is wondering if it should just like...
// give up? Or if there's a chance at redemption // give up? Or if there's a chance at redemption
const cookieInvalidationRecovery = ( const cookieInvalidationRecovery = (
sessionChange: ClientSessionChange, sessionChange: ClientSessionChange,
error: ?string, error: ?string,
) => { ) => {
if (!canResolveInvalidation) { if (!canResolveInvalidation) {
// When invalidation recovery is supported, we let that code call // When invalidation recovery is supported, we let that code call
// setNewSession. When it isn't supported, we call it directly here. // setNewSession. When it isn't supported, we call it directly here.
// Once usingCommServicesAccessToken is true, we should consider // Once usingCommServicesAccessToken is true, we should consider
// removing this call... see description of D10952 for details. // removing this call... see description of D10952 for details.
boundSetNewSession(sessionChange, error); boundSetNewSession(sessionChange, error);
// If there is no way to resolve the session invalidation, // If there is no way to resolve the session invalidation,
// just let the caller callSingleKeyserverEndpoint instance continue // just let the caller callSingleKeyserverEndpoint instance continue
return Promise.resolve(null); return Promise.resolve(null);
} }
if (!loggedIn) { if (!loggedIn) {
// We don't want to attempt any use native credentials of a logged out // We don't want to attempt any use native credentials of a logged out
// user to log-in after a cookieInvalidation while logged out // user to log-in after a cookieInvalidation while logged out
return Promise.resolve(null); return Promise.resolve(null);
} }
const ongoingRecoveryAttempt =
ongoingRecoveryAttemptsRef.current.get(keyserverID); const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
if (ongoingRecoveryAttempt) { let keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
keyserverRecoveryAttempts = { waitingCalls: [] };
recoveryAttempts.set(keyserverID, keyserverRecoveryAttempts);
}
if (!sessionRecoveryInProgress) {
dispatch({
type: setSessionRecoveryInProgressActionType,
payload: { sessionRecoveryInProgress: true, keyserverID },
});
}
const ongoingRecoveryAttempts = keyserverRecoveryAttempts;
return new Promise<?CallSingleKeyserverEndpoint>(r => return new Promise<?CallSingleKeyserverEndpoint>(r =>
ongoingRecoveryAttempt.waitingCalls.push(r), ongoingRecoveryAttempts.waitingCalls.push(r),
); );
}
ongoingRecoveryAttemptsRef.current.set(keyserverID, { waitingCalls: [] });
return attemptToResolveInvalidation(sessionChange);
}; };
return ( return (
endpoint: Endpoint, endpoint: Endpoint,
data: Object, data: Object,
options?: ?CallSingleKeyserverEndpointOptions, options?: ?CallSingleKeyserverEndpointOptions,
) => ) =>
callSingleKeyserverEndpoint( callSingleKeyserverEndpoint(
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines ): (ServerCallSelectorParams => CallSingleKeyserverEndpoint) =>
canRecoverSession, canRecoverSession,
lastCommunicatedPlatformDetails, lastCommunicatedPlatformDetails,
keyserverID, keyserverID,
}), }),
), ),
[bindCookieAndUtilsIntoCallSingleKeyserverEndpoint], [bindCookieAndUtilsIntoCallSingleKeyserverEndpoint],
); );
// SECTION 3: getBoundSingleKeyserverActionFunc // SECTION 3: getCallSingleKeyserverEndpoint
const dispatch = useDispatch(); const dispatch = useDispatch();
const currentUserInfo = useSelector(state => state.currentUserInfo); const currentUserInfo = useSelector(state => state.currentUserInfo);
const keyserverInfos = useSelector( const keyserverInfos = useSelector(
state => state.keyserverStore.keyserverInfos, state => state.keyserverStore.keyserverInfos,
); );
const keyserverCallInfos = useKeyserverCallInfos(keyserverInfos); const keyserverCallInfos = useKeyserverCallInfos(keyserverInfos);
Show All 23 Lines const getCallSingleKeyserverEndpoint = React.useCallback(
[ [
createCallSingleKeyserverEndpointSelector, createCallSingleKeyserverEndpointSelector,
dispatch, dispatch,
currentUserInfo, currentUserInfo,
keyserverCallInfos, keyserverCallInfos,
], ],
); );
// SECTION 4: flush waitingCalls when sessionRecoveryInProgress flips to false
const prevKeyserverCallInfosRef = React.useRef<{
+[keyserverID: string]: KeyserverCallInfo,
}>(keyserverCallInfos);
React.useEffect(() => {
const sessionRecoveriesConcluded = new Set<string>();
const prevKeyserverCallInfos = prevKeyserverCallInfosRef.current;
for (const keyserverID in keyserverCallInfos) {
const prevKeyserverCallInfo = prevKeyserverCallInfos[keyserverID];
if (!prevKeyserverCallInfo) {
continue;
}
const keyserverCallInfo = keyserverCallInfos[keyserverID];
if (
!keyserverCallInfo.sessionRecoveryInProgress &&
prevKeyserverCallInfo.sessionRecoveryInProgress
) {
sessionRecoveriesConcluded.add(keyserverID);
}
}
for (const keyserverID of sessionRecoveriesConcluded) {
const recoveryAttempts = ongoingRecoveryAttemptsRef.current;
const keyserverRecoveryAttempts = recoveryAttempts.get(keyserverID);
if (!keyserverRecoveryAttempts) {
continue;
}
const { waitingCalls } = keyserverRecoveryAttempts;
if (waitingCalls.length === 0) {
continue;
}
const { cookie } = keyserverCallInfos[keyserverID];
const hasUserCookie = cookie && cookie.startsWith('user=');
const boundCallSingleKeyserverEndpoint = hasUserCookie
? getCallSingleKeyserverEndpoint(keyserverID)
: null;
for (const waitingCall of waitingCalls) {
waitingCall(boundCallSingleKeyserverEndpoint);
}
}
prevKeyserverCallInfosRef.current = keyserverCallInfos;
}, [keyserverCallInfos, getCallSingleKeyserverEndpoint]);
// SECTION 5: getBoundSingleKeyserverActionFunc
const createBoundSingleKeyserverActionFuncSelector: CreateBoundSingleKeyserverActionFuncSelector = const createBoundSingleKeyserverActionFuncSelector: CreateBoundSingleKeyserverActionFuncSelector =
React.useCallback( React.useCallback(
actionFunc => actionFunc =>
createSelector( createSelector(
(params: SingleKeyserverActionFuncSelectorParams) => (params: SingleKeyserverActionFuncSelectorParams) =>
params.callSingleKeyserverEndpoint, params.callSingleKeyserverEndpoint,
actionFunc, actionFunc,
), ),
Show All 29 Lines React.useCallback(
}); });
}, },
[ [
createBoundSingleKeyserverActionFuncsCache, createBoundSingleKeyserverActionFuncsCache,
getCallSingleKeyserverEndpoint, getCallSingleKeyserverEndpoint,
], ],
); );
// SECTION 4: getBoundKeyserverActionFunc // SECTION 6: getBoundKeyserverActionFunc
const callKeyserverEndpoint = React.useCallback( const callKeyserverEndpoint = React.useCallback(
( (
endpoint: Endpoint, endpoint: Endpoint,
requests: { +[keyserverID: string]: ?{ +[string]: mixed } }, requests: { +[keyserverID: string]: ?{ +[string]: mixed } },
options?: ?CallSingleKeyserverEndpointOptions, options?: ?CallSingleKeyserverEndpointOptions,
) => { ) => {
const makeCallToSingleKeyserver = (keyserverID: string) => { const makeCallToSingleKeyserver = (keyserverID: string) => {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines