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

[tunnelbroker] Split AMQP connect functionClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 44929

services/tunnelbroker/src/amqp.rs

[tunnelbroker] Split AMQP connect function
ClosedPublic
Actions

Revision Contents
Changeset List