Fix backup package download

src/_helpers/util.js

@@ -184,16 +184,21 @@ export const util = {
         }
     },
 
-    handleResponseToDownloadAsFile: function(fileName, messages, errors) {
+    handleResponseToDownloadAsFile: function(fileName) {
         return function(response) {
-            if (!response.ok) return handleCrudResponse(messages, errors)(response);
-            return downloadBlob(response.blob(), fileName);
+            return response.blob().then(blob => {
+                if (!response.ok || response.status != 200) {
+                    console.log("handleResponseToDownloadAsFile: download failes or not ready yet");
+                    return Promise.reject(response.statusText);
+                }
+                return util.downloadBlob(blob, fileName);
+            });
         };
     },
 
     handleDataToDownloadAsFile: function(fileName, mimeType) {
         return function(data) {
-            return downloadBlob(new Blob([data], {type: mimeType}), fileName);
+            return util.downloadBlob(new Blob([data], {type: mimeType}), fileName);
         };
     },
 

src/_services/network.service.js

@@ -20,7 +20,8 @@ export const networkService = {
     requestNetworkKeys,
     retrieveNetworkKeys,
     startBackupPackageDownload,
-    downloadBackupPackage,
+    backupPackageStatus,
+    backupPackageDownload,
     getNetworkBackups,
     getLogFlag, enableLog, disableLog
 };
@@ -95,18 +96,18 @@ function startBackupPackageDownload(userId, networkId, code, password, backupId)
                  util.postWithAuth({ name: 'password', value: password }))
             .then(util.handleBasicResponse);
 }
-
-function downloadBackupPackage(userId, networkId, code, messages, errors) {
-    return fetch(`${config.apiUrl}/users/${userId}/networks/${networkId}/actions/keys/${code}/backups/download`,
+function backupPackageStatus(userId, networkId, code, messages, errors) {
+    return fetch(`${config.apiUrl}/users/${userId}/networks/${networkId}/actions/keys/${code}/backups/status`,
                  util.getWithAuth())
-            .then(response => {
-                if (response.status == 202) {
-                    // accepted, but not yet done
-                    setTimeout(() => downloadBackupPackage(userId, networkId, code, messages, errors), 5000);
-                } else {
-                    return util.handleResponseToDownloadAsFile('backup.' + networkId + '.tgz.enc', messages, errors);
-                }
-            });
+            .then(util.handleCrudResponse(messages, errors));
+}
+function backupPackageDownload(userId, networkId, code, messages, errors) {
+    const getWithAuth = util.getWithAuth();
+    getWithAuth.responseType = 'blob';
+    return fetch(`${config.apiUrl}/users/${userId}/networks/${networkId}/actions/keys/${code}/backups/download`,
+                 getWithAuth)
+            .then(util.handleResponseToDownloadAsFile(`backup.${networkId}.tgz.enc`),
+                  util.handleCrudResponse(messages, errors));
 }
 
 function getNetworkBackups(userId, networkId, messages, errors) {

src/_store/networks.module.js

@@ -11,7 +11,7 @@ const state = {
         networks: false, network: false, stopping: false, restoring: false, deleting: false,
         nearestRegions: false, startingNetwork: false, networkStatuses: false, networkNodes: false,
         requestNetworkKeys: false, retrieveNetworkKeys: false, queueBackup: false, managingLogFlag: false,
-        fullBackupRequested: false
+        preparingLatestBackup: false
     },
     creating: null,
     error: null,
@@ -156,15 +156,23 @@ const actions = {
                             error => commit('retrieveNetworkKeysFailure', error));
     },
 
-    retrieveLatestBackupPackage({ commit }, {userId, networkId, code, password, messages, errors}) {
-        commit('retrieveLatestBackupPackageRequest');
+    buildLatestBackupPackage({ commit }, {userId, networkId, code, password}) {
+        commit('buildLatestBackupPackageRequest');
         networkService.startBackupPackageDownload(userId, networkId, code, password, state.backups[0].uuid)
-                      .then(ok => {
-                              networkService.downloadBackupPackage(userId, networkId, code, messages, errors)
-                                            .then(ok => commit('retrieveLatestBackupPackageSuccess'),
-                                                  error => commit('retrieveLatestBackupPackageFailure', error));
-                            },
-                            error => commit('retrieveLatestBackupPackageFailure', error));
+                .then(ok => commit('buildLatestBackupPackageSuccess'),
+                      error => commit('buildLatestBackupPackageFailure', error));
+    },
+    latestBackupBuildingStatus({ commit }, { userId, networkId, code, messages, errors }) {
+        commit('latestBackupBuildingStatusRequest');
+        networkService.backupPackageStatus(userId, networkId, code, messages, errors)
+                      .then(status => commit('latestBackupBuildingStatusSuccess', status),
+                            error => commit('latestBackupBuildingStatusFailure', error));
+    },
+    latestBackupDownload({ commit }, { userId, networkId, code, messages, errors }) {
+        commit('latestBackupDownloadRequest');
+        networkService.backupPackageDownload(userId, networkId, code, messages, errors)
+                      .then(ok => commit('latestBackupDownloadSuccess'),
+                            error => commit('latestBackupDownloadFailure', error));
     },
 
     getLogFlag({ commit }, { networkId, messages, errors }) {
@@ -353,20 +361,48 @@ const mutations = {
         state.loading.retrieveNetworkKeys = false;
         state.error = { error };
     },
-    retrieveLatestBackupPackageRequest(state) {
+
+    buildLatestBackupPackageRequest(state) {
         state.loading.retrieveNetworkKeys = true;
-        state.loading.fullBackupRequested = true;
+        state.loading.preparingLatestBackup = true;
         state.networkKeysRequested = null;
     },
-    retrieveLatestBackupPackageSuccess(state) {
+    buildLatestBackupPackageSuccess(state) {
+        // noop
+    },
+    buildLatestBackupPackageFailure(state, error) {
         state.loading.retrieveNetworkKeys = false;
-        state.loading.fullBackupRequested = false;
+        state.loading.preparingLatestBackup = false;
+        state.error = { error };
+    },
+    latestBackupBuildingStatusRequest(state) {
+        state.loading.retrieveNetworkKeys = true;
+        state.loading.preparingLatestBackup = true;
+    },
+    latestBackupBuildingStatusSuccess(state, packageBuildingStatus) {
+        if (packageBuildingStatus && packageBuildingStatus.done === true) {
+            if (packageBuildingStatus.error) {
+                return latestBackupBuildingStatusFailure(state, packageBuildingStatus.error);
+            }
+            state.loading.preparingLatestBackup = false;
+        }
     },
-    retrieveLatestBackupPackageFailure(state, error) {
+    latestBackupBuildingStatusFailure(state, error) {
         state.loading.retrieveNetworkKeys = false;
-        state.loading.fullBackupRequested = false;
+        state.loading.preparingLatestBackup = false;
         state.error = { error };
     },
+    latestBackupDownloadRequest(state) {
+        // noop
+    },
+    latestBackupDownloadSuccess(state) {
+        state.loading.retrieveNetworkKeys = false;
+    },
+    latestBackupDownloadFailure(state, error) {
+        state.loading.retrieveNetworkKeys = false;
+        state.error = { error };
+    },
+
     getNetworkBackupsRequest(state, backups) {
         state.backups = null;
     },

src/account/NetworkPage.vue

@@ -97,13 +97,13 @@
             </button>
             <span v-if="backups && backups.length > 0">
                 {{ messages.label_or }}
-                <button @click="retrieveFullBackup()" class="btn btn-primary"
+                <button @click="fullyPrepareBackupPackage()" class="btn btn-primary"
                         :disabled="loading && loading.retrieveNetworkKeys">
                     {{ messages.button_label_download_backup }}
                 </button>
             </span>
             <img v-show="loading && loading.retrieveNetworkKeys" :src="loadingImgSrc" />
-            <br/><small v-if="loading && loading.fullBackupRequested">{{ messages.label_download_backup_note }}</small>
+            <br/><small v-if="loading && preparingLatestBackup">{{ messages.label_download_backup_note }}</small>
 
             <span v-html="latestBackupInfoHtml"></span>
 
@@ -221,7 +221,8 @@
                 loadingImgSrc: loadingImgSrc,
                 checkingForUpgrade: null,
                 upgradeRefresher: null,
-                logsExpirationDays: null
+                logsExpirationDays: null,
+                backupDownloadRefresher: null
             };
         },
         computed: {
@@ -280,6 +281,9 @@
             },
             logsExpirationDaysMax: function() {
                 return 7;
+            },
+            preparingLatestBackup: function() {
+                return this.loading.preparingLatestBackup;
             }
         },
         methods: {
@@ -287,7 +291,7 @@
                 'getNetworkById', 'deleteNetwork', 'getStatusesByNetworkId', 'getNodesByNetworkId',
                 'stopNetwork', 'queueBackup', 'restoreNetwork', 'deleteNetwork', 'requestNetworkKeys',
                 'retrieveNetworkKeys', 'getBackups', 'resetRestoreKey', 'getLogFlag', 'disableLog', 'enableLog',
-                'retrieveLatestBackupPackage'
+                'buildLatestBackupPackage', 'latestBackupBuildingStatus', 'latestBackupDownload'
             ]),
             ...mapActions('system', ['getAppLinks', 'loadSystemConfigs', 'checkForUpgrade', 'upgrade']),
             refreshStatus (userId) {
@@ -395,17 +399,24 @@
                     errors: this.errors
                 });
             },
-            retrieveFullBackup () {
+            retrieveBackupPackageBuildingStatus () {
                 this.errors.clear();
-                this.retrieveLatestBackupPackage({
-                    userId: this.user.uuid,
-                    networkId: this.networkId,
-                    code: this.restoreKeyCode,
-                    password: this.restoreKeyPassword,
-                    messages: this.messages,
-                    errors: this.errors
-                });
+                this.latestBackupBuildingStatus({ userId: this.user.uuid, networkId: this.networkId,
+                                                  code: this.restoreKeyCode, messages: this.messages,
+                                                  errors: this.errors });
             },
+            fullyPrepareBackupPackage () {
+                this.errors.clear();
+                this.buildLatestBackupPackage({ userId: this.user.uuid, networkId: this.networkId,
+                                                code: this.restoreKeyCode, password: this.restoreKeyPassword});
+                this.backupDownloadRefresher = setInterval(this.retrieveBackupPackageBuildingStatus, 5000);
+            },
+            retrieveBackupPackage () {
+                this.errors.clear();
+                this.latestBackupDownload({ userId: this.user.uuid, networkId: this.networkId,
+                                            code: this.restoreKeyCode, messages: this.messages, errors: this.errors });
+            },
+
             disableLogs () {
                 this.errors.clear();
                 this.disableLog({ networkId: this.networkId, messages: this.messages, errors: this.errors });
@@ -430,6 +441,7 @@
         beforeDestroy () {
             this.clearRefresherInterval(this.refresher);
             this.clearRefresherInterval(this.stopRefresher);
+            this.clearRefresherInterval(this.backupDownloadRefresher);
             this.resetRestoreKey();
         },
         watch: {
@@ -519,6 +531,12 @@
                         this.checkingForUpgrade = false;
                     }, 10000);
                 }
+            },
+            preparingLatestBackup (isStillPreparing) {
+                if (this.backupDownloadRefresher && isStillPreparing === false) {
+                    this.clearRefresherInterval(this.backupDownloadRefresher);
+                    this.retrieveBackupPackage();
+                }
             }
         }
     };