Page MenuHomePhabricator
Differential D11210

[lib][native] Separate out recoveryActionSources
ClosedPublic
Actions

Authored by ashoat on Mar 3 2024, 8:39 PM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 16, 8:54 AM
Unknown Object (File)
Wed, Apr 16, 8:15 AM
Unknown Object (File)
Tue, Apr 15, 11:20 PM
Unknown Object (File)
Tue, Apr 15, 9:36 PM
Unknown Object (File)
Tue, Apr 8, 8:57 PM
Unknown Object (File)
Tue, Apr 8, 8:19 PM
Unknown Object (File)
Mar 13 2025, 10:24 AM
Unknown Object (File)
Feb 20 2025, 7:45 PM
View All 68 Files
Subscribers
None

Details

Reviewers
inka
tomek
Commits
rCOMM65085cd6a6d9: [lib][native] Separate out recoveryActionSources
Summary

We'll need a RecoveryActionSource type in one of the next diffs, so I figured it made sense to separate out the enums.

Test Plan

Flow, plus this test plan I used for the whole stack: https://gist.github.com/Ashoat/75ab690d5c53cdd68a51b02e03e27c58

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
keyserver/
src/
responders/
6 lines
lib/
actions/
2 lines
12 lines
components/
13 lines
keyserver-conn/
6 lines
13 lines
reducers/
2 lines
10 lines
shared/
12 lines
socket/
10 lines
types/
32 lines
4 lines
utils/
4 lines
native/
account/
6 lines
2 lines
6 lines
data/
10 lines
redux/
6 lines
4 lines
web/
account/
2 lines

Diff 37835

View Options

keyserver/src/responders/user-responders.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/actions/siwe-actions.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/actions/user-actions.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/components/keyserver-connection-handler.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/keyserver-conn/keyserver-conn-types.js

Loading...
View Options

lib/keyserver-conn/recovery-utils.js

Loading...
View Options

lib/reducers/calendar-filters-reducer.test.js

Loading...
View Options

lib/reducers/message-reducer.js

Loading...
View Options

lib/shared/session-utils.js

Loading...
View Options

lib/socket/socket.react.js

Loading...
View Options

lib/types/account-types.js

Loading...
View Options

lib/types/session-types.js

Loading...
View Options

lib/utils/config.js

Loading...
View Options

native/account/legacy-recover-keyserver-session.js

Loading...
View Options

native/account/log-in-panel.react.js

Loading...
View Options

native/account/logged-out-modal.react.js

Loading...
View Options

native/data/sqlite-data-handler.js

Loading...
View Options

native/redux/redux-setup.js

Loading...
View Options

native/socket.react.js

Loading...
View Options

web/account/traditional-login-form.react.js

Loading...