change tracking refactoring and renaming ewc 262

src/sequelize/migrations/20181105120036-change-tracking-container-to-microservice-renaming.js

@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.renameColumn('ChangeTrackings', 'container_config', 'microservice_config')
+      .then(() => {
+        return queryInterface.renameColumn('ChangeTrackings', 'container_list', 'microservice_list')
+      })
+  },
+
+  down: (queryInterface, Sequelize) => {
+    return queryInterface.renameColumn('ChangeTrackings', 'microservice_config', 'container_config')
+      .then(() => {
+        return queryInterface.renameColumn('ChangeTrackings', 'microservice_list', 'container_list')
+      })
+  }
+};

src/sequelize/models/changetracking.js

@@ -1,3 +1,16 @@
+/*
+ *  *******************************************************************************
+ *  * Copyright (c) 2018 Edgeworx, Inc.
+ *  *
+ *  * This program and the accompanying materials are made available under the
+ *  * terms of the Eclipse Public License v. 2.0 which is available at
+ *  * http://www.eclipse.org/legal/epl-2.0
+ *  *
+ *  * SPDX-License-Identifier: EPL-2.0
+ *  *******************************************************************************
+ *
+ */
+
 'use strict';
 module.exports = (sequelize, DataTypes) => {
   const ChangeTracking = sequelize.define('ChangeTracking', {
@@ -8,9 +21,9 @@ module.exports = (sequelize, DataTypes) => {
       allowNull: false,
       field: 'id'
     },
-    containerConfig: {
+    microserviceConfig: {
       type: DataTypes.BOOLEAN,
-      field: 'container_config',
+      field: 'microservice_config',
       defaultValue: false
     },
     reboot: {
@@ -28,9 +41,9 @@ module.exports = (sequelize, DataTypes) => {
       field: 'version',
       defaultValue: false
     },
-    containerList: {
+    microserviceList: {
       type: DataTypes.BOOLEAN,
-      field: 'container_list',
+      field: 'microservice_list',
       defaultValue: false
     },
     config: {

src/services/agent-service.js

@@ -17,7 +17,7 @@ const FogProvisionKeyManager = require('../sequelize/managers/iofog-provision-ke
 const FogTypeManager = require('../sequelize/managers/iofog-type-manager');
 const FogManager = require('../sequelize/managers/iofog-manager');
 const FogAccessTokenService = require('../services/iofog-access-token-service');
-const ChangeTrackingManager = require('../sequelize/managers/change-tracking-manager');
+const ChangeTrackingService = require('./change-tracking-service');
 const FogVersionCommandManager = require('../sequelize/managers/iofog-version-command-manager');
 const StraceManager = require('../sequelize/managers/strace-manager');
 const RegistryManager = require('../sequelize/managers/registry-manager');
@@ -131,39 +131,20 @@ const updateAgentConfig = async function (updateData, fog, transaction) {
 
 const getAgentConfigChanges = async function (fog, transaction) {
 
-  const changeTracking = await ChangeTrackingManager.findOne({
-    iofogUuid: fog.uuid
-  }, transaction);
+  const changeTracking = await ChangeTrackingService.getByFogId(fog.uuid, transaction);
   if (!changeTracking) {
     throw new Errors.NotFoundError(ErrorMessages.INVALID_NODE_ID)
   }
 
-  const cleanTracking = {
-    config: false,
-    version: false,
-    reboot: false,
-    deleteNode: false,
-    containerList: false,
-    containerConfig: false,
-    routing: false,
-    registries: false,
-    tunnel: false,
-    diagnostics: false,
-    isImageSnapshot: false
-  };
-
-  await ChangeTrackingManager.update({
-    iofogUuid: fog.uuid
-  }, cleanTracking, transaction);
-
+  await ChangeTrackingService.update(fog.uuid, ChangeTrackingService.events.clean, transaction);
 
   return {
     config: changeTracking.config,
     version: changeTracking.version,
     reboot: changeTracking.reboot,
     deleteNode: changeTracking.deleteNode,
-    microserviceList: changeTracking.containerList,
-    microserviceConfig: changeTracking.containerConfig,
+    microserviceList: changeTracking.microserviceList,
+    microserviceConfig: changeTracking.microserviceConfig,
     routing: changeTracking.routing,
     registries: changeTracking.registries,
     tunnel: changeTracking.tunnel,

src/services/change-tracking-service.js

@@ -0,0 +1,91 @@
+/*
+ *  *******************************************************************************
+ *  * Copyright (c) 2018 Edgeworx, Inc.
+ *  *
+ *  * This program and the accompanying materials are made available under the
+ *  * terms of the Eclipse Public License v. 2.0 which is available at
+ *  * http://www.eclipse.org/legal/epl-2.0
+ *  *
+ *  * SPDX-License-Identifier: EPL-2.0
+ *  *******************************************************************************
+ *
+ */
+
+const ChangeTrackingManager = require('../sequelize/managers/change-tracking-manager');
+
+const events = Object.freeze({
+  clean: {
+    config: false,
+    version: false,
+    reboot: false,
+    deleteNode: false,
+    microserviceList: false,
+    microserviceConfig: false,
+    routing: false,
+    registries: false,
+    tunnel: false,
+    diagnostics: false,
+    isImageSnapshot: false
+  },
+  diagnostics: {
+    diagnostics: true
+  },
+  imageSnapshot: {
+    isImageSnapshot: true
+  },
+  microserviceFull: {
+    microserviceConfig: true,
+    microserviceList: true,
+    routing: true
+  },
+  microserviceCommon: {
+    microserviceConfig: true,
+    microserviceList: true
+  },
+  microserviceList: {
+    microserviceList: true
+  },
+  microserviceConfig: {
+    microserviceConfig: true
+  },
+  microserviceRouting: {
+    routing: true
+  },
+  version: {
+    version: true
+  },
+  reboot: {
+    reboot: true
+  },
+  deleteNode: {
+    deleteNode: true
+  },
+  registries: {
+    registries: true
+  },
+  tunnel: {
+    tunnel: true
+  },
+  config: {
+    config: true
+  }
+});
+
+async function update(fogId, data, transaction) {
+  await ChangeTrackingManager.update({iofogUuid: fogId}, data, transaction);
+}
+
+async function create(fogId, transaction) {
+  await ChangeTrackingManager.create({iofogUuid: fogId}, transaction);
+}
+
+async function getByFogId(fogId, transaction) {
+  return await ChangeTrackingManager.findOne({iofogUuid: fogId}, transaction);
+}
+
+module.exports = {
+  events: events,
+  create: create,
+  update: update,
+  getByFogId: getByFogId
+};

src/services/connector-service.js

@@ -114,9 +114,9 @@ async function _makeRequest(connector, options, data) {
         let responseObj = JSON.parse(output);
         console.log(responseObj);
         if (responseObj.errormessage) {
-          reject(new Error(responseObj.errormessage));
+          return reject(new Error(responseObj.errormessage));
         } else {
-          resolve(responseObj);
+          return resolve(responseObj);
         }
       });
     })
@@ -129,9 +129,9 @@ async function _makeRequest(connector, options, data) {
     httpreq.on('error', function(err) {
       console.log(err);
       if (err instanceof Error)
-        reject(new Error(err.message));
+        return reject(new Error(err.message));
       else
-        reject(new Error(JSON.stringify(err)));
+        return reject(new Error(JSON.stringify(err)));
     });
 
     httpreq.write(data);

src/services/diagnostic-service.js

@@ -18,7 +18,7 @@ const ErrorMessages = require('../helpers/error-messages');
 const validator = require('../schemas/index');
 const MicroserviceService = require('../services/microservices-service');
 const StraceDiagnosticManager = require('../sequelize/managers/strace-diagnostics-manager');
-const ChangeTrackingManager = require('../sequelize/managers/change-tracking-manager');
+const ChangeTrackingService = require('./change-tracking-service');
 const MicroserviceManager = require('../sequelize/managers/microservice-manager');
 const config = require('../config');
 const fs = require('fs');
@@ -41,7 +41,7 @@ const changeMicroserviceStraceState = async function (id, data, user, isCLI, tra
   };
 
   await StraceDiagnosticManager.updateOrCreate({microserviceUuid: id}, straceObj, transaction);
-  await ChangeTrackingManager.update({iofogUuid: microservice.iofogUuid}, {diagnostics: true}, transaction)
+  await ChangeTrackingService.update(microservice.iofogUuid, ChangeTrackingService.events.diagnostics, transaction)
 };
 
 const getMicroserviceStraceData = async function (id, data, user, isCLI, transaction) {
@@ -96,12 +96,8 @@ const postMicroserviceImageSnapshotCreate = async function (microserviceUuid, us
 
   let imageSnapshot = 'get_image';
 
-  const microserviceToUpdate = {
-    imageSnapshot: imageSnapshot
-  };
-
   await MicroserviceManager.update({uuid: microservice.uuid}, microserviceToUpdate, transaction);
-  await ChangeTrackingManager.update({iofogUuid: microservice.iofogUuid}, {isImageSnapshot: true}, transaction);
+  await ChangeTrackingService.update(microservice.iofogUuid, ChangeTrackingService.events.imageSnapshot, transaction);
 };
 
 const getMicroserviceImageSnapshot = async function (microserviceUuid, user, isCLI, transaction) {

src/services/flow-service.js

@@ -17,7 +17,7 @@ const AppHelper = require('../helpers/app-helper');
 const Errors = require('../helpers/errors');
 const ErrorMessages = require('../helpers/error-messages');
 const Validation = require('../schemas');
-const ChangeTrackingManager = require('../sequelize/managers/change-tracking-manager')
+const ChangeTrackingService = require('./change-tracking-service');
 
 const _createFlow = async function (flowData, user, isCLI, transaction) {
   await Validation.validate(flowData, Validation.schemas.flowCreate);
@@ -47,13 +47,28 @@ const _deleteFlow = async function (flowId, user, isCLI, transaction) {
   };
   const where = AppHelper.deleteUndefinedFields(whereObj);
 
+  await _updateChangeTrackingsByFlowId(flowId, transaction)
+
   const affectedRows = await FlowManager.delete(where, transaction);
 
   if (affectedRows === 0) {
     throw new Errors.NotFoundError(AppHelper.formatMessage(ErrorMessages.INVALID_FLOW_ID, flowId));
   }
+
 };
 
+async function _updateChangeTrackingsByFlowId(flowId, transaction) {
+  const flowWithMicroservices = await FlowManager.findFlowMicroservices({id: flowId}, transaction);
+  const onlyUnique = (value, index, self) => self.indexOf(value) === index;
+  const iofogUuids = flowWithMicroservices.microservices
+    .map(obj => obj.iofogUuid)
+    .filter(onlyUnique)
+    .filter(val => val !== null);
+  for (let iofogUuid of iofogUuids) {
+    await ChangeTrackingService.update(iofogUuid, ChangeTrackingService.events.microserviceFull, transaction);
+  }
+}
+
 const _updateFlow = async function (flowData, flowId, user, isCLI, transaction) {
   await Validation.validate(flowData, Validation.schemas.flowUpdate);
 
@@ -81,20 +96,7 @@ const _updateFlow = async function (flowData, flowId, user, isCLI, transaction)
   await FlowManager.update(where, updateFlowData, transaction);
 
   if (oldFlow.isActivated !== flowData.isActivated) {
-    const flowWithMicroservices = await FlowManager.findFlowMicroservices({id: flowId}, transaction);
-    const onlyUnique = (value, index, self) => self.indexOf(value) === index;
-    const iofogUuids = flowWithMicroservices.microservices
-      .map(obj => obj.iofogUuid)
-      .filter(onlyUnique)
-      .filter(val => val !== null);
-    for (let iofogUuid of iofogUuids) {
-      const updateChangeTrackingData = {
-        containerConfig: true,
-        containerList: true,
-        routing: true
-      };
-      await ChangeTrackingManager.update({iofogUuid: iofogUuid}, updateChangeTrackingData, transaction);
-    }
+    await _updateChangeTrackingsByFlowId(flowId, transaction);
   }
 };