mirror of
https://github.com/mattermost/mattermost-mobile.git
synced 2026-11-16 08:01:23 +00:00
Connect the manager to the app lifecycle so late HTTP completions can never touch a destroyed database. - app/init/app.ts: initialize DraftSyncManager for every server after pending ephemeral wipes finish and before WebSocket startup. - actions/local/session/index.ts: invalidate(serverUrl) at the start of terminateSession, before client invalidation and database destruction (un-flushed outbox intent is intentionally discarded on logout). - managers/ephemeral_mode_manager: invalidate before wipeServerArtifacts and re-initialize after the server is re-added post-wipe. Checks: npm run tsc clean; eslint --quiet clean; 87 Jest tests pass across the session, ephemeral, and manager suites (no regressions). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
209 lines
7.8 KiB
TypeScript
209 lines
7.8 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 DraftSyncManager from '@managers/draft_sync_manager';
|
|
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);
|
|
|
|
// Stop draft sync before invalidating the client and destroying the database so a late
|
|
// HTTP completion cannot touch a destroyed database (invalidate is synchronous). Un-flushed
|
|
// outbox intent is intentionally discarded on logout/session termination.
|
|
DraftSyncManager.invalidate(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 {};
|
|
};
|