Page MenuHomePhabricator
Differential D13315

[keyserver][lib] Update raw entry info to be thick or thin
ClosedPublic
Actions

Authored by will on Sep 12 2024, 10:26 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 1, 10:46 AM
Unknown Object (File)
Tue, Apr 1, 4:51 AM
Unknown Object (File)
Tue, Apr 1, 2:04 AM
Unknown Object (File)
Mon, Mar 31, 9:33 PM
Unknown Object (File)
Mon, Mar 31, 10:50 AM
Unknown Object (File)
Mar 8 2025, 4:45 PM
Unknown Object (File)
Mar 7 2025, 6:58 AM
Unknown Object (File)
Mar 4 2025, 11:40 AM
View All 78 Files
Subscribers
None

Details

Reviewers
ashoat
tomek
marcin
Commits
rCOMM29f7bedd375c: [keyserver][lib] Update raw entry info to be thick or thin
Summary

This updates raw entry info to be union type of either thick or thin.

Test Plan

flow check. Will test later in stack

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

will created this revision.Sep 12 2024, 10:26 PM
will added a child revision: D13316: [lib] DMOperationSpec for create entry operation.Sep 12 2024, 10:33 PM
Harbormaster completed remote builds in B31582: Diff 44115.Sep 12 2024, 10:43 PM
will requested review of this revision.Sep 12 2024, 10:43 PM
tomek accepted this revision.Sep 13 2024, 3:02 AM
tomek added inline comments.
lib/types/entry-types.js
37 ↗(On Diff #44115)

Should this be mandatory for thick threads?

51–53 ↗(On Diff #44115)
63 ↗(On Diff #44115)

Looks like it is always true.

This revision is now accepted and ready to land.Sep 13 2024, 3:02 AM
ashoat added inline comments.Sep 13 2024, 8:43 AM
lib/types/entry-types.js
37 ↗(On Diff #44115)

Agree – we can move this out of the base, and have it be t.maybe for thin and always defined for thick

38 ↗(On Diff #44115)

Do we need localID for thick?

63 ↗(On Diff #44115)

We can use tBool(true)

will added inline comments.Sep 13 2024, 1:05 PM
lib/types/entry-types.js
38 ↗(On Diff #44115)

Seemingly not? We seemingly use it for optimistic creations before it gets assigned a serverID on the keyserver. I imagine this doesn't really apply in client to client?

will added a child revision: D13339: [lib] Update entry reducer so thick entry infos are properly stored.Sep 16 2024, 1:15 AM
will updated this revision to Diff 44236.Sep 16 2024, 1:24 PM

review feedback

ashoat added inline comments.Sep 16 2024, 1:25 PM
lib/types/entry-types.js
26 ↗(On Diff #44236)

I thought we agreed we didn't need this in the base

37 ↗(On Diff #44236)

I thought we agreed we didn't need this in the base

Harbormaster completed remote builds in B31648: Diff 44236.Sep 16 2024, 1:45 PM
Closed by commit rCOMM29f7bedd375c: [keyserver][lib] Update raw entry info to be thick or thin (authored by will). · Explain WhySep 16 2024, 2:27 PM
This revision was automatically updated to reflect the committed changes.
will added a commit: rCOMM29f7bedd375c: [keyserver][lib] Update raw entry info to be thick or thin.
will added inline comments.Sep 16 2024, 4:03 PM
lib/types/entry-types.js
26 ↗(On Diff #44236)

addressing in https://linear.app/comm/issue/ENG-9303/remove-localid-from-rawentryinfobase

37 ↗(On Diff #44236)

Addressing in https://linear.app/comm/issue/ENG-9303/remove-localid-from-rawentryinfobase

Revision Contents
Changeset List

PathSize
keyserver/
src/
updaters/
2 lines
lib/
types/
80 lines

Diff 44244

View Options

keyserver/src/updaters/entry-updaters.js

Show All 15 Linesimport {
cookieSelector, cookieSelector,
deviceTokenSelector, deviceTokenSelector,
} from '../selectors/keyserver-selectors.js'; } from '../selectors/keyserver-selectors.js';
import { isLoggedInToKeyserver } from '../selectors/user-selectors.js'; import { isLoggedInToKeyserver } from '../selectors/user-selectors.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js'; import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
import type { BaseSocketProps } from '../socket/socket.react.js'; import type { BaseSocketProps } from '../socket/socket.react.js';
import { logInActionSources } from '../types/account-types.js'; import { logInActionSources } from '../types/account-types.js';
import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
import { useDispatchActionPromise } from '../utils/redux-promise-utils.js'; import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
import { useSelector } from '../utils/redux-utils.js'; import { useSelector } from '../utils/redux-utils.js';
import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
import { ashoatKeyserverID } from '../utils/validation-utils.js';
type Props = { type Props = {
...BaseSocketProps, ...BaseSocketProps,
+socketComponent: React.ComponentType<BaseSocketProps>, +socketComponent: React.ComponentType<BaseSocketProps>,
}; };
const AUTH_RETRY_DELAY_MS = 60000; const AUTH_RETRY_DELAY_MS = 60000;
const CANCELLED_ERROR = 'cancelled'; const CANCELLED_ERROR = 'cancelled';
Show All 13 Linesfunction KeyserverConnectionHandler(props: Props) {
const dataLoaded = useSelector(state => state.dataLoaded); const dataLoaded = useSelector(state => state.dataLoaded);
const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID)); const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID));
// We have an assumption that we should be always connected to Ashoat's // We have an assumption that we should be always connected to Ashoat's
// keyserver. It is possible that a token which it has is correct, so we can // keyserver. It is possible that a token which it has is correct, so we can
// try to use it. In worst case it is invalid and our push-handler will try // try to use it. In worst case it is invalid and our push-handler will try
// to fix it. // to fix it.
const ashoatKeyserverDeviceToken = useSelector( const ashoatKeyserverDeviceToken = useSelector(
deviceTokenSelector(ashoatKeyserverID), deviceTokenSelector(authoritativeKeyserverID()),
); );
const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken; const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken;
const navInfo = useSelector(state => state.navInfo); const navInfo = useSelector(state => state.navInfo);
const calendarFilters = useSelector(state => state.calendarFilters); const calendarFilters = useSelector(state => state.calendarFilters);
const calendarQuery = React.useMemo(() => { const calendarQuery = React.useMemo(() => {
const filters = filterThreadIDsInFilterList( const filters = filterThreadIDsInFilterList(
calendarFilters, calendarFilters,
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines const promise = (async () => {
return; return;
} }
console.log( console.log(
`Error while authenticating to keyserver with id ${keyserverID}`, `Error while authenticating to keyserver with id ${keyserverID}`,
e, e,
); );
if (!dataLoaded && keyserverID === ashoatKeyserverID) { if (!dataLoaded && keyserverID === authoritativeKeyserverID()) {
await dispatchActionPromise(logOutActionTypes, callLogOut()); await dispatchActionPromise(logOutActionTypes, callLogOut());
} }
} finally { } finally {
if (!cancelled) { if (!cancelled) {
await sleep(AUTH_RETRY_DELAY_MS); await sleep(AUTH_RETRY_DELAY_MS);
setAuthInProgress(false); setAuthInProgress(false);
} }
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines React.useEffect(() => {
if (authInProgress) { if (authInProgress) {
return; return;
} }
const [, cancel] = performAuth(); const [, cancel] = performAuth();
cancelPendingAuth.current = cancel; cancelPendingAuth.current = cancel;
}, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]); }, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== authoritativeKeyserverID()) {
return null; return null;
} }
return <Socket {...socketProps} />; return <Socket {...socketProps} />;
} }
const Handler: React.ComponentType<Props> = React.memo<Props>( const Handler: React.ComponentType<Props> = React.memo<Props>(
KeyserverConnectionHandler, KeyserverConnectionHandler,
); );
export default Handler; export default Handler;
View Options

lib/types/entry-types.js

Show All 15 Linesimport {
cookieSelector, cookieSelector,
deviceTokenSelector, deviceTokenSelector,
} from '../selectors/keyserver-selectors.js'; } from '../selectors/keyserver-selectors.js';
import { isLoggedInToKeyserver } from '../selectors/user-selectors.js'; import { isLoggedInToKeyserver } from '../selectors/user-selectors.js';
import { IdentityClientContext } from '../shared/identity-client-context.js'; import { IdentityClientContext } from '../shared/identity-client-context.js';
import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js'; import { OlmSessionCreatorContext } from '../shared/olm-session-creator-context.js';
import type { BaseSocketProps } from '../socket/socket.react.js'; import type { BaseSocketProps } from '../socket/socket.react.js';
import { logInActionSources } from '../types/account-types.js'; import { logInActionSources } from '../types/account-types.js';
import { authoritativeKeyserverID } from '../utils/authoritative-keyserver.js';
import { useDispatchActionPromise } from '../utils/redux-promise-utils.js'; import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
import { useSelector } from '../utils/redux-utils.js'; import { useSelector } from '../utils/redux-utils.js';
import { usingCommServicesAccessToken } from '../utils/services-utils.js'; import { usingCommServicesAccessToken } from '../utils/services-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
import { ashoatKeyserverID } from '../utils/validation-utils.js';
type Props = { type Props = {
...BaseSocketProps, ...BaseSocketProps,
+socketComponent: React.ComponentType<BaseSocketProps>, +socketComponent: React.ComponentType<BaseSocketProps>,
}; };
const AUTH_RETRY_DELAY_MS = 60000; const AUTH_RETRY_DELAY_MS = 60000;
const CANCELLED_ERROR = 'cancelled'; const CANCELLED_ERROR = 'cancelled';
Show All 13 Linesfunction KeyserverConnectionHandler(props: Props) {
const dataLoaded = useSelector(state => state.dataLoaded); const dataLoaded = useSelector(state => state.dataLoaded);
const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID)); const keyserverDeviceToken = useSelector(deviceTokenSelector(keyserverID));
// We have an assumption that we should be always connected to Ashoat's // We have an assumption that we should be always connected to Ashoat's
// keyserver. It is possible that a token which it has is correct, so we can // keyserver. It is possible that a token which it has is correct, so we can
// try to use it. In worst case it is invalid and our push-handler will try // try to use it. In worst case it is invalid and our push-handler will try
// to fix it. // to fix it.
const ashoatKeyserverDeviceToken = useSelector( const ashoatKeyserverDeviceToken = useSelector(
deviceTokenSelector(ashoatKeyserverID), deviceTokenSelector(authoritativeKeyserverID()),
); );
const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken; const deviceToken = keyserverDeviceToken ?? ashoatKeyserverDeviceToken;
const navInfo = useSelector(state => state.navInfo); const navInfo = useSelector(state => state.navInfo);
const calendarFilters = useSelector(state => state.calendarFilters); const calendarFilters = useSelector(state => state.calendarFilters);
const calendarQuery = React.useMemo(() => { const calendarQuery = React.useMemo(() => {
const filters = filterThreadIDsInFilterList( const filters = filterThreadIDsInFilterList(
calendarFilters, calendarFilters,
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines const promise = (async () => {
return; return;
} }
console.log( console.log(
`Error while authenticating to keyserver with id ${keyserverID}`, `Error while authenticating to keyserver with id ${keyserverID}`,
e, e,
); );
if (!dataLoaded && keyserverID === ashoatKeyserverID) { if (!dataLoaded && keyserverID === authoritativeKeyserverID()) {
await dispatchActionPromise(logOutActionTypes, callLogOut()); await dispatchActionPromise(logOutActionTypes, callLogOut());
} }
} finally { } finally {
if (!cancelled) { if (!cancelled) {
await sleep(AUTH_RETRY_DELAY_MS); await sleep(AUTH_RETRY_DELAY_MS);
setAuthInProgress(false); setAuthInProgress(false);
} }
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines React.useEffect(() => {
if (authInProgress) { if (authInProgress) {
return; return;
} }
const [, cancel] = performAuth(); const [, cancel] = performAuth();
cancelPendingAuth.current = cancel; cancelPendingAuth.current = cancel;
}, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]); }, [authInProgress, hasAccessToken, isUserAuthenticated, performAuth]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== authoritativeKeyserverID()) {
return null; return null;
} }
return <Socket {...socketProps} />; return <Socket {...socketProps} />;
} }
const Handler: React.ComponentType<Props> = React.memo<Props>( const Handler: React.ComponentType<Props> = React.memo<Props>(
KeyserverConnectionHandler, KeyserverConnectionHandler,
); );
export default Handler; export default Handler;