mirror of
https://github.com/mattermost/mattermost-mobile.git
synced 2026-11-18 09:28:16 +00:00
* implements auto cache cleanup when zero persistence mode is enabled (0 value) * uses memory flag with sqlite instead of loki when running in zero persistence mode * renames ephemeral mode manager and improves readability * zero persistence refactors and restore values during transitions * fixes ephemeral mode tests * use initializeClient instead of just initialize to wait for doReconnect to finish that way teams loading is awaited while WS reconnects during ZPM transitions * adds inital sync as a mount hook to prevent undesired load error states during app cold start in ZPM mode, we need a way to load team and channels without showing loading error during the transition. The nre is initial sync hook allows for it * reset started sync subject on wipe * removes extra log lines * resets tracked server during ephemeral mode transitions * improvements to apply persistence mode changes when something fails * address coderabbit PR suggestions * add batching time logging * throws ephemeral mode change error as is * make deleteServerDatabaseFiles private * inline derive persistence flag function * return current user id when refetching current user * support zero persistence mode server for push notifications * adds support for zero persistence mode when sharing to mattermost * adds clarifying comment * catch and log error deleting files * reorder translations to correct position * adds some new tests to improve coverage * ios push notification native fix * logout when fetchMe fails with 401 status code during reconnection * properly surface errors * return proper false value when checking for zero persistence flag * change comments and properly await on some operations * prevent not set persistence mode to report as an error Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * include servers with no persistence flag set in share list * disable button for accessibility Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * improves when to store and remove signing key from global area * review push notification reception running in zero persistence mode * add server to ephemeral mode manager right after login --------- Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
203 lines
7.4 KiB
TypeScript
203 lines
7.4 KiB
TypeScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
import NetInfo from '@react-native-community/netinfo';
|
|
import {Platform} from 'react-native';
|
|
|
|
import {removePushDisabledInServerAcknowledged, removePushSigningKey} from '@actions/app/global';
|
|
import {clearConversationCacheForServer} from '@agents/actions/remote/conversation';
|
|
import streamingStore from '@agents/store/streaming_store';
|
|
import {SYSTEM_IDENTIFIERS} from '@constants/database';
|
|
import DatabaseManager from '@database/manager';
|
|
import {resetMomentLocale} from '@i18n';
|
|
import {getAllServerCredentials, removeServerCredentials} from '@init/credentials';
|
|
import PushNotifications from '@init/push_notifications';
|
|
import NetworkManager from '@managers/network_manager';
|
|
import WebsocketManager from '@managers/websocket_manager';
|
|
import {getDeviceToken} from '@queries/app/global';
|
|
import {getExpiredSession} from '@queries/servers/system';
|
|
import {getCurrentUser} from '@queries/servers/user';
|
|
import EphemeralStore from '@store/ephemeral_store';
|
|
import {deleteFileCache, deleteFileCacheByDir} from '@utils/file';
|
|
import {logError, logWarning} from '@utils/log';
|
|
import {clearCookiesForServer, getCSRFFromCookie, urlSafeBase64Encode} from '@utils/security';
|
|
|
|
const resetLocale = async () => {
|
|
if (Object.keys(DatabaseManager.serverDatabases).length) {
|
|
const serverDatabase = await DatabaseManager.getActiveServerDatabase();
|
|
const user = await getCurrentUser(serverDatabase!);
|
|
resetMomentLocale(user?.locale);
|
|
} else {
|
|
resetMomentLocale();
|
|
}
|
|
};
|
|
|
|
export async function findSession(serverUrl: string, sessions: Session[]) {
|
|
try {
|
|
const {database} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const expiredSession = await getExpiredSession(database);
|
|
const deviceToken = await getDeviceToken();
|
|
|
|
// First try and find the session by the given identifier
|
|
let session = sessions.find((s) => s.id === expiredSession?.id);
|
|
if (session) {
|
|
return session;
|
|
}
|
|
|
|
// Next try and find the session by deviceId
|
|
if (deviceToken) {
|
|
session = sessions.find((s) => s.device_id === deviceToken);
|
|
if (session) {
|
|
return session;
|
|
}
|
|
}
|
|
|
|
// Next try and find the session by the CSRF token
|
|
const csrfToken = await getCSRFFromCookie(serverUrl);
|
|
if (csrfToken) {
|
|
session = sessions.find((s) => s.props?.csrf === csrfToken);
|
|
if (session) {
|
|
return session;
|
|
}
|
|
}
|
|
|
|
// Next try and find the session based on the OS
|
|
// if multiple sessions exists with the same os type this can be inaccurate
|
|
session = sessions.find((s) => s.props?.os.toLowerCase() === Platform.OS);
|
|
if (session) {
|
|
return session;
|
|
}
|
|
} catch (e) {
|
|
logError('findSession', e);
|
|
}
|
|
|
|
// At this point we did not find the session
|
|
return undefined;
|
|
}
|
|
|
|
export const cancelAllSessionNotifications = async () => {
|
|
const serverCredentials = await getAllServerCredentials();
|
|
for (const {serverUrl} of serverCredentials) {
|
|
cancelSessionNotification(serverUrl);
|
|
}
|
|
};
|
|
|
|
export const cancelSessionNotification = async (serverUrl: string) => {
|
|
try {
|
|
const {database, operator} = DatabaseManager.getServerDatabaseAndOperator(serverUrl);
|
|
const expiredSession = await getExpiredSession(database);
|
|
const rechable = (await NetInfo.fetch()).isInternetReachable;
|
|
|
|
if (expiredSession?.notificationId && rechable) {
|
|
PushNotifications.cancelScheduleNotification(parseInt(expiredSession.notificationId, 10));
|
|
operator.handleSystem({
|
|
systems: [{
|
|
id: SYSTEM_IDENTIFIERS.SESSION_EXPIRATION,
|
|
value: '',
|
|
}],
|
|
prepareRecordsOnly: false,
|
|
});
|
|
}
|
|
|
|
return {};
|
|
} catch (e) {
|
|
logError('cancelSessionNotification', e);
|
|
return {error: e};
|
|
}
|
|
};
|
|
|
|
export const terminateSession = async (serverUrl: string, removeServer: boolean) => {
|
|
const errors: Array<{operation: string; error: unknown}> = [];
|
|
|
|
// Helper to safely execute operations and optionally track errors
|
|
const safeExecute = async (operation: string, fn: () => Promise<unknown>, critical = true) => {
|
|
try {
|
|
const result = await fn();
|
|
|
|
// Check if function returned {error}
|
|
if (result && typeof result === 'object' && 'error' in result && critical) {
|
|
errors.push({operation, error: result.error});
|
|
}
|
|
} catch (error) {
|
|
if (critical) {
|
|
errors.push({operation, error});
|
|
} else {
|
|
// Log but don't track as failure
|
|
logWarning(`terminateSession: ${operation} failed (non-critical)`, error);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Cancel session notification (critical)
|
|
await safeExecute('cancelSessionNotification', async () => {
|
|
await cancelSessionNotification(serverUrl);
|
|
}, false);
|
|
|
|
// Remove server credentials (critical)
|
|
await safeExecute('removeServerCredentials', async () => {
|
|
await removeServerCredentials(serverUrl);
|
|
});
|
|
|
|
// Remove push notifications (synchronous, no error handling needed)
|
|
PushNotifications.removeServerNotifications(serverUrl);
|
|
|
|
// Invalidate clients (websocket waits for close event before destroying)
|
|
await safeExecute('invalidateNetworkClient', async () => {
|
|
NetworkManager.invalidateClient(serverUrl);
|
|
});
|
|
await safeExecute('invalidateWebsocketClient', async () => {
|
|
await WebsocketManager.invalidateClient(serverUrl);
|
|
});
|
|
|
|
EphemeralStore.clearManagedCategoryPropertyIds(serverUrl);
|
|
|
|
// Drop ephemeral agents caches for this server only; other connected
|
|
// servers must keep their cached conversations and in-flight streams.
|
|
clearConversationCacheForServer(serverUrl);
|
|
streamingStore.removeServer(serverUrl);
|
|
|
|
// Remove push disabled acknowledgment (non-critical)
|
|
if (removeServer) {
|
|
await safeExecute('removePushDisabledInServerAcknowledged', async () => {
|
|
const result = await removePushDisabledInServerAcknowledged(urlSafeBase64Encode(serverUrl));
|
|
if (result && typeof result === 'object' && 'error' in result) {
|
|
throw result.error;
|
|
}
|
|
}, false);
|
|
await safeExecute('removePushSigningKey', async () => {
|
|
const result = await removePushSigningKey(serverUrl);
|
|
if (result && typeof result === 'object' && 'error' in result) {
|
|
throw result.error;
|
|
}
|
|
}, false);
|
|
}
|
|
|
|
// Database operations (critical)
|
|
await safeExecute('databaseOperation', async () => {
|
|
if (removeServer) {
|
|
await DatabaseManager.destroyServerDatabase(serverUrl);
|
|
} else {
|
|
await DatabaseManager.deleteServerDatabase(serverUrl);
|
|
}
|
|
});
|
|
|
|
// Reset locale (non-critical)
|
|
await safeExecute('resetLocale', async () => {
|
|
await resetLocale();
|
|
}, false);
|
|
|
|
// Clear cookies (synchronous)
|
|
clearCookiesForServer(serverUrl);
|
|
|
|
// Delete file caches (synchronous, no error handling needed)
|
|
deleteFileCache(serverUrl);
|
|
deleteFileCacheByDir('mmPasteInput');
|
|
deleteFileCacheByDir('thumbnails');
|
|
|
|
if (errors.length > 0) {
|
|
return {error: errors};
|
|
}
|
|
|
|
return {};
|
|
};
|