Remove redundant `Promise` wrapper from API calls

The 'axios' API Caller returns a promise so it is no longer necessary to
wrap the API calls with a `Promise`.

This also includes using `Promise.all` when depending on multiple API
call responses.

src/components/pages/AssessmentsPage/AssessmentsPage.jsx

@@ -49,6 +49,8 @@ class AssessmentsPage extends React.Component<Props, State> {
   }
 
   componentWillMount() {
+    document.title = 'Coriolis Planning'
+
     projectStore.getProjects()
 
     if (!azureStore.isLoadedForCurrentProject()) {

src/sources/AssessmentSource.js

@@ -38,66 +38,49 @@ class AssessmentSourceUtils {
 
 class AssessmentSource {
   static migrate(data: MigrationInfo): Promise<MainItem> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let useReplicaField = data.options.find(o => o.name === 'use_replica')
-      let type = useReplicaField && useReplicaField.value ? 'replica' : 'migration'
-      let payload = {}
-      payload[type] = {
-        origin_endpoint_id: data.source ? data.source.id : 'null',
-        destination_endpoint_id: data.target.id,
-        destination_environment: AssessmentSourceUtils.getDestinationEnv(data),
-        instances: data.selectedInstances.map(i => i.instance_name),
-        notes: '',
-        security_groups: ['testgroup'],
-      }
+    let projectId = cookie.get('projectId')
+    let useReplicaField = data.options.find(o => o.name === 'use_replica')
+    let type = useReplicaField && useReplicaField.value ? 'replica' : 'migration'
+    let payload = {}
+    payload[type] = {
+      origin_endpoint_id: data.source ? data.source.id : 'null',
+      destination_endpoint_id: data.target.id,
+      destination_environment: AssessmentSourceUtils.getDestinationEnv(data),
+      instances: data.selectedInstances.map(i => i.instance_name),
+      notes: '',
+      security_groups: ['testgroup'],
+    }
 
-      data.options.forEach(option => {
-        if (option.name === 'use_replica') {
-          return
-        }
-        if (option.value !== null && option.value !== undefined) {
-          payload[type][option.name] = option.value
-        }
-      })
+    data.options.forEach(option => {
+      if (option.name === 'use_replica') {
+        return
+      }
+      if (option.value !== null && option.value !== undefined) {
+        payload[type][option.name] = option.value
+      }
+    })
 
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/${type}s`,
-        method: 'POST',
-        data: payload,
-      }).then(response => {
-        resolve(response.data[type])
-      }, reject).catch(reject)
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/${type}s`,
+      method: 'POST',
+      data: payload,
+    }).then(response => {
+      return response.data[type]
     })
   }
 
   static migrateMultiple(data: MigrationInfo): Promise<MainItem[]> {
-    return new Promise((resolve, reject) => {
-      let items = []
-      let count = 0
-
-      data.selectedInstances.forEach(instance => {
-        let newData = { ...data }
-        newData.selectedInstances = [instance]
-        this.migrate(newData).then(item => {
-          count += 1
-          items.push(item)
-          if (count === data.selectedInstances.length) {
-            if (items.length > 0) {
-              resolve(items)
-            } else {
-              reject()
-            }
-          }
-        }, () => {
-          count += 1
-          notificationStore.notify(`Error while migrating instance ${instance.name}`, 'error', {
-            persist: true,
-            persistInfo: { title: 'Migration creation error' },
-          })
+    return Promise.all(data.selectedInstances.map(instance => {
+      let newData = { ...data }
+      newData.selectedInstances = [instance]
+      return this.migrate(newData).catch(() => {
+        notificationStore.notify(`Error while migrating instance ${instance.name}`, 'error', {
+          persist: true,
+          persistInfo: { title: 'Migration creation error' },
         })
+        return null
       })
-    })
+    })).then(items => items.filter(Boolean).map(i => i))
   }
 }
 

src/sources/AzureSource.js

@@ -53,134 +53,130 @@ class Util {
     }
   }
 
-  static responseIsValid(resolve, reject, response, resolveData) {
-    if (response.data.error) {
+  static isResponseValid(response): boolean {
+    if (response && response.data && response.data.error) {
       const error = response.data.error
       console.error('%c', 'color: #D0021B', `${error.code}: ${error.message}`)
-      reject()
       return false
     }
+    return true
+  }
+
+  static validateResponse(response, resolveData): Promise<any> {
+    if (!this.isResponseValid(response)) {
+      return Promise.reject()
+    }
 
     if (resolveData) {
-      resolve(resolveData)
+      return Promise.resolve(resolveData)
     }
-    return true
+    return Promise.resolve(response)
   }
 }
 
 class AzureSource {
   static authenticate(username: string, password: string): Promise<any> {
-    return new Promise((resolve, reject) => {
-      Api.send({
-        url: '/azure-login',
-        method: 'POST',
-        data: { username, password },
-      }).then(response => {
-        let entries = Object.keys(response.data.tokenCache)[0]
-        let accessToken = response.data.tokenCache[entries][0].accessToken
-        Api.setDefaultHeader('Authorization', `Bearer ${accessToken}`)
-        resolve(response.data)
-      }, reject)
+    return Api.send({
+      url: '/azure-login',
+      method: 'POST',
+      data: { username, password },
+    }).then(response => {
+      let entries = Object.keys(response.data.tokenCache)[0]
+      let accessToken = response.data.tokenCache[entries][0].accessToken
+      Api.setDefaultHeader('Authorization', `Bearer ${accessToken}`)
+      return response.data
     })
   }
 
   static getResourceGroups(subscriptionId: string): Promise<$PropertyType<Assessment, 'group'>[]> {
-    return new Promise((resolve, reject) => {
-      Api.get(Util.buildUrl(resourceGroupsUrl({ subscriptionId }), '2017-08-01')).then(response => {
-        Util.responseIsValid(resolve, reject, response, response.data.value)
-      }, reject)
+    return Api.get(Util.buildUrl(resourceGroupsUrl({ subscriptionId }), '2017-08-01')).then(response => {
+      return Util.validateResponse(response, response.data.value)
     })
   }
 
-  static reqId: string
+  static previousReqId: string
 
   static getAssessments(subscriptionId: string, resourceGroupName: string): Promise<Assessment[]> {
-    this.reqId = subscriptionId + resourceGroupName
-
-    return new Promise((resolve, reject) => {
-      let assessments = []
-      let projectsQueue
-      let groupsQueue = 0
-
-      // Load projects
-      Api.get(Util.buildUrl(projectsUrl({ resourceGroupName, subscriptionId }))).then(response => {
-        if (!Util.responseIsValid(resolve, reject, response)) {
-          return
-        }
-
-        let projects = response.data.value
-        projectsQueue = projects.length
-
-        if (projectsQueue === 0 && subscriptionId + resourceGroupName === this.reqId) {
-          resolve([])
-        }
-
-        projects.forEach(project => {
-          if (project.type !== 'Microsoft.Migrate/projects') {
-            return
+    let cancelId = subscriptionId + resourceGroupName
+    if (this.previousReqId) {
+      Api.cancelRequests(this.previousReqId)
+    }
+    this.previousReqId = cancelId
+
+    // Load Projects
+    return Api.send({
+      url: Util.buildUrl(projectsUrl({ resourceGroupName, subscriptionId })),
+      cancelId,
+    }).then(projectsResponse => {
+      if (!Util.isResponseValid(projectsResponse)) {
+        return []
+      }
+      let projects = projectsResponse.data.value.filter(p => p.type === 'Microsoft.Migrate/projects')
+
+      // Load groups for each project
+      return Promise.all(projects.map(project => {
+        return Api.send({
+          url: Util.buildUrl(groupsUrl({ projectName: project.name, subscriptionId, resourceGroupName })),
+          cancelId,
+        }).then(groupsResponse => {
+          if (!Util.isResponseValid(groupsResponse)) {
+            return null
           }
-          // Load Groups
-          Api.get(Util.buildUrl(groupsUrl({ projectName: project.name, subscriptionId, resourceGroupName }))).then(response => {
-            if (!Util.responseIsValid(resolve, reject, response)) {
-              return
-            }
-            projectsQueue -= 1
-
-            let groups = response.data.value
-            groupsQueue = groups.length
-
-            if (groupsQueue === 0 && subscriptionId + resourceGroupName === this.reqId) {
-              resolve([])
-            }
-
-            groups.forEach(group => {
-              // Load Assessments
-              Api.get(Util.buildUrl(assessmentsUrl({ subscriptionId, resourceGroupName, projectName: project.name, groupName: group.name }))).then(response => {
-                if (!Util.responseIsValid(resolve, reject, response)) {
-                  return
-                }
-                groupsQueue -= 1
-
-                assessments = assessments.concat(response.data.value.map(a => ({ ...a, project, group })))
-                Util.checkQueues([groupsQueue, projectsQueue], [subscriptionId + resourceGroupName, this.reqId], () => { resolve(Util.sortAssessments(assessments)) })
-              }, () => { groupsQueue -= 1; Util.checkQueues([groupsQueue, projectsQueue], [subscriptionId + resourceGroupName, this.reqId], () => { resolve(Util.sortAssessments(assessments)) }) })
-            })
-          }, () => { projectsQueue -= 1; Util.checkQueues([groupsQueue, projectsQueue], [subscriptionId + resourceGroupName, this.reqId], () => { resolve(Util.sortAssessments(assessments)) }) })
+          return groupsResponse.data.value.map(group => { return { ...group, project } })
         })
-      }, reject)
+      }))
+    }).then(groupsResponses => {
+      let groups = []
+      groupsResponses.filter(r => r !== null).forEach(validGroupsReponse => {
+        groups = groups.concat(validGroupsReponse)
+      })
+
+      // Load assessments for each group
+      return Promise.all(groups.map(group => {
+        // $FlowIgnore
+        return Api.send({
+          url: Util.buildUrl(assessmentsUrl({ subscriptionId, resourceGroupName, projectName: group.project.name, groupName: group.name })),
+          cancelId,
+        }).then(assessmentResponse => {
+          if (!Util.isResponseValid(assessmentResponse)) {
+            return null
+          }
+          return assessmentResponse.data.value.map(assessment => { return { ...assessment, group, project: group.project } })
+        })
+      }))
+    }).then(assessementsResponses => {
+      let assessments = []
+      assessementsResponses.filter(r => r !== null).forEach(validAssessmentsResponse => {
+        assessments = assessments.concat(validAssessmentsResponse)
+      })
+      return Util.sortAssessments(assessments)
     })
   }
 
   static getAssessmentDetails(info: Assessment): Promise<Assessment> {
-    return new Promise((resolve, reject) => {
-      Api.get(Util.buildUrl(assessmentDetailsUrl({ ...info, subscriptionId: info.connectionInfo.subscription_id }))).then(response => {
-        Util.responseIsValid(resolve, reject, response, { ...response.data, ...info })
-      }, reject)
+    return Api.get(Util.buildUrl(assessmentDetailsUrl({ ...info, subscriptionId: info.connectionInfo.subscription_id }))).then(response => {
+      return Util.validateResponse(response, { ...response.data, ...info })
     })
   }
 
   static getAssessedVms(info: Assessment): Promise<VmItem[]> {
-    return new Promise((resolve, reject) => {
-      Api.get(Util.buildUrl(assessedVmsUrl({ ...info, subscriptionId: info.connectionInfo.subscription_id }))).then(response => {
-        if (!Util.responseIsValid(resolve, reject, response)) {
-          return
-        }
-
-        let vms = response.data.value
-        vms.sort((a, b) => {
-          let getLabel = item => `${item.properties.datacenterContainer}/${item.properties.displayName}`
-          return getLabel(a).localeCompare(getLabel(b))
-        })
-        resolve(vms)
-      }, reject)
+    return Api.get(Util.buildUrl(assessedVmsUrl({ ...info, subscriptionId: info.connectionInfo.subscription_id }))).then(response => {
+      if (!Util.isResponseValid(response)) {
+        return []
+      }
+
+      let vms = response.data.value
+      vms.sort((a, b) => {
+        let getLabel = item => `${item.properties.datacenterContainer}/${item.properties.displayName}`
+        return getLabel(a).localeCompare(getLabel(b))
+      })
+      return vms
     })
   }
 
   static getVmSizes(info: Assessment): Promise<VmSize[]> {
-    return new Promise((resolve, reject) => {
-      Api.get(Util.buildUrl(`/subscriptions/${info.connectionInfo.subscription_id}/providers/Microsoft.Compute/locations/${info.location}/vmSizes`, '2017-12-01')).then(response => {
-        Util.responseIsValid(resolve, reject, response, response.data.value)
-      }, reject)
+    return Api.get(Util.buildUrl(`/subscriptions/${info.connectionInfo.subscription_id}/providers/Microsoft.Compute/locations/${info.location}/vmSizes`, '2017-12-01')).then(response => {
+      return Util.validateResponse(response, response.data.value)
     })
   }
 }

src/sources/EndpointSource.js

@@ -39,46 +39,39 @@ let getBarbicanPayload = data => {
 
 class EdnpointSource {
   static getEndpoints(): Promise<Endpoint[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      if (projectId) {
-        Api.get(`${servicesUrl.coriolis}/${projectId}/endpoints`).then(response => {
-          let connections = []
-          if (response.data.endpoints.length) {
-            response.data.endpoints.forEach(endpoint => {
-              connections.push(endpoint)
-            })
-          }
-
-          connections.sort((c1, c2) => moment(c2.created_at).diff(moment(c1.created_at)))
+    let projectId = cookie.get('projectId')
+    if (projectId) {
+      return Api.get(`${servicesUrl.coriolis}/${projectId}/endpoints`).then(response => {
+        let connections = []
+        if (response.data.endpoints.length) {
+          response.data.endpoints.forEach(endpoint => {
+            connections.push(endpoint)
+          })
+        }
 
-          resolve(connections)
-        }).catch(reject)
-      } else {
-        reject()
-      }
-    })
+        connections.sort((c1, c2) => moment(c2.created_at).diff(moment(c1.created_at)))
+        return connections
+      })
+    }
+    return Promise.reject('No Project ID!')
   }
   static delete(endpoint: Endpoint): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let projectId: any = cookie.get('projectId')
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId}/endpoints/${endpoint.id}`,
-        method: 'DELETE',
-      }).then(() => {
-        if (endpoint.connection_info && endpoint.connection_info.secret_ref) {
-          let uuidIndex = endpoint.connection_info.secret_ref.lastIndexOf('/')
-          // $FlowIssue
-          let uuid = endpoint.connection_info.secret_ref.substr(uuidIndex + 1)
-          Api.send({
-            url: `${servicesUrl.barbican}/v1/secrets/${uuid}`,
-            method: 'DELETE',
-          }).then(() => { resolve(endpoint.id) }).catch(reject)
-        } else {
-          resolve(endpoint.id)
-        }
-      }).catch(reject)
+    let projectId: any = cookie.get('projectId')
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId}/endpoints/${endpoint.id}`,
+      method: 'DELETE',
+    }).then(() => {
+      if (endpoint.connection_info && endpoint.connection_info.secret_ref) {
+        let uuidIndex = endpoint.connection_info.secret_ref.lastIndexOf('/')
+        // $FlowIssue
+        let uuid = endpoint.connection_info.secret_ref.substr(uuidIndex + 1)
+        return Api.send({
+          url: `${servicesUrl.barbican}/v1/secrets/${uuid}`,
+          method: 'DELETE',
+        }).then(() => { return endpoint.id })
+      }
+      return endpoint.id
     })
   }
 
@@ -90,175 +83,152 @@ class EdnpointSource {
       return Promise.resolve(endpoint.connection_info)
     }
 
-    return new Promise((resolve, reject) => {
-      Api.send({
-        url: `${servicesUrl.barbican}/v1/secrets/${uuid || 'undefined'}/payload`,
-        responseType: 'text',
-        headers: { Accept: 'text/plain' },
-      }).then((response) => {
-        resolve(response.data)
-      }).catch(reject)
+    return Api.send({
+      url: `${servicesUrl.barbican}/v1/secrets/${uuid || 'undefined'}/payload`,
+      responseType: 'text',
+      headers: { Accept: 'text/plain' },
+    }).then((response) => {
+      return response.data
     })
   }
 
   static getConnectionsInfo(endpoints: Endpoint[]): Promise<Endpoint[]> {
-    return new Promise(resolve => {
-      if (!endpoints || endpoints.length === 0) {
-        resolve([])
-        return
-      }
-
-      let count = 0
-      let connectionsInfo = []
-      let isDone = () => {
-        count += 1
-        if (count === endpoints.length) {
-          resolve(connectionsInfo)
-        }
-      }
-
-      endpoints.forEach(endpoint => {
-        let index = endpoint.connection_info.secret_ref ? endpoint.connection_info.secret_ref.lastIndexOf('/') : ''
-        let uuid = endpoint.connection_info.secret_ref && index ? endpoint.connection_info.secret_ref.substr(index + 1) : ''
-        Api.send({
-          url: `${servicesUrl.barbican}/v1/secrets/${uuid}/payload`,
-          responseType: 'text',
-          headers: { Accept: 'text/plain' },
-        }).then(response => {
-          connectionsInfo.push({ ...endpoint, connection_info: response.data })
-          isDone()
-        }, isDone).catch(isDone)
+    return Promise.all(endpoints.map(endpoint => {
+      let index = endpoint.connection_info.secret_ref ? endpoint.connection_info.secret_ref.lastIndexOf('/') : ''
+      let uuid = endpoint.connection_info.secret_ref && index ? endpoint.connection_info.secret_ref.substr(index + 1) : ''
+      return Api.send({
+        url: `${servicesUrl.barbican}/v1/secrets/${uuid}/payload`,
+        responseType: 'text',
+        headers: { Accept: 'text/plain' },
+      }).then(response => {
+        return { ...endpoint, connection_info: response.data }
       })
-    })
+    }))
   }
 
   static validate(endpoint: Endpoint): Promise<Validation> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints/${endpoint.id}/actions`,
-        method: 'POST',
-        data: { 'validate-connection': null },
-      }).then(response => {
-        resolve(response.data['validate-connection'])
-      }).catch(reject)
+    let projectId = cookie.get('projectId')
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints/${endpoint.id}/actions`,
+      method: 'POST',
+      data: { 'validate-connection': null },
+    }).then(response => {
+      return response.data['validate-connection']
     })
   }
 
   static update(endpoint: Endpoint): Promise<Endpoint> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let parsedEndpoint = SchemaParser.fieldsToPayload(endpoint)
-
-      if (parsedEndpoint.connection_info && parsedEndpoint.connection_info.secret_ref) {
-        // $FlowIgnore
-        let uuidIndex = parsedEndpoint.connection_info.secret_ref.lastIndexOf('/')
-        // $FlowIgnore
-        let uuid = parsedEndpoint.connection_info.secret_ref.substr(uuidIndex + 1)
-
-        Api.send({
-          url: `${servicesUrl.barbican}/v1/secrets/${uuid}`,
-          method: 'DELETE',
-        })
-
-        Api.send({
+    let projectId = cookie.get('projectId')
+    let parsedEndpoint = SchemaParser.fieldsToPayload(endpoint)
+
+    if (parsedEndpoint.connection_info && parsedEndpoint.connection_info.secret_ref) {
+      // $FlowIgnore
+      let uuidIndex = parsedEndpoint.connection_info.secret_ref.lastIndexOf('/')
+      // $FlowIgnore
+      let uuid = parsedEndpoint.connection_info.secret_ref.substr(uuidIndex + 1)
+      let newEndpoint: any = {}
+      let connectionInfo = {}
+      return Api.send({
+        url: `${servicesUrl.barbican}/v1/secrets/${uuid}`,
+        method: 'DELETE',
+      }).then(() => {
+        return Api.send({
           url: `${servicesUrl.barbican}/v1/secrets`,
           method: 'POST',
           data: getBarbicanPayload(ObjectUtils.skipField(parsedEndpoint.connection_info, 'secret_ref')),
-        }).then(response => {
-          let connectionInfo = { secret_ref: response.data.secret_ref }
-          let newPayload = {
-            endpoint: {
-              name: parsedEndpoint.name,
-              description: parsedEndpoint.description,
-              connection_info: connectionInfo,
-            },
-          }
-          Api.send({
-            url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints/${endpoint.id}`,
-            method: 'PUT',
-            data: newPayload,
-          }).then(putResponse => {
-            uuidIndex = connectionInfo.secret_ref.lastIndexOf('/')
-            uuid = connectionInfo.secret_ref.substr(uuidIndex + 1)
-            let newEndpoint = putResponse.data.endpoint
-
-            Api.send({
-              url: `${servicesUrl.barbican}/v1/secrets/${uuid}/payload`,
-              method: 'GET',
-              responseType: 'text',
-              headers: { Accept: 'text/plain' },
-            }).then(conInfoResponse => {
-              newEndpoint.connection_info = {
-                ...newEndpoint.connection_info,
-                ...conInfoResponse.data,
-              }
-              resolve(newEndpoint)
-            }).catch(reject)
-          }).catch(reject)
-        }).catch(reject)
-      } else {
-        Api.send({
+        })
+      }).then(response => {
+        connectionInfo = { secret_ref: response.data.secret_ref }
+        let newPayload = {
+          endpoint: {
+            name: parsedEndpoint.name,
+            description: parsedEndpoint.description,
+            connection_info: connectionInfo,
+          },
+        }
+        return Api.send({
           url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints/${endpoint.id}`,
           method: 'PUT',
-          data: { endpoint: parsedEndpoint },
-        }).then(response => {
-          resolve(response.data.endpoint)
-        }).catch(reject)
-      }
+          data: newPayload,
+        })
+      }).then(putResponse => {
+        uuidIndex = connectionInfo.secret_ref.lastIndexOf('/')
+        uuid = connectionInfo.secret_ref.substr(uuidIndex + 1)
+        newEndpoint = putResponse.data.endpoint
+        return Api.send({
+          url: `${servicesUrl.barbican}/v1/secrets/${uuid}/payload`,
+          method: 'GET',
+          responseType: 'text',
+          headers: { Accept: 'text/plain' },
+        })
+      }).then(conInfoResponse => {
+        newEndpoint.connection_info = {
+          ...newEndpoint.connection_info,
+          ...conInfoResponse.data,
+        }
+        return newEndpoint
+      })
+    }
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints/${endpoint.id}`,
+      method: 'PUT',
+      data: { endpoint: parsedEndpoint },
+    }).then(response => {
+      return response.data.endpoint
     })
   }
 
   static add(endpoint: Endpoint, skipSchemaParser: boolean = false): Promise<Endpoint> {
-    return new Promise((resolve, reject) => {
-      let parsedEndpoint = skipSchemaParser ? { ...endpoint } : SchemaParser.fieldsToPayload(endpoint)
-      let projectId = cookie.get('projectId')
-      if (useSecret) {
-        Api.send({
-          url: `${servicesUrl.barbican}/v1/secrets`,
-          method: 'POST',
-          data: getBarbicanPayload(ObjectUtils.skipField(parsedEndpoint.connection_info, 'secret_ref')),
-        }).then(response => {
-          let connectionInfo = { secret_ref: response.data.secret_ref }
-          let newPayload = {
-            endpoint: {
-              name: parsedEndpoint.name,
-              description: parsedEndpoint.description,
-              type: endpoint.type,
-              connection_info: connectionInfo,
-            },
-          }
-          Api.send({
-            url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints`,
-            method: 'POST',
-            data: newPayload,
-          }).then(postResponse => {
-            let uuidIndex = connectionInfo.secret_ref.lastIndexOf('/')
-            let uuid = connectionInfo.secret_ref.substr(uuidIndex + 1)
-            let newEndpoint = postResponse.data.endpoint
-
-            Api.send({
-              url: `${servicesUrl.barbican}/v1/secrets/${uuid}/payload`,
-              responseType: 'text',
-              headers: { Accept: 'text/plain' },
-            }).then(conInfoResponse => {
-              newEndpoint.connection_info = {
-                ...newEndpoint.connection_info,
-                ...conInfoResponse.data,
-              }
-              resolve(newEndpoint)
-            }).catch(reject)
-          }).catch(reject)
-        }).catch(reject)
-      } else {
-        Api.send({
+    let parsedEndpoint = skipSchemaParser ? { ...endpoint } : SchemaParser.fieldsToPayload(endpoint)
+    let projectId = cookie.get('projectId')
+    let newEndpoint: any = {}
+    let connectionInfo = {}
+    if (useSecret) {
+      return Api.send({
+        url: `${servicesUrl.barbican}/v1/secrets`,
+        method: 'POST',
+        data: getBarbicanPayload(ObjectUtils.skipField(parsedEndpoint.connection_info, 'secret_ref')),
+      }).then(response => {
+        connectionInfo = { secret_ref: response.data.secret_ref }
+        let newPayload = {
+          endpoint: {
+            name: parsedEndpoint.name,
+            description: parsedEndpoint.description,
+            type: endpoint.type,
+            connection_info: connectionInfo,
+          },
+        }
+        return Api.send({
           url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints`,
           method: 'POST',
-          data: { endpoint: parsedEndpoint },
-        }).then(response => {
-          resolve(response.data.endpoint)
-        }).catch(reject)
-      }
+          data: newPayload,
+        })
+      }).then(postResponse => {
+        let uuidIndex = connectionInfo.secret_ref.lastIndexOf('/')
+        let uuid = connectionInfo.secret_ref.substr(uuidIndex + 1)
+        newEndpoint = postResponse.data.endpoint
+
+        return Api.send({
+          url: `${servicesUrl.barbican}/v1/secrets/${uuid}/payload`,
+          responseType: 'text',
+          headers: { Accept: 'text/plain' },
+        })
+      }).then(conInfoResponse => {
+        newEndpoint.connection_info = {
+          ...newEndpoint.connection_info,
+          ...conInfoResponse.data,
+        }
+        return newEndpoint
+      })
+    }
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || ''}/endpoints`,
+      method: 'POST',
+      data: { endpoint: parsedEndpoint },
+    }).then(response => {
+      return response.data.endpoint
     })
   }
 }

src/sources/InstanceSource.js

@@ -22,48 +22,45 @@ import type { Instance } from '../types/Instance'
 import { servicesUrl, wizardConfig } from '../config'
 
 class InstanceSource {
-  static endpointId: string
+  static lastEndpointId: string
 
   static loadInstances(endpointId: string, searchText: ?string, lastInstanceId: ?string, skipLimit?: boolean): Promise<Instance[]> {
-    this.endpointId = endpointId
+    if (this.lastEndpointId) {
+      Api.cancelRequests(this.lastEndpointId)
+      this.lastEndpointId = endpointId
+    }
 
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let url = `${servicesUrl.coriolis}/${projectId || 'null'}/endpoints/${endpointId}/instances`
-      let symbol = '?'
+    let projectId = cookie.get('projectId')
+    let url = `${servicesUrl.coriolis}/${projectId || 'null'}/endpoints/${endpointId}/instances`
+    let symbol = '?'
 
-      if (!skipLimit) {
-        url = `${url + symbol}limit=${wizardConfig.instancesItemsPerPage + 1}`
-        symbol = '&'
-      }
+    if (!skipLimit) {
+      url = `${url + symbol}limit=${wizardConfig.instancesItemsPerPage + 1}`
+      symbol = '&'
+    }
 
-      if (searchText) {
-        url = `${url + symbol}name=${searchText}`
-        symbol = '&'
-      }
+    if (searchText) {
+      url = `${url + symbol}name=${searchText}`
+      symbol = '&'
+    }
 
-      if (lastInstanceId) {
-        url = `${url + symbol}&marker=${lastInstanceId}`
-      }
+    if (lastInstanceId) {
+      url = `${url + symbol}&marker=${lastInstanceId}`
+    }
 
-      Api.get(url).then(response => {
-        if (this.endpointId === endpointId) {
-          resolve(response.data.instances)
-        }
-      }).catch(reject)
+    return Api.send({ url, cancelId: endpointId }).then(response => {
+      return response.data.instances
     })
   }
 
   static loadInstanceDetails(endpointId: string, instanceName: string, reqId: number): Promise<{ instance: Instance, reqId: number }> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId') || 'undefined'
+    let projectId = cookie.get('projectId') || 'undefined'
 
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId}/endpoints/${endpointId}/instances/${btoa(instanceName)}`,
-        cancelId: `instanceDetail-${reqId}`,
-      }).then(response => {
-        resolve({ instance: response.data.instance, reqId })
-      }, response => { reject({ response, reqId }) }).catch(reject)
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId}/endpoints/${endpointId}/instances/${btoa(instanceName)}`,
+      cancelId: `instanceDetail-${reqId}`,
+    }).then(response => {
+      return { instance: response.data.instance, reqId }
     })
   }
 

src/sources/MigrationSource.js

@@ -51,73 +51,58 @@ class MigrationSourceUtils {
 
 class MigrationSource {
   static getMigrations(): Promise<MainItem[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId') || 'null'
-      Api.get(`${servicesUrl.coriolis}/${projectId}/migrations/detail`).then(response => {
-        let migrations = response.data.migrations
-        MigrationSourceUtils.sortMigrations(migrations)
-        resolve(migrations)
-      }).catch(reject)
+    let projectId = cookie.get('projectId') || 'null'
+    return Api.get(`${servicesUrl.coriolis}/${projectId}/migrations/detail`).then(response => {
+      let migrations = response.data.migrations
+      MigrationSourceUtils.sortMigrations(migrations)
+      return migrations
     })
   }
 
   static getMigration(migrationId: string): Promise<MainItem> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId') || 'null'
-
-      Api.get(`${servicesUrl.coriolis}/${projectId}/migrations/${migrationId}`).then(response => {
-        let migration = response.data.migration
-        MigrationSourceUtils.sortTaskUpdates(migration)
-        resolve(migration)
-      }).catch(reject)
+    let projectId = cookie.get('projectId') || 'null'
+
+    return Api.get(`${servicesUrl.coriolis}/${projectId}/migrations/${migrationId}`).then(response => {
+      let migration = response.data.migration
+      MigrationSourceUtils.sortTaskUpdates(migration)
+      return migration
     })
   }
 
   static cancel(migrationId: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId') || 'null'
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId}/migrations/${migrationId}/actions`,
-        method: 'POST',
-        data: { cancel: null },
-      }).then(() => {
-        resolve(migrationId)
-      }).catch(reject)
-    })
+    let projectId = cookie.get('projectId') || 'null'
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId}/migrations/${migrationId}/actions`,
+      method: 'POST',
+      data: { cancel: null },
+    }).then(() => migrationId)
   }
 
   static delete(migrationId: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/migrations/${migrationId}`,
-        method: 'DELETE',
-      }).then(() => { resolve(migrationId) }, reject).catch(reject)
-    })
+    let projectId = cookie.get('projectId')
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/migrations/${migrationId}`,
+      method: 'DELETE',
+    }).then(() => migrationId)
   }
 
   static migrateReplica(replicaId: string, options: Field[]): Promise<MainItem> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let payload = {
-        migration: {
-          replica_id: replicaId,
-        },
-      }
-      options.forEach(o => {
-        payload.migration[o.name] = o.value || false
-      })
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/migrations`,
-        method: 'POST',
-        data: payload,
-      }).then(response => {
-        let migration = response.data.migration
-        resolve(migration)
-      }).catch(reject)
+    let projectId = cookie.get('projectId')
+    let payload = {
+      migration: {
+        replica_id: replicaId,
+      },
+    }
+    options.forEach(o => {
+      payload.migration[o.name] = o.value || false
     })
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/migrations`,
+      method: 'POST',
+      data: payload,
+    }).then(response => response.data.migration)
   }
 }
 

src/sources/NetworkSource.js

@@ -23,18 +23,16 @@ import { servicesUrl } from '../config'
 
 class NetworkSource {
   static loadNetworks(enpointId: string, environment: ?{ [string]: mixed }): Promise<Network[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let url = `${servicesUrl.coriolis}/${projectId || 'null'}/endpoints/${enpointId}/networks`
-      if (environment) {
-        url = `${url}?env=${btoa(JSON.stringify(environment))}`
-      }
+    let projectId = cookie.get('projectId')
+    let url = `${servicesUrl.coriolis}/${projectId || 'null'}/endpoints/${enpointId}/networks`
+    if (environment) {
+      url = `${url}?env=${btoa(JSON.stringify(environment))}`
+    }
 
-      Api.get(url).then(response => {
-        let networks = response.data.networks.filter(n => n.name.indexOf('coriolis-migrnet') === -1)
-        networks.sort((a, b) => a.name.localeCompare(b.name))
-        resolve(networks)
-      }).catch(reject)
+    return Api.get(url).then(response => {
+      let networks = response.data.networks.filter(n => n.name.indexOf('coriolis-migrnet') === -1)
+      networks.sort((a, b) => a.name.localeCompare(b.name))
+      return networks
     })
   }
 }

src/sources/NotificationSource.js

@@ -18,31 +18,25 @@ import type { NotificationItem } from '../types/NotificationItem'
 
 class NotificationSource {
   static notify(message: string, level?: $PropertyType<NotificationItem, 'level'>, options?: $PropertyType<NotificationItem, 'options'>): Promise<NotificationItem> {
-    return new Promise(resolve => {
-      let notifications = JSON.parse(localStorage.getItem('notifications') || '[]')
-      let newItem = {
-        id: new Date().getTime().toString(),
-        message,
-        level,
-        options,
-      }
-      notifications.push(newItem)
-      localStorage.setItem('notifications', JSON.stringify(notifications))
-      resolve(newItem)
-    })
+    let notifications = JSON.parse(localStorage.getItem('notifications') || '[]')
+    let newItem = {
+      id: new Date().getTime().toString(),
+      message,
+      level,
+      options,
+    }
+    notifications.push(newItem)
+    localStorage.setItem('notifications', JSON.stringify(notifications))
+    return Promise.resolve(newItem)
   }
 
   static loadNotifications(): Promise<NotificationItem[]> {
-    return new Promise(resolve => {
-      resolve(JSON.parse(localStorage.getItem('notifications') || '[]'))
-    })
+    return Promise.resolve(JSON.parse(localStorage.getItem('notifications') || '[]'))
   }
 
   static clearNotifications(): Promise<void> {
-    return new Promise(resolve => {
-      localStorage.setItem('notifications', '[]')
-      resolve()
-    })
+    localStorage.setItem('notifications', '[]')
+    return Promise.resolve()
   }
 }
 

src/sources/ProviderSource.js

@@ -25,52 +25,43 @@ import type { DestinationOption } from '../types/Endpoint'
 
 class ProviderSource {
   static getConnectionInfoSchema(providerName: string): Promise<Field[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
+    let projectId = cookie.get('projectId')
 
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/providers/${providerName}/schemas/${providerTypes.CONNECTION}`).then(response => {
-        let schema = response.data.schemas.connection_info_schema
-        schema = SchemaParser.connectionSchemaToFields(providerName, schema)
-        resolve(schema)
-      }).catch(reject)
+    return Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/providers/${providerName}/schemas/${providerTypes.CONNECTION}`).then(response => {
+      let schema = response.data.schemas.connection_info_schema
+      schema = SchemaParser.connectionSchemaToFields(providerName, schema)
+      return schema
     })
   }
 
   static loadProviders(): Promise<Providers> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
+    let projectId = cookie.get('projectId')
 
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/providers`).then(response => {
-        resolve(response.data.providers)
-      }).catch(reject)
-    })
+    return Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/providers`)
+      .then(response => response.data.providers)
   }
 
   static loadOptionsSchema(providerName: string, schemaType: string): Promise<Field[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let schemaTypeInt = schemaType === 'migration' ? providerTypes.TARGET_MIGRATION : providerTypes.TARGET_REPLICA
+    let projectId = cookie.get('projectId')
+    let schemaTypeInt = schemaType === 'migration' ? providerTypes.TARGET_MIGRATION : providerTypes.TARGET_REPLICA
 
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/providers/${providerName}/schemas/${schemaTypeInt}`).then(response => {
-        let schema = response.data.schemas.destination_environment_schema
-        let fields = SchemaParser.optionsSchemaToFields(providerName, schema)
-        resolve(fields)
-      }).catch(reject)
+    return Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/providers/${providerName}/schemas/${schemaTypeInt}`).then(response => {
+      let schema = response.data.schemas.destination_environment_schema
+      let fields = SchemaParser.optionsSchemaToFields(providerName, schema)
+      return fields
     })
   }
 
   static getDestinationOptions(endpointId: string, envData: ?{ [string]: mixed }): Promise<DestinationOption[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let envString = ''
-      if (envData) {
-        envString = `?env=${btoa(JSON.stringify(envData))}`
-      }
+    let projectId = cookie.get('projectId')
+    let envString = ''
+    if (envData) {
+      envString = `?env=${btoa(JSON.stringify(envData))}`
+    }
 
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/endpoints/${endpointId}/destination-options${envString}`).then(response => {
-        let options = response.data.destination_options
-        resolve(options)
-      }).catch(() => { reject() })
+    return Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/endpoints/${endpointId}/destination-options${envString}`).then(response => {
+      let options = response.data.destination_options
+      return options
     })
   }
 }

src/sources/ReplicaSource.js

@@ -85,114 +85,92 @@ class ReplicaSourceUtils {
 
 class ReplicaSource {
   static getReplicas(): Promise<MainItem[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/replicas/detail`).then(response => {
-        let replicas = response.data.replicas
-        replicas = ReplicaSourceUtils.filterDeletedExecutionsInReplicas(replicas)
-        ReplicaSourceUtils.sortReplicas(replicas)
-        resolve(replicas)
-      }).catch(reject)
+    let projectId = cookie.get('projectId') || 'undefined'
+    return Api.get(`${servicesUrl.coriolis}/${projectId}/replicas/detail`).then(response => {
+      let replicas = response.data.replicas
+      replicas = ReplicaSourceUtils.filterDeletedExecutionsInReplicas(replicas)
+      ReplicaSourceUtils.sortReplicas(replicas)
+      return replicas
     })
   }
 
   static getReplicaExecutions(replicaId: string): Promise<Execution[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/executions/detail`).then((response) => {
-        let executions = response.data.executions
-        ReplicaSourceUtils.sortExecutionsAndTaskUpdates(executions)
-
-        resolve(executions)
-      }).catch(reject)
+    let projectId = cookie.get('projectId') || 'undefined'
+    return Api.get(`${servicesUrl.coriolis}/${projectId}/replicas/${replicaId}/executions/detail`).then((response) => {
+      let executions = response.data.executions
+      ReplicaSourceUtils.sortExecutionsAndTaskUpdates(executions)
+
+      return executions
     })
   }
 
   static getReplica(replicaId: string): Promise<MainItem> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}`).then(response => {
-        let replica = response.data.replica
-        replica.executions = ReplicaSourceUtils.filterDeletedExecutions(replica.executions)
-        ReplicaSourceUtils.sortExecutions(replica.executions)
-        resolve(replica)
-      }).catch(reject)
+    let projectId = cookie.get('projectId') || 'undefined'
+
+    return Api.get(`${servicesUrl.coriolis}/${projectId}/replicas/${replicaId}`).then(response => {
+      let replica = response.data.replica
+      replica.executions = ReplicaSourceUtils.filterDeletedExecutions(replica.executions)
+      ReplicaSourceUtils.sortExecutions(replica.executions)
+      return replica
     })
   }
 
   static execute(replicaId: string, fields?: Field[]): Promise<Execution> {
-    return new Promise((resolve, reject) => {
-      let payload = { execution: { shutdown_instances: false } }
-      if (fields) {
-        fields.forEach(f => {
-          payload.execution[f.name] = f.value || false
-        })
-      }
-      let projectId = cookie.get('projectId')
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/executions`,
-        method: 'POST',
-        data: payload,
-      }).then((response) => {
-        let execution = response.data.execution
-        ReplicaSourceUtils.sortTaskUpdates(execution)
-        resolve(execution)
-      }).catch(reject)
+    let payload = { execution: { shutdown_instances: false } }
+    if (fields) {
+      fields.forEach(f => {
+        payload.execution[f.name] = f.value || false
+      })
+    }
+    let projectId = cookie.get('projectId') || 'undefined'
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId}/replicas/${replicaId}/executions`,
+      method: 'POST',
+      data: payload,
+    }).then((response) => {
+      let execution = response.data.execution
+      ReplicaSourceUtils.sortTaskUpdates(execution)
+      return execution
     })
   }
 
   static cancelExecution(replicaId: string, executionId: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/executions/${executionId}/actions`,
-        method: 'POST',
-        data: { cancel: null },
-      }).then(() => {
-        resolve(replicaId)
-      }).catch(reject)
-    })
+    let projectId = cookie.get('projectId')
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/executions/${executionId}/actions`,
+      method: 'POST',
+      data: { cancel: null },
+    }).then(() => replicaId)
   }
 
   static deleteExecution(replicaId: string, executionId: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/executions/${executionId}`,
-        method: 'DELETE',
-      }).then(() => {
-        resolve(replicaId)
-      }).catch(reject)
-    })
+    let projectId = cookie.get('projectId')
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/executions/${executionId}`,
+      method: 'DELETE',
+    }).then(() => replicaId)
   }
 
   static delete(replicaId: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
+    let projectId = cookie.get('projectId')
 
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}`,
-        method: 'DELETE',
-      }).then(() => { resolve(replicaId) }, reject).catch(reject)
-    })
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}`,
+      method: 'DELETE',
+    }).then(() => replicaId)
   }
 
   static deleteDisks(replicaId: string): Promise<Execution> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/actions`,
-        method: 'POST',
-        data: { 'delete-disks': null },
-      }).then(response => {
-        resolve(response.data.execution)
-      }).catch(reject)
-    })
+    let projectId = cookie.get('projectId')
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/actions`,
+      method: 'POST',
+      data: { 'delete-disks': null },
+    }).then(response => response.data.execution)
   }
 }
 

src/sources/ScheduleSource.js

@@ -24,110 +24,82 @@ import type { Schedule } from '../types/Schedule'
 
 class ScheduleSource {
   static scheduleSinge(replicaId: string, scheduleData: Schedule): Promise<Schedule> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let payload = {
-        schedule: {},
-        expiration_date: null,
-        enabled: scheduleData.enabled === null || scheduleData.enabled === undefined ? false : scheduleData.enabled,
-        shutdown_instance: scheduleData.shutdown_instances === null || scheduleData.shutdown_instances === undefined ? false : scheduleData.shutdown_instances,
-      }
-
-      if (scheduleData.expiration_date) {
+    let projectId = cookie.get('projectId')
+    let payload = {
+      schedule: {},
+      expiration_date: null,
+      enabled: scheduleData.enabled === null || scheduleData.enabled === undefined ? false : scheduleData.enabled,
+      shutdown_instance: scheduleData.shutdown_instances === null || scheduleData.shutdown_instances === undefined ? false : scheduleData.shutdown_instances,
+    }
+
+    if (scheduleData.expiration_date) {
+      // $FlowIssue
+      payload.expiration_date = moment(scheduleData.expiration_date).toISOString()
+    }
+
+    if (scheduleData.schedule !== null && scheduleData.schedule !== undefined) {
+      Object.keys(scheduleData.schedule).forEach(prop => {
         // $FlowIssue
-        payload.expiration_date = moment(scheduleData.expiration_date).toISOString()
-      }
-
-      if (scheduleData.schedule !== null && scheduleData.schedule !== undefined) {
-        Object.keys(scheduleData.schedule).forEach(prop => {
-          // $FlowIssue
-          if (scheduleData.schedule[prop] !== null && scheduleData.schedule[prop] !== undefined) {
-            payload.schedule[prop] = scheduleData.schedule[prop]
-          }
-        })
-      }
+        if (scheduleData.schedule[prop] !== null && scheduleData.schedule[prop] !== undefined) {
+          payload.schedule[prop] = scheduleData.schedule[prop]
+        }
+      })
+    }
 
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules`,
-        method: 'POST',
-        data: payload,
-      }).then(response => {
-        resolve(response.data.schedule)
-      }).catch(reject)
-    })
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules`,
+      method: 'POST',
+      data: payload,
+    }).then(response => response.data.schedule)
   }
 
   static scheduleMultiple(replicaId: string, schedules: Schedule[]): Promise<Schedule[]> {
-    return new Promise((resolve, reject) => {
-      let createdSchedules = []
-      let count = 0
-      schedules.forEach(schedule => {
-        ScheduleSource.scheduleSinge(replicaId, schedule).then(createdSchedule => {
-          count += 1
-          createdSchedules.push(createdSchedule)
-          if (count === schedules.length) {
-            if (createdSchedules.length > 0) {
-              resolve(createdSchedules)
-            } else {
-              reject()
-            }
-          }
-        }, () => { count += 1 })
-      })
-    })
+    return Promise.all(schedules.map(schedule => {
+      return ScheduleSource.scheduleSinge(replicaId, schedule)
+    }))
   }
 
   static getSchedules(replicaId: string): Promise<Schedule[]> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-
-      Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules`).then(response => {
-        let schedules = [...response.data.schedules]
-
-        schedules.forEach(s => {
-          if (s.expiration_date) {
-            s.expiration_date = DateUtils.getLocalTime(s.expiration_date)
-          }
-
-          if (s.shutdown_instance) {
-            s.shutdown_instances = s.shutdown_instance
-          }
-        })
-        schedules.sort((a, b) => moment(a.created_at).diff(b.created_at))
-        resolve(schedules)
-      }).catch(reject)
+    let projectId = cookie.get('projectId')
+
+    return Api.get(`${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules`).then(response => {
+      let schedules = [...response.data.schedules]
+      schedules.forEach(s => {
+        if (s.expiration_date) {
+          s.expiration_date = DateUtils.getLocalTime(s.expiration_date)
+        }
+        if (s.shutdown_instance) {
+          s.shutdown_instances = s.shutdown_instance
+        }
+      })
+      schedules.sort((a, b) => moment(a.created_at).diff(b.created_at))
+      return schedules
     })
   }
 
   static addSchedule(replicaId: string, schedule: Schedule): Promise<Schedule> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let payload = {
-        schedule: { hour: 0, minute: 0 },
-        enabled: false,
-      }
-      if (schedule && schedule.schedule) {
-        payload.schedule = { ...schedule.schedule }
-      }
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules`,
-        method: 'POST',
-        data: payload,
-      }).then(response => {
-        resolve(response.data.schedule)
-      }).catch(reject)
-    })
+    let projectId = cookie.get('projectId')
+    let payload = {
+      schedule: { hour: 0, minute: 0 },
+      enabled: false,
+    }
+    if (schedule && schedule.schedule) {
+      payload.schedule = { ...schedule.schedule }
+    }
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules`,
+      method: 'POST',
+      data: payload,
+    }).then(response => response.data.schedule)
   }
 
   static removeSchedule(replicaId: string, scheduleId: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules/${scheduleId}`,
-        method: 'DELETE',
-      }).then(() => { resolve() }).catch(reject)
-    })
+    let projectId = cookie.get('projectId')
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules/${scheduleId}`,
+      method: 'DELETE',
+    }).then(() => { })
   }
 
   static updateSchedule(
@@ -137,47 +109,45 @@ class ScheduleSource {
     scheduleOldData: ?Schedule,
     unsavedData: ?Schedule
   ): Promise<Schedule> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-      let payload = {}
-      if (scheduleData.enabled !== null && scheduleData.enabled !== undefined) {
-        payload.enabled = scheduleData.enabled
+    let projectId = cookie.get('projectId')
+    let payload = {}
+    if (scheduleData.enabled !== null && scheduleData.enabled !== undefined) {
+      payload.enabled = scheduleData.enabled
+    }
+    if (scheduleData.shutdown_instances !== null && scheduleData.shutdown_instances !== undefined) {
+      payload.shutdown_instance = scheduleData.shutdown_instances
+    }
+    if (unsavedData && unsavedData.expiration_date) {
+      payload.expiration_date = moment(unsavedData.expiration_date).toISOString()
+    }
+    if (unsavedData && unsavedData.schedule !== null && unsavedData.schedule !== undefined && Object.keys(unsavedData.schedule).length) {
+      if (scheduleOldData) {
+        payload.schedule = { ...scheduleOldData.schedule }
       }
-      if (scheduleData.shutdown_instances !== null && scheduleData.shutdown_instances !== undefined) {
-        payload.shutdown_instance = scheduleData.shutdown_instances
-      }
-      if (unsavedData && unsavedData.expiration_date) {
-        payload.expiration_date = moment(unsavedData.expiration_date).toISOString()
-      }
-      if (unsavedData && unsavedData.schedule !== null && unsavedData.schedule !== undefined && Object.keys(unsavedData.schedule).length) {
-        if (scheduleOldData) {
-          payload.schedule = { ...scheduleOldData.schedule }
-        }
+      // $FlowIssue
+      Object.keys(unsavedData.schedule).forEach(prop => {
         // $FlowIssue
-        Object.keys(unsavedData.schedule).forEach(prop => {
-          // $FlowIssue
-          if (unsavedData.schedule[prop] !== null && unsavedData.schedule[prop] !== undefined) {
-            payload.schedule[prop] = unsavedData.schedule[prop]
-          } else {
-            delete payload.schedule[prop]
-          }
-        })
-      }
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules/${scheduleId}`,
-        method: 'PUT',
-        data: payload,
-      }).then(response => {
-        let s = { ...response.data.schedule }
-        if (s.expiration_date) {
-          s.expiration_date = DateUtils.getLocalTime(s.expiration_date)
+        if (unsavedData.schedule[prop] !== null && unsavedData.schedule[prop] !== undefined) {
+          payload.schedule[prop] = unsavedData.schedule[prop]
+        } else {
+          delete payload.schedule[prop]
         }
-        if (s.shutdown_instance) {
-          s.shutdown_instances = s.shutdown_instance
-        }
-        resolve(s)
-      }).catch(reject)
+      })
+    }
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/replicas/${replicaId}/schedules/${scheduleId}`,
+      method: 'PUT',
+      data: payload,
+    }).then(response => {
+      let s = { ...response.data.schedule }
+      if (s.expiration_date) {
+        s.expiration_date = DateUtils.getLocalTime(s.expiration_date)
+      }
+      if (s.shutdown_instance) {
+        s.shutdown_instances = s.shutdown_instance
+      }
+      return s
     })
   }
 }

src/sources/UserSource.js

@@ -54,17 +54,15 @@ class UserSource {
 
     Api.setDefaultHeader('X-Auth-Token', null)
 
-    return new Promise((resolve, reject) => {
-      Api.send({
-        url: servicesUrl.identity,
-        method: 'POST',
-        data: auth,
-      }).then((response) => {
-        let token = response.headers ? response.headers['X-Subject-Token'] || response.headers['x-subject-token'] : ''
-        Api.setDefaultHeader('X-Auth-Token', token)
-        cookie.set('unscopedToken', token, { expires: 30 })
-        resolve(response.data)
-      }).catch(reject)
+    return Api.send({
+      url: servicesUrl.identity,
+      method: 'POST',
+      data: auth,
+    }).then(response => {
+      let token = response.headers ? response.headers['X-Subject-Token'] || response.headers['x-subject-token'] : ''
+      Api.setDefaultHeader('X-Auth-Token', token)
+      cookie.set('unscopedToken', token, { expires: 30 })
+      return response.data
     })
   }
 
@@ -90,27 +88,24 @@ class UserSource {
 
     Api.setDefaultHeader('X-Auth-Token', null)
 
-    return new Promise((resolve, reject) => {
-      Api.send({
-        url: servicesUrl.identity,
-        method: 'POST',
-        data: auth,
-      }).then((response) => {
-        let token = response.headers ? response.headers['X-Subject-Token'] || response.headers['x-subject-token'] : ''
-        let data = UserModel.parseUserData(response.data)
-        data = { ...data, token }
-        cookie.set('token', data.token, { expires: 30 })
-        cookie.set('projectId', data.project.id, { expires: 30 })
-        Api.setDefaultHeader('X-Auth-Token', data.token)
-
-        resolve(data)
-      }, response => {
-        if (!skipCookie) {
-          UserSource.loginScoped(projectId, true).then(resolve, reject)
-        } else {
-          reject(response)
-        }
-      }).catch(reject)
+    return Api.send({
+      url: servicesUrl.identity,
+      method: 'POST',
+      data: auth,
+    }).then(response => {
+      let token = response.headers ? response.headers['X-Subject-Token'] || response.headers['x-subject-token'] : ''
+      let data = UserModel.parseUserData(response.data)
+      data = { ...data, token }
+      cookie.set('token', data.token, { expires: 30 })
+      cookie.set('projectId', data.project.id, { expires: 30 })
+      Api.setDefaultHeader('X-Auth-Token', data.token)
+
+      return data
+    }).catch(response => {
+      if (!skipCookie) {
+        return UserSource.loginScoped(projectId, true)
+      }
+      return Promise.reject(response)
     })
   }
 
@@ -121,70 +116,60 @@ class UserSource {
       Api.setDefaultHeader('X-Auth-Token', token)
     }
 
-    return new Promise((resolve, reject) => {
-      if (!token || !projectId) {
-        reject()
-        return
-      }
-      Api.send({
-        url: servicesUrl.identity,
-        headers: { 'X-Subject-Token': token },
-      }).then(response => {
-        let data = UserModel.parseUserData(response.data)
-        data = { ...data, token }
-        resolve(data)
-      }).catch(() => {
-        cookie.remove('token')
-        Api.setDefaultHeader('X-Auth-Token', null)
-        reject()
-      })
+    if (!token || !projectId) {
+      return Promise.reject()
+    }
+
+    return Api.send({
+      url: servicesUrl.identity,
+      headers: { 'X-Subject-Token': token },
+    }).then(response => {
+      let data = UserModel.parseUserData(response.data)
+      data = { ...data, token }
+      return data
+    }).catch(() => {
+      cookie.remove('token')
+      Api.setDefaultHeader('X-Auth-Token', null)
+      return Promise.reject()
     })
   }
 
   static switchProject(): Promise<void> {
     let token = cookie.get('unscopedToken')
-    return new Promise((resolve, reject) => {
-      if (token) {
-        cookie.remove('projectId')
-        resolve()
-      } else {
-        reject()
-      }
-    })
+    if (token) {
+      cookie.remove('projectId')
+      return Promise.resolve()
+    }
+    return Promise.reject()
   }
 
   static logout(): Promise<void> {
     let token = cookie.get('token')
-
-    return new Promise((resolve, reject) => {
-      Api.send({
-        url: servicesUrl.identity,
-        method: 'DELETE',
-        headers: { 'X-Subject-Token': token || '' },
-      }).then(() => {
-        cookie.remove('token')
-        window.location.href = '/'
-        resolve()
-      }).catch(() => {
-        cookie.remove('token')
-        window.location.href = '/'
-        reject()
-      })
-
+    let clear = () => {
+      cookie.remove('token')
+      window.location.href = '/'
       Api.setDefaultHeader('X-Auth-Token', null)
+    }
+
+    return Api.send({
+      url: servicesUrl.identity,
+      method: 'DELETE',
+      headers: { 'X-Subject-Token': token || '' },
+    }).then(() => {
+      clear()
+    }).catch(() => {
+      clear()
+      return Promise.reject()
     })
   }
 
   static getUserInfo(userId: string): Promise<User> {
-    return Api.get(`${servicesUrl.users}/${userId}`).then(response => {
-      return response.data.user
-    })
+    return Api.get(`${servicesUrl.users}/${userId}`).then(response => response.data.user)
   }
 
   static getAllUsers(): Promise<User[]> {
-    return Api.get(`${servicesUrl.users}`).then(response => {
-      return response.data.users.sort((u1, u2) => u1.name.localeCompare(u2.name))
-    })
+    return Api.get(`${servicesUrl.users}`)
+      .then(response => response.data.users.sort((u1, u2) => u1.name.localeCompare(u2.name)))
   }
 
   static update(userId: string, user: User, oldUser: ?User): Promise<User> {

src/sources/WizardSource.js

@@ -26,66 +26,45 @@ import type { MainItem } from '../types/MainItem'
 
 class WizardSource {
   static create(type: string, data: WizardData): Promise<MainItem> {
-    return new Promise((resolve, reject) => {
-      let projectId = cookie.get('projectId')
-
-      const parser = data.target ? OptionsSchemaPlugin[data.target.type] || OptionsSchemaPlugin.default : OptionsSchemaPlugin.default
-      let payload = {}
-      payload[type] = {
-        origin_endpoint_id: data.source ? data.source.id : 'null',
-        destination_endpoint_id: data.target ? data.target.id : 'null',
-        destination_environment: parser.getDestinationEnv(data),
-        instances: data.selectedInstances ? data.selectedInstances.map(i => i.instance_name) : 'null',
-        notes: '',
-      }
-
-      if (data.options && data.options.skip_os_morphing !== null && data.options.skip_os_morphing !== undefined) {
-        payload[type].skip_os_morphing = data.options.skip_os_morphing
-      }
-
-      Api.send({
-        url: `${servicesUrl.coriolis}/${projectId || 'null'}/${type}s`,
-        method: 'POST',
-        data: payload,
-      }).then(response => {
-        resolve(response.data[type])
-      }).catch(reject)
-    })
+    let projectId = cookie.get('projectId')
+
+    const parser = data.target ? OptionsSchemaPlugin[data.target.type] || OptionsSchemaPlugin.default : OptionsSchemaPlugin.default
+    let payload = {}
+    payload[type] = {
+      origin_endpoint_id: data.source ? data.source.id : 'null',
+      destination_endpoint_id: data.target ? data.target.id : 'null',
+      destination_environment: parser.getDestinationEnv(data),
+      instances: data.selectedInstances ? data.selectedInstances.map(i => i.instance_name) : 'null',
+      notes: '',
+    }
+
+    if (data.options && data.options.skip_os_morphing !== null && data.options.skip_os_morphing !== undefined) {
+      payload[type].skip_os_morphing = data.options.skip_os_morphing
+    }
+
+    return Api.send({
+      url: `${servicesUrl.coriolis}/${projectId || 'null'}/${type}s`,
+      method: 'POST',
+      data: payload,
+    }).then(response => response.data[type])
   }
 
   static createMultiple(type: string, data: WizardData): Promise<MainItem[]> {
-    return new Promise((resolve, reject) => {
-      let items = []
-      let count = 0
-
-      if (!data.selectedInstances) {
-        reject('No selected instances')
-        return
-      }
-
-      data.selectedInstances.forEach(instance => {
-        let newData = { ...data }
-        newData.selectedInstances = [instance]
-        WizardSource.create(type, newData).then(item => {
-          count += 1
-          items.push(item)
-          // $FlowIssue
-          if (count === data.selectedInstances.length) {
-            if (items.length > 0) {
-              resolve(items)
-            } else {
-              reject()
-            }
-          }
-        }, () => {
-          count += 1
-          notificationStore.notify(`Error while creating ${type} for instance ${instance.name}`, 'error', {
-            persist: true,
-            persistInfo: { title: `${type} creation error` },
-          })
+    if (!data.selectedInstances) {
+      return Promise.reject('No selected instances')
+    }
+
+    return Promise.all(data.selectedInstances.map(instance => {
+      let newData = { ...data }
+      newData.selectedInstances = [instance]
+      return WizardSource.create(type, newData).catch(() => {
+        notificationStore.notify(`Error while creating ${type} for instance ${instance.name}`, 'error', {
+          persist: true,
+          persistInfo: { title: `${type} creation error` },
         })
+        return null
       })
-    })
+    })).then(mainItems => mainItems.filter(Boolean).map(i => i))
   }
 
   static setPermalink(data: WizardData) {

src/stores/AzureStore.js

@@ -81,8 +81,6 @@ class AzureStore {
       }
       this.assessmentsProjectId = cookieProjectId
       this.assessments = assessments
-    }).catch(() => {
-      this.loadingAssessments = false
     })
   }
 

src/utils/ApiCaller.js

@@ -101,7 +101,7 @@ class ApiCaller {
             }
           }
 
-          if (error.response.status === 401 && window.location.hash !== loginUrl) {
+          if (error.response.status === 401 && window.location.hash !== loginUrl && error.request.responseURL.indexOf('/proxy/') === -1) {
             window.location.href = '/'
           }