Fixed: Re-newed import/export request failed immediately if the previous failed

changelog.d/20241106_095739_sekachev.bs_fixed_exception_1.md

@@ -0,0 +1,4 @@
+### Fixed
+
+- Fixed issue 'Cannot read properties of undefined (reading 'push')'
+  (<https://github.com/cvat-ai/cvat/pull/8648>)

changelog.d/20241106_112907_sekachev.bs_fixed_exception_2.md

@@ -0,0 +1,4 @@
+### Fixed
+
+- Re-newed import/export request failed immediately if the previous failed
+  (<https://github.com/cvat-ai/cvat/pull/XXXX>)

cvat-core/src/requests-manager.ts

@@ -34,7 +34,7 @@ class RequestsManager {
         requestDelayIdx: number | null,
         request: Request | null,
         timeout: number | null;
-        promise?: Promise<Request>;
+        promise: Promise<Request>;
     }>;
 
     private requestStack: number[];
@@ -71,6 +71,7 @@ class RequestsManager {
             }
             return this.listening[requestID].promise;
         }
+
         const promise = new Promise<Request>((resolve, reject) => {
             const timeoutCallback = async (): Promise<void> => {
                 // We make sure that no more than REQUESTS_COUNT requests are sent simultaneously
@@ -131,27 +132,29 @@ class RequestsManager {
                                     message: `Could not get a status of the request ${requestID}. ${error.toString()}`,
                                 })));
                         }
+
+                        delete this.listening[requestID];
                         reject(error);
                     }
                 }
             };
 
-            if (initialRequest?.status === RQStatus.FAILED) {
-                reject(new RequestError(initialRequest?.message));
-            } else {
-                this.listening[requestID] = {
-                    onUpdate: callback ? [callback] : [],
-                    timeout: window.setTimeout(timeoutCallback),
-                    request: initialRequest,
-                    requestDelayIdx: 0,
-                };
-            }
+            Promise.resolve().then(() => {
+                // running as microtask to make sure "promise" was initialized
+                if (initialRequest?.status === RQStatus.FAILED) {
+                    reject(new RequestError(initialRequest?.message));
+                } else {
+                    this.listening[requestID] = {
+                        onUpdate: callback ? [callback] : [],
+                        timeout: window.setTimeout(timeoutCallback),
+                        request: initialRequest,
+                        requestDelayIdx: 0,
+                        promise,
+                    };
+                }
+            });
         });
 
-        this.listening[requestID] = {
-            ...this.listening[requestID],
-            promise,
-        };
         return promise;
     }
 

cvat-ui/src/actions/export-actions.ts

@@ -4,11 +4,12 @@
 // SPDX-License-Identifier: MIT
 
 import { ActionUnion, createAction, ThunkAction } from 'utils/redux';
-
-import { Storage, ProjectOrTaskOrJob, Job } from 'cvat-core-wrapper';
 import {
-    getInstanceType, RequestInstanceType, listen, RequestsActions,
-    shouldListenForProgress,
+    Storage, ProjectOrTaskOrJob, Job, getCore, StorageLocation,
+} from 'cvat-core-wrapper';
+import {
+    getInstanceType, RequestInstanceType, listen,
+    RequestsActions, updateRequestProgress,
 } from './requests-actions';
 
 export enum ExportActionTypes {
@@ -24,6 +25,8 @@ export enum ExportActionTypes {
     EXPORT_BACKUP_FAILED = 'EXPORT_BACKUP_FAILED',
 }
 
+const core = getCore();
+
 export const exportActions = {
     openExportDatasetModal: (instance: ProjectOrTaskOrJob) => (
         createAction(ExportActionTypes.OPEN_EXPORT_DATASET_MODAL, { instance })
@@ -75,52 +78,33 @@ export const exportActions = {
     ),
 };
 
-export async function listenExportDatasetAsync(
-    rqID: string,
-    dispatch: (action: ExportActions | RequestsActions) => void,
-    params: {
-        instance: ProjectOrTaskOrJob | RequestInstanceType,
-        format: string,
-        saveImages: boolean,
-    },
-): Promise<void> {
-    const { instance, format, saveImages } = params;
-    const resource = saveImages ? 'dataset' : 'annotations';
-
-    const instanceType = getInstanceType(instance);
-    try {
-        const result = await listen(rqID, dispatch);
-        const target = !result?.url ? 'cloudstorage' : 'local';
-        dispatch(exportActions.exportDatasetSuccess(
-            instance, instanceType, format, resource, target,
-        ));
-    } catch (error) {
-        dispatch(exportActions.exportDatasetFailed(instance, instanceType, format, resource, error));
-    }
-}
-
+/** *
+ * Function is supposed to be used when a new dataset export request initiated by a user
+** */
 export const exportDatasetAsync = (
     instance: ProjectOrTaskOrJob,
     format: string,
     saveImages: boolean,
     useDefaultSettings: boolean,
     targetStorage: Storage,
     name?: string,
-): ThunkAction => async (dispatch, getState) => {
-    const state = getState();
-
+): ThunkAction => async (dispatch) => {
     const resource = saveImages ? 'dataset' : 'annotations';
     const instanceType = getInstanceType(instance);
 
     try {
         const rqID = await instance.annotations
             .exportDataset(format, saveImages, useDefaultSettings, targetStorage, name);
-        if (shouldListenForProgress(rqID, state.requests)) {
-            await listenExportDatasetAsync(rqID, dispatch, {
-                instance, format, saveImages,
+
+        if (rqID) {
+            await core.requests.listen(rqID, {
+                callback: (updatedRequest) => updateRequestProgress(updatedRequest, dispatch),
             });
-        }
-        if (!rqID) {
+            const target = targetStorage.location === StorageLocation.LOCAL ? 'local' : 'cloudstorage';
+            dispatch(exportActions.exportDatasetSuccess(
+                instance, instanceType, format, resource, target,
+            ));
+        } else {
             dispatch(exportActions.exportDatasetSuccess(
                 instance, instanceType, format, resource,
             ));
@@ -130,47 +114,79 @@ export const exportDatasetAsync = (
     }
 };
 
-export async function listenExportBackupAsync(
+/** *
+ * Function is supposed to be used when a new backup export request initiated by a user
+** */
+export const exportBackupAsync = (
+    instance: Exclude<ProjectOrTaskOrJob, Job>,
+    targetStorage: Storage,
+    useDefaultSetting: boolean,
+    fileName: string,
+): ThunkAction => async (dispatch) => {
+    const instanceType = getInstanceType(instance) as 'project' | 'task';
+    try {
+        const rqID = await instance.backup(targetStorage, useDefaultSetting, fileName);
+        if (rqID) {
+            await core.requests.listen(rqID, {
+                callback: (updatedRequest) => updateRequestProgress(updatedRequest, dispatch),
+            });
+            const target = targetStorage.location === StorageLocation.LOCAL ? 'local' : 'cloudstorage';
+            dispatch(exportActions.exportBackupSuccess(instance, instanceType, target));
+        } else {
+            dispatch(exportActions.exportBackupSuccess(instance, instanceType));
+        }
+    } catch (error) {
+        dispatch(exportActions.exportBackupFailed(instance, instanceType, error as Error));
+    }
+};
+
+/** *
+ * Function is supposed to be used when application starts listening to existing dataset export request
+** */
+export async function listenExportDatasetAsync(
     rqID: string,
     dispatch: (action: ExportActions | RequestsActions) => void,
     params: {
-        instance: Exclude<ProjectOrTaskOrJob, Job> | RequestInstanceType,
+        instance: ProjectOrTaskOrJob | RequestInstanceType,
+        format: string,
+        saveImages: boolean,
     },
 ): Promise<void> {
-    const { instance } = params;
-    const instanceType = getInstanceType(instance) as 'project' | 'task';
+    const { instance, format, saveImages } = params;
+    const resource = saveImages ? 'dataset' : 'annotations';
 
+    const instanceType = getInstanceType(instance);
     try {
         const result = await listen(rqID, dispatch);
         const target = !result?.url ? 'cloudstorage' : 'local';
-        dispatch(exportActions.exportBackupSuccess(instance, instanceType, target));
+        dispatch(exportActions.exportDatasetSuccess(
+            instance, instanceType, format, resource, target,
+        ));
     } catch (error) {
-        dispatch(exportActions.exportBackupFailed(instance, instanceType, error as Error));
+        dispatch(exportActions.exportDatasetFailed(instance, instanceType, format, resource, error));
     }
 }
 
-export const exportBackupAsync = (
-    instance: Exclude<ProjectOrTaskOrJob, Job>,
-    targetStorage: Storage,
-    useDefaultSetting: boolean,
-    fileName: string,
-): ThunkAction => async (dispatch, getState) => {
-    const state = getState();
-
+/** *
+ * Function is supposed to be used when application starts listening to existing backup export request
+** */
+export async function listenExportBackupAsync(
+    rqID: string,
+    dispatch: (action: ExportActions | RequestsActions) => void,
+    params: {
+        instance: Exclude<ProjectOrTaskOrJob, Job> | RequestInstanceType,
+    },
+): Promise<void> {
+    const { instance } = params;
     const instanceType = getInstanceType(instance) as 'project' | 'task';
 
     try {
-        const rqID = await instance
-            .backup(targetStorage, useDefaultSetting, fileName);
-        if (shouldListenForProgress(rqID, state.requests)) {
-            await listenExportBackupAsync(rqID, dispatch, { instance });
-        }
-        if (!rqID) {
-            dispatch(exportActions.exportBackupSuccess(instance, instanceType));
-        }
+        const result = await listen(rqID, dispatch);
+        const target = !result?.url ? 'cloudstorage' : 'local';
+        dispatch(exportActions.exportBackupSuccess(instance, instanceType, target));
     } catch (error) {
         dispatch(exportActions.exportBackupFailed(instance, instanceType, error as Error));
     }
-};
+}
 
 export type ExportActions = ActionUnion<typeof exportActions>;