Page MenuHomePhabricator
Differential D11344

[native][rust] Split download_backup to separate ct1 and ct2
ClosedPublic
Actions

Authored by bartek on Mar 18 2024, 3:55 AM.
Tags
None
Referenced Files
F6196134: D11344.id.diff
Wed, Apr 23, 2:49 PM
F6182496: D11344.id38253.diff
Wed, Apr 23, 7:50 AM
Unknown Object (File)
Tue, Apr 22, 8:03 PM
Unknown Object (File)
Tue, Apr 22, 1:47 PM
Unknown Object (File)
Sun, Apr 6, 8:58 AM
Unknown Object (File)
Mar 22 2025, 11:37 PM
Unknown Object (File)
Feb 27 2025, 7:26 PM
Unknown Object (File)
Feb 27 2025, 7:26 PM
View All 68 Files
Subscribers
ashoat
tomek

Details

Reviewers
michal
kamil
Commits
rCOMMc51241adca50: [native][rust] Split download_backup to separate ct1 and ct2
Summary

In secondary device auth, we only need to restore backup data (ct2) so I need to separate it in the download_backup()

Depends on D11332

Test Plan

Backup restoration still works as before - checked it via the backup dev menu.

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
native/
native_rust_library/
src/
40 lines

Diff 38115

View Options

native/native_rust_library/src/backup.rs

Show All 23 Lines
function reduceIntegrityStore( function reduceIntegrityStore(
state: IntegrityStore, state: IntegrityStore,
action: BaseAction, action: BaseAction,
threadInfos: { threadInfos: {
+[string]: RawThreadInfo, +[string]: RawThreadInfo,
}, },
threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>, threadStoreOperations: $ReadOnlyArray<ThreadStoreOperation>,
): IntegrityStore { ): {
+integrityStore: IntegrityStore,
+integrityStoreOperations: $ReadOnlyArray<IntegrityStoreOperation>,
} {
if (action.type === fullStateSyncActionType) { if (action.type === fullStateSyncActionType) {
const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' }; const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' };
const threadHashesArray = Object.entries(state.threadHashes).filter( const threadHashesArray = Object.entries(state.threadHashes).filter(
([key]) => extractKeyserverIDFromID(key) !== action.payload.keyserverID, ([key]) => extractKeyserverIDFromID(key) !== action.payload.keyserverID,
); );
const threadHashes = Object.fromEntries(threadHashesArray);
const replaceOperation = { const replaceOperation = {
type: 'replace_integrity_thread_hashes', type: 'replace_integrity_thread_hashes',
payload: { threadHashes }, payload: { threadHashes: Object.fromEntries(threadHashesArray) },
}; };
return { return {
integrityStore: {
threadHashes: processStoreOps(state, [ threadHashes: processStoreOps(state, [
removeAllOperation, removeAllOperation,
replaceOperation, replaceOperation,
]).threadHashes, ]).threadHashes,
threadHashingStatus: 'starting', threadHashingStatus: 'starting',
},
integrityStoreOperations: [removeAllOperation, replaceOperation],
}; };
} else if ( } else if (
action.type === logInActionTypes.success || action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success || action.type === siweAuthActionTypes.success ||
action.type === keyserverRegisterActionTypes.success || action.type === keyserverRegisterActionTypes.success ||
(action.type === setClientDBStoreActionType && (action.type === setClientDBStoreActionType &&
!!action.payload.threadStore && !!action.payload.threadStore &&
state.threadHashingStatus !== 'completed') state.threadHashingStatus !== 'completed')
) { ) {
const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' }; const removeAllOperation = { type: 'remove_all_integrity_thread_hashes' };
return { return {
integrityStore: {
threadHashes: processStoreOps(state, [removeAllOperation]).threadHashes, threadHashes: processStoreOps(state, [removeAllOperation]).threadHashes,
threadHashingStatus: 'starting', threadHashingStatus: 'starting',
},
integrityStoreOperations: [removeAllOperation],
}; };
} else if (action.type === keyserverAuthActionTypes.success) { } else if (action.type === keyserverAuthActionTypes.success) {
return { return {
integrityStore: {
threadHashes: processStoreOps(state, []).threadHashes, threadHashes: processStoreOps(state, []).threadHashes,
threadHashingStatus: 'starting', threadHashingStatus: 'starting',
},
integrityStoreOperations: [],
}; };
} }
let newState = state; let newState = state;
const integrityOperations: IntegrityStoreOperation[] = [];
if (action.type === updateIntegrityStoreActionType) { if (action.type === updateIntegrityStoreActionType) {
if (action.payload.threadIDsToHash) { if (action.payload.threadIDsToHash) {
const newThreadHashes = Object.fromEntries( const newThreadHashes = Object.fromEntries(
action.payload.threadIDsToHash action.payload.threadIDsToHash
.map(id => [id, threadInfos[id]]) .map(id => [id, threadInfos[id]])
.filter(([, info]) => !!info) .filter(([, info]) => !!info)
.map(([id, info]) => [id, hash(info)]), .map(([id, info]) => [id, hash(info)]),
); );
const replaceOperation = { const replaceOperation = {
type: 'replace_integrity_thread_hashes', type: 'replace_integrity_thread_hashes',
payload: { threadHashes: newThreadHashes }, payload: { threadHashes: newThreadHashes },
}; };
newState = processStoreOps(state, [replaceOperation]); newState = processStoreOps(state, [replaceOperation]);
integrityOperations.push(replaceOperation);
} }
if (action.payload.threadHashingStatus) { if (action.payload.threadHashingStatus) {
newState = { newState = {
...newState, ...newState,
threadHashingStatus: action.payload.threadHashingStatus, threadHashingStatus: action.payload.threadHashingStatus,
}; };
} }
} }
if (threadStoreOperations.length === 0) { if (threadStoreOperations.length === 0) {
return newState; return {
integrityStore: newState,
integrityStoreOperations: integrityOperations,
};
} }
const integrityOperations: IntegrityStoreOperation[] = [];
let threadHashingStatus = newState.threadHashingStatus; let threadHashingStatus = newState.threadHashingStatus;
for (const operation of threadStoreOperations) { for (const operation of threadStoreOperations) {
if (operation.type === 'replace') { if (operation.type === 'replace') {
const newIntegrityThreadHash = hash(operation.payload.threadInfo); const newIntegrityThreadHash = hash(operation.payload.threadInfo);
integrityOperations.push({ integrityOperations.push({
type: 'replace_integrity_thread_hashes', type: 'replace_integrity_thread_hashes',
payload: { payload: {
threadHashes: { [operation.payload.id]: newIntegrityThreadHash }, threadHashes: { [operation.payload.id]: newIntegrityThreadHash },
}, },
}); });
} else if (operation.type === 'remove') { } else if (operation.type === 'remove') {
for (const id of operation.payload.ids) { for (const id of operation.payload.ids) {
integrityOperations.push({ integrityOperations.push({
type: 'remove_integrity_thread_hashes', type: 'remove_integrity_thread_hashes',
payload: { ids: [id] }, payload: { ids: [id] },
}); });
} }
} else if (operation.type === 'remove_all') { } else if (operation.type === 'remove_all') {
integrityOperations.push({ type: 'remove_all_integrity_thread_hashes' }); integrityOperations.push({ type: 'remove_all_integrity_thread_hashes' });
threadHashingStatus = 'completed'; threadHashingStatus = 'completed';
} }
} }
return { return {
...newState, integrityStore: {
threadHashes: processStoreOps(newState, integrityOperations).threadHashes, threadHashes: processStoreOps(newState, integrityOperations).threadHashes,
threadHashingStatus, threadHashingStatus,
},
integrityStoreOperations: integrityOperations,
}; };
} }
export { reduceIntegrityStore }; export { reduceIntegrityStore };