Page MenuHomePhabricator
Differential D11176

[lib] Add keyserverID param to getClientResponsesSelector
ClosedPublic
Actions

Authored by tomek on Feb 26 2024, 6:37 AM.
Tags
None
Referenced Files
Unknown Object (File)
Feb 16 2025, 12:18 AM
Unknown Object (File)
Feb 16 2025, 12:18 AM
Unknown Object (File)
Feb 16 2025, 12:17 AM
Unknown Object (File)
Feb 16 2025, 12:17 AM
Unknown Object (File)
Jan 30 2025, 8:28 PM
Unknown Object (File)
Jan 23 2025, 7:04 AM
Unknown Object (File)
Jan 13 2025, 8:48 AM
Unknown Object (File)
Jan 8 2025, 10:53 AM
View All 64 Files
Subscribers
ashoat

Details

Reviewers
michal
atul
inka
kamil
Commits
rCOMMc34612666172: [lib] Add keyserverID param to getClientResponsesSelector
Summary

The selector needs to be aware of the keyserver that sent a message to prepare the correct response.

https://linear.app/comm/issue/ENG-6522/provide-a-keyserver-id-to-getclientresponsesselector-function

Depends on D11144

Test Plan

Console logged the value of keyserverID in getClientResponsesSelector on both web and native

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
lib/
selectors/
4 lines
native/
selectors/
7 lines
1 line
web/
selectors/
3 lines
1 line

Diff 37645

View Options

lib/selectors/socket-selectors.js

Show All 36 Linesfunction KeyserverConnectionHandler(props: Props) {
const dispatchActionPromise = useDispatchActionPromise(); const dispatchActionPromise = useDispatchActionPromise();
const callLogOut = useLogOut(); const callLogOut = useLogOut();
const keyserverAuth = useKeyserverAuth(); const keyserverAuth = useKeyserverAuth();
const hasConnectionIssue = useSelector( const hasConnectionIssue = useSelector(
state => !!connectionSelector(keyserverID)(state)?.connectionIssue, state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
); );
const cookie = useSelector(cookieSelector(keyserverID)); const cookie = useSelector(cookieSelector(keyserverID));
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(ashoatKeyserverID),
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines void (async () => {
}, },
}), }),
); );
} catch (e) { } catch (e) {
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) {
await dispatchActionPromise(logOutActionTypes, callLogOut());
}
} finally { } finally {
authInProgress.current = false; authInProgress.current = false;
} }
})(); })();
}, [ }, [
keyserverID, keyserverID,
identityClient, identityClient,
olmSessionCreator, olmSessionCreator,
cookie, cookie,
getAuthMetadata, getAuthMetadata,
dispatchActionPromise, dispatchActionPromise,
keyserverAuth, keyserverAuth,
deviceToken, deviceToken,
calendarQuery, calendarQuery,
isUserAuthenticated, isUserAuthenticated,
callLogOut,
dataLoaded,
]); ]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== ashoatKeyserverID) {
return null; return null;
} }
return <Socket {...rest} />; return <Socket {...rest} />;
} }
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

native/selectors/socket-selectors.js

Show All 36 Linesfunction KeyserverConnectionHandler(props: Props) {
const dispatchActionPromise = useDispatchActionPromise(); const dispatchActionPromise = useDispatchActionPromise();
const callLogOut = useLogOut(); const callLogOut = useLogOut();
const keyserverAuth = useKeyserverAuth(); const keyserverAuth = useKeyserverAuth();
const hasConnectionIssue = useSelector( const hasConnectionIssue = useSelector(
state => !!connectionSelector(keyserverID)(state)?.connectionIssue, state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
); );
const cookie = useSelector(cookieSelector(keyserverID)); const cookie = useSelector(cookieSelector(keyserverID));
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(ashoatKeyserverID),
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines void (async () => {
}, },
}), }),
); );
} catch (e) { } catch (e) {
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) {
await dispatchActionPromise(logOutActionTypes, callLogOut());
}
} finally { } finally {
authInProgress.current = false; authInProgress.current = false;
} }
})(); })();
}, [ }, [
keyserverID, keyserverID,
identityClient, identityClient,
olmSessionCreator, olmSessionCreator,
cookie, cookie,
getAuthMetadata, getAuthMetadata,
dispatchActionPromise, dispatchActionPromise,
keyserverAuth, keyserverAuth,
deviceToken, deviceToken,
calendarQuery, calendarQuery,
isUserAuthenticated, isUserAuthenticated,
callLogOut,
dataLoaded,
]); ]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== ashoatKeyserverID) {
return null; return null;
} }
return <Socket {...rest} />; return <Socket {...rest} />;
} }
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

native/socket.react.js

Show All 36 Linesfunction KeyserverConnectionHandler(props: Props) {
const dispatchActionPromise = useDispatchActionPromise(); const dispatchActionPromise = useDispatchActionPromise();
const callLogOut = useLogOut(); const callLogOut = useLogOut();
const keyserverAuth = useKeyserverAuth(); const keyserverAuth = useKeyserverAuth();
const hasConnectionIssue = useSelector( const hasConnectionIssue = useSelector(
state => !!connectionSelector(keyserverID)(state)?.connectionIssue, state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
); );
const cookie = useSelector(cookieSelector(keyserverID)); const cookie = useSelector(cookieSelector(keyserverID));
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(ashoatKeyserverID),
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines void (async () => {
}, },
}), }),
); );
} catch (e) { } catch (e) {
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) {
await dispatchActionPromise(logOutActionTypes, callLogOut());
}
} finally { } finally {
authInProgress.current = false; authInProgress.current = false;
} }
})(); })();
}, [ }, [
keyserverID, keyserverID,
identityClient, identityClient,
olmSessionCreator, olmSessionCreator,
cookie, cookie,
getAuthMetadata, getAuthMetadata,
dispatchActionPromise, dispatchActionPromise,
keyserverAuth, keyserverAuth,
deviceToken, deviceToken,
calendarQuery, calendarQuery,
isUserAuthenticated, isUserAuthenticated,
callLogOut,
dataLoaded,
]); ]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== ashoatKeyserverID) {
return null; return null;
} }
return <Socket {...rest} />; return <Socket {...rest} />;
} }
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

web/selectors/socket-selectors.js

Show All 36 Linesfunction KeyserverConnectionHandler(props: Props) {
const dispatchActionPromise = useDispatchActionPromise(); const dispatchActionPromise = useDispatchActionPromise();
const callLogOut = useLogOut(); const callLogOut = useLogOut();
const keyserverAuth = useKeyserverAuth(); const keyserverAuth = useKeyserverAuth();
const hasConnectionIssue = useSelector( const hasConnectionIssue = useSelector(
state => !!connectionSelector(keyserverID)(state)?.connectionIssue, state => !!connectionSelector(keyserverID)(state)?.connectionIssue,
); );
const cookie = useSelector(cookieSelector(keyserverID)); const cookie = useSelector(cookieSelector(keyserverID));
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(ashoatKeyserverID),
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines void (async () => {
}, },
}), }),
); );
} catch (e) { } catch (e) {
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) {
await dispatchActionPromise(logOutActionTypes, callLogOut());
}
} finally { } finally {
authInProgress.current = false; authInProgress.current = false;
} }
})(); })();
}, [ }, [
keyserverID, keyserverID,
identityClient, identityClient,
olmSessionCreator, olmSessionCreator,
cookie, cookie,
getAuthMetadata, getAuthMetadata,
dispatchActionPromise, dispatchActionPromise,
keyserverAuth, keyserverAuth,
deviceToken, deviceToken,
calendarQuery, calendarQuery,
isUserAuthenticated, isUserAuthenticated,
callLogOut,
dataLoaded,
]); ]);
if (keyserverID !== ashoatKeyserverID) { if (keyserverID !== ashoatKeyserverID) {
return null; return null;
} }
return <Socket {...rest} />; return <Socket {...rest} />;
} }
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

web/socket.react.js

Loading...