Page MenuHomePhabricator
Differential D13605

[tunnelbroker] Refactor Websocket session init
ClosedPublic
Actions

Authored by bartek on Oct 3 2024, 1:36 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Apr 7, 7:43 PM
Unknown Object (File)
Wed, Apr 2, 3:21 AM
Unknown Object (File)
Mar 11 2025, 3:55 PM
Unknown Object (File)
Mar 11 2025, 3:53 PM
Unknown Object (File)
Mar 11 2025, 3:41 PM
Unknown Object (File)
Mar 11 2025, 3:38 PM
Unknown Object (File)
Mar 11 2025, 3:37 PM
Unknown Object (File)
Mar 3 2025, 6:18 AM
View All Files
Subscribers
ashoat
tomek

Details

Reviewers
kamil
varun
will
Commits
rCOMMb43e6708eee6: [tunnelbroker] Refactor Websocket session init
Summary

Separated AMQP and DeviceInfo/auth logic from initiate_session(). Moved channel creation deeper into WebsocketSession::init_amqp()

Depends on D13604

Test Plan

cargo build

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

bartek created this revision.Oct 3 2024, 1:36 PM
bartek held this revision as a draft.
Herald added subscribers: tomek, ashoat. · View Herald TranscriptOct 3 2024, 1:36 PM
bartek added a child revision: D13606: [tunnelbroker] Recover AMQP consumers.Oct 3 2024, 1:37 PM
Harbormaster completed remote builds in B32056: Diff 44885.Oct 3 2024, 2:06 PM
bartek updated this revision to Diff 44894.Oct 4 2024, 3:27 AM

Rebase

Harbormaster completed remote builds in B32063: Diff 44894.Oct 4 2024, 3:45 AM
bartek edited the summary of this revision. (Show Details)Oct 4 2024, 3:53 AM
bartek edited the test plan for this revision. (Show Details)
bartek edited the summary of this revision. (Show Details)
bartek updated this revision to Diff 44902.Oct 4 2024, 8:17 AM

Remove connection pool

bartek published this revision for review.Oct 4 2024, 8:38 AM
Harbormaster completed remote builds in B32070: Diff 44902.Oct 4 2024, 8:42 AM
kamil accepted this revision.EditedOct 7 2024, 2:04 AM

Looks a lot cleaner now

services/tunnelbroker/src/websockets/session.rs
204 ↗(On Diff #44902)

I would prefer something like get_device_info_from_frame

This revision is now accepted and ready to land.Oct 7 2024, 2:04 AM
bartek updated this revision to Diff 44923.Oct 7 2024, 7:06 AM

Rename

Harbormaster completed remote builds in B32087: Diff 44923.Oct 7 2024, 7:25 AM
Closed by commit rCOMMb43e6708eee6: [tunnelbroker] Refactor Websocket session init (authored by bartek). · Explain WhyOct 7 2024, 7:28 AM
This revision was automatically updated to reflect the committed changes.
bartek added a commit: rCOMMb43e6708eee6: [tunnelbroker] Refactor Websocket session init.

Revision Contents
Changeset List

PathSize
services/
tunnelbroker/
src/
websockets/
37 lines
79 lines

Diff 44934

View Options

services/tunnelbroker/src/websockets/mod.rs

// @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

services/tunnelbroker/src/websockets/session.rs

// @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