Name

sn_agent.AccPolicyDependecyExporter

Description

No description available

Script

var AccPolicyDependecyExporter = Class.create();

AccPolicyDependecyExporter.UPDATE_SET_PREFIX = 'AccPolicyExport';

/*
- Policies
- Checks
- Check Definitions
- Check Groups
- Check Parameters
- Check Parameter Definition
- Secure Check Parameters
- Secure Check Parameter Definition
- Check Type
- Plugin (asset_name) names
- Plugins (asset)
- Plugin Attachment
- Plugin Attachment Docs
*/
AccPolicyDependecyExporter.prototype = {
  DEPENDED_TABLES: {
      SN_AGENT_POLICY: 'sn_agent_policy',
      SN_AGENT_CHECK: 'sn_agent_check',
      SN_AGENT_CHECK_DEF: 'sn_agent_check_def',
      SN_AGENT_CHECK_GROUP: 'sn_agent_check_group',
      SN_AGENT_CHECK_PARAM: 'sn_agent_check_param',
      SN_AGENT_CHECK_PARAM_DEF: 'sn_agent_check_param_def',
      SN_AGENT_CHECK_SECURE_PARAM: 'sn_agent_check_secure_param',
      SN_AGENT_CHECK_SECURE_PARAM_DEF: 'sn_agent_check_secure_param_def',
      SN_AGENT_CHECK_TYPE: 'sn_agent_check_type',
      SN_AGENT_ASSET: 'sn_agent_asset',
      SN_AGENT_ASSET_NAME: 'sn_agent_asset_name',
      SYS_ATTACHMENT: 'sys_attachment',
      SYS_ATTACHMENT_DOC: 'sys_attachment_doc',
      ECC_AGENT_SCRIPT_INCLUDE: 'ecc_agent_script_include',
      CMDB_GROUP: 'cmdb_group',
      CMDB_GROUP_CONATINS_QB: 'cmdb_group_contains_qb_query',
      CMDB_GROUP_CONATINS_EQ: 'cmdb_group_contains_encoded_query',
      CMDB_QB_SAVED_QUERY: 'qb_saved_query',
      SYS_ALIAS: 'sys_alias',
      SN_AGENT_CRON_EXPRESSION: 'sn_agent_cron_expression',
  },

  RELATIONSHIP_STATE: {
      FLAT: 0,
      PARENT: 1,
      CHILD: 2
  },

  initialize: function(policyList, publisher, intervalPercent, logger) {
      this.policyList = this.addChildPolicies(policyList);
      this.publisher = publisher;
      this.logger = logger;
      this.intervalPercent = intervalPercent;
  },

  addChildPolicies: function(pList) {
      var ret = pList;
      var gr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_POLICY);
      gr.addQuery('published_parent', pList);
      gr.addQuery('relationship_state', this.RELATIONSHIP_STATE.CHILD);
      gr.addQuery('is_draft', false);
      gr.addQuery('publish_status', '1');
      gr.query();
      while (gr.next())
          ret.push(gr.getUniqueValue());
      return ret;
  },

  exportData: function() {
      for (var policyIndex in this.policyList) {
          var policySysId = this.policyList[policyIndex];
          var checkGroups = [];
          var checkSysIds = [];
          var checkDefSysIds = [];
          var checkTypeSysIds = [];
          var cronExpressionSysIds = [];
          this.logger.log("Exporting dependencies for policy: " + this._getPolicyName(policySysId));
          this.publisher.updateTracker(this.intervalPercent);
          var gr = this.getPolicyRecord(policySysId);
          this.publisher.publishSingle(gr);
          var gr2 = this.getPolicyRecord(policySysId);
          if (gr2.next() && !gs.nil(gr2.getValue('check_group')) && checkGroups.indexOf(gr2.getValue('check_group')) == -1)
              checkGroups.push(gr2.getValue('check_group'));
          //collect cron ids from policy
          this.appendIdsFromListRef(gr2, "cron_expressions", cronExpressionSysIds);

          this.publisher.updateTracker(this.intervalPercent);
          var checkGr = this.getSnAgentCheckRecords(policySysId);
          this.publisher.publishSingle(checkGr);
          var checkGr2 = this.getSnAgentCheckRecords(policySysId);
          while (checkGr2.next()) {
              if (checkSysIds.indexOf(checkGr2.getValue('sys_id')) == -1)
                  checkSysIds.push(checkGr2.getValue('sys_id'));
              if (checkDefSysIds.indexOf(checkGr2.getValue('check_def')) == -1)
                  checkDefSysIds.push(checkGr2.getValue('check_def'));
              //collect cron ids from check instances
              this.appendIdsFromListRef(checkGr2, "cron_expressions", cronExpressionSysIds);
          }
          this.publisher.updateTracker(this.intervalPercent);
          var checkDefGr = this.getSnAgentCheckDefRecords(checkDefSysIds);
          this.publisher.publishSingle(checkDefGr);
          var checkDefGr2 = this.getSnAgentCheckDefRecords(checkDefSysIds);
          var assetNameIds = [];
          while (checkDefGr2.next()) {
              if (checkGroups.indexOf(checkDefGr2.getValue('check_group')) == -1)
                  checkGroups.push(checkDefGr2.getValue('check_group'));
              if (checkTypeSysIds.indexOf(checkDefGr2.getValue('check_script_type')) == -1)
                  checkTypeSysIds.push(checkDefGr2.getValue('check_script_type'));

              //collect assetNameIds
              this.appendIdsFromListRef(checkDefGr2, "assets", assetNameIds);

              //collect cron ids from check definitions
              this.appendIdsFromListRef(checkDefGr2, "cron_expressions", cronExpressionSysIds);
          }
          this.publisher.updateTracker(this.intervalPercent);
          this.publisher.publishMultiple(this.getDependencyRecords(policySysId, checkGroups, checkSysIds, checkDefSysIds, checkTypeSysIds, assetNameIds, gr2, cronExpressionSysIds));
          //Add deleted check and check param records related to exported policy
          this.publisher.addDeleteRecordsToGlobalUpdateset(this.getDeletedCheckRecords(policySysId, checkSysIds));

          //Check if this policy ever had parent that was deleted, if so export the deleted parent record
          var deletedParent = this.getDeletedParentPolicyRecords(policySysId);
          if (deletedParent)
              this.publisher.addDeleteRecordsToGlobalUpdateset(deletedParent);

          //Check if this policy ever had children that were deleted, if so export the deleted children records
          this.publisher.addDeleteRecordsToGlobalUpdateset(this.getDeletedChildPolicyRecords(policySysId));

          this.publisher.updateTracker(this.intervalPercent);
      }
      this._addMidSyncRecordToUpdateset();
      this._addExportedSysIdsForDraftDeletion();
  },

  appendIdsFromListRef: function(gr, columnName, refIdsArr) {
      var grRefIds = gr.getValue(columnName);
      if (grRefIds) {
          var nIds = grRefIds.split(',');
          for (var i = 0; i < nIds.length; i++) {
              if (refIdsArr.indexOf(nIds[i]) == -1) {
                  refIdsArr.push(nIds[i]);
              }
          }
      }
  },


  getPolicyRecord: function(policyId) {
      var gr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_POLICY);
      gr.addQuery('sys_id', policyId);
      gr.query();
      return gr;
  },
  getSnAgentCheckRecords: function(policyId) {
      var checkGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK);
      checkGr.addQuery("monitoring_policy", policyId);
      checkGr.query();
      return checkGr;
  },
  getSnAgentCheckDefRecords: function(checkDefSysIds) {
      var checkDefGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_DEF);
      checkDefGr.addQuery('sys_id', checkDefSysIds);
      checkDefGr.query();
      return checkDefGr;
  },

  getDependencyRecords: function(policyId, checkGroups, checkSysIds, checkDefSysIds, checkTypeSysIds, assetNameIds, policyGR, cronExpressionSysIds) {
      var ret = [];
      var checkGroupGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_GROUP);
      checkGroupGr.addQuery('sys_id', checkGroups);
      checkGroupGr.query();
      ret.push(checkGroupGr);
      var checkParamGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_PARAM);
      checkParamGr.addQuery('check', checkSysIds);
      checkParamGr.query();
      ret.push(checkParamGr);
      var checkParamDefGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_PARAM_DEF);
      checkParamDefGr.addQuery('check_def', checkDefSysIds);
      checkParamDefGr.query();
      ret.push(checkParamDefGr);
      var checkSecureParamGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_SECURE_PARAM);
      checkSecureParamGr.addQuery('check', checkSysIds);
      checkSecureParamGr.query();
      ret.push(checkSecureParamGr);
      var checkSecureParamDefGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_SECURE_PARAM_DEF);
      checkSecureParamDefGr.addQuery('check_def', checkDefSysIds);
      checkSecureParamDefGr.query();
      ret.push(checkSecureParamDefGr);
      var checkTypeGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_TYPE);
      checkTypeGr.addQuery('sys_id', checkTypeSysIds);
      checkTypeGr.query();
      ret.push(checkTypeGr);
      var midScriptSysIds = this.getMidScriptSysIds(checkTypeSysIds);
      if (midScriptSysIds.length > 0) {
          var midScriptQueryParams = {};
          midScriptQueryParams['sys_id'] = midScriptSysIds;
          var midScriptGr = this.publisher.getGlobalScopeRecords(this.DEPENDED_TABLES.ECC_AGENT_SCRIPT_INCLUDE, midScriptQueryParams);
          ret.push(midScriptGr);
      }
      var assetNamesGr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_ASSET_NAME);
      assetNamesGr.addQuery('sys_id', assetNameIds);
      assetNamesGr.query();
      ret.push(assetNamesGr);
      var assetGr = this.publisher.getAssets(assetNameIds);
      ret.push(assetGr);
      var assetAttachmentGr = this.publisher.getAttachments(assetNameIds);
      ret.push(assetAttachmentGr);

      // try to use new getAttachmentDocsArr api, if its not found in family release use old api
      if (this.publisher.getAttachmentDocsArr !== undefined) {
          var assetAttachmentDocGrArr = this.publisher.getAttachmentDocsArr(assetNameIds);
          for (var i in assetAttachmentDocGrArr) {
              ret.push(assetAttachmentDocGrArr[i]);
          }
      } else {
          var assetAttachmentDocGr = this.publisher.getAttachmentDocs(assetNameIds);
          ret.push(assetAttachmentDocGr);
      }

      this.addCmdbGroupDependencies(policyGR.getValue("monitored_ci_group"), ret);

      //add cred alias
      this.addTableBySysId(policyGR.getValue("credential_alias"), this.DEPENDED_TABLES.SYS_ALIAS, ret);

      //add cron expression
      this.addTableBySysId(cronExpressionSysIds, this.DEPENDED_TABLES.SN_AGENT_CRON_EXPRESSION, ret);



      return ret;
  },

  getMidScriptSysIds: function(typeSysIds) {
      var ret = [];
      var gr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_CHECK_TYPE);
      gr.addQuery('sys_id', typeSysIds);
      gr.query();
      while (gr.next())
          ret.push(gr.getValue('mid_script'));
      return ret;
  },

  getDeletedCheckRecords: function(policyId, checkIds) {
      //add deleted checks. These need to be deleted from target as well for parity.
      var delPolicyGr = new GlideRecord('sys_update_xml');
      delPolicyGr.addQuery('action', 'DELETE');
      delPolicyGr.addQuery('payload', 'CONTAINS', policyId + '</monitoring_policy>');
      delPolicyGr.addQuery('type', 'Check Instance');
      delPolicyGr.query();
      while (delPolicyGr.next()) {
          var delCheckSysId = delPolicyGr.getValue('name').split('sn_agent_check_')[1];
          checkIds.push(delCheckSysId);
      }
      var checkList = '';
      for (var i = 0; i < checkIds.length; i++) {
          checkList += checkIds[i] + '</check>';
          if (i < (checkIds.length - 1))
              checkList += '^ORpayloadLIKE';
      }
      var delGr = new GlideRecord('sys_update_xml');
      //this queryString says the following:
      //get all DELETE action records where name starts with sn_agent_check_ and payload contains policyId</monitoring_policy>
      //OR all DELETE action records where name starts with sn_agent_check_param_ and payload contains checkId</check>
      //OR all DELETE action records where name starts with sn_agent_check_secure_param and payload contains checkId</check>
      var queryString = 'action=DELETE^nameSTARTSWITHsn_agent_check_^payloadLIKE' + policyId + '</monitoring_policy>^NQaction=DELETE^nameSTARTSWITHsn_agent_check_param_^payloadLIKE' + checkList + '^NQaction=DELETE^nameSTARTSWITHsn_agent_check_secure_param^payloadLIKE' + checkList;
      delGr.addEncodedQuery(queryString);
      delGr.query();
      return delGr;
  },

  //will return record only in case there was actual parent deleted
  getDeletedParentPolicyRecords: function(policySysId) {
      var deletedParentPolicyId;
      var gr = new GlideRecord('sys_update_xml');
      gr.addEncodedQuery('type=Policy^action=INSERT_OR_UPDATE^payloadLIKE<published_parent display_value^name=sn_agent_policy_' + policySysId);
      gr.orderByDesc('sys_created_on');
      gr.query();
      if (gr.next()) {
          var customerUpdateRecord = this._parseCustomerUpdatePayload(gr.payload);
          deletedParentPolicyId = customerUpdateRecord['published_parent'];
      }
      if (!gs.nil(deletedParentPolicyId)) {
          var delGr = new GlideRecord('sys_update_xml');
          delGr.addEncodedQuery('type=Policy^action=DELETE^name=sn_agent_policy_' + deletedParentPolicyId);
          delGr.query();
          return delGr;
      }
      //no parent was deleted
      return "";
  },

  getDeletedChildPolicyRecords: function(parentPolicySysId) {
      var deletedChildrenPolicyIds;
      var gr = new GlideRecord('sys_update_xml');
      gr.addEncodedQuery('type=Policy^action=DELETE^payloadLIKE' + parentPolicySysId + '</published_parent>^payloadLIKE<is_draft>false</is_draft>');
      gr.query();
      return gr;
  },

  addCmdbGroupDependencies: function(cmdbGroupName, ret) {
      if (!gs.nil(cmdbGroupName)) {
          var groupRecord = this.getCmdbGroupRecord(cmdbGroupName);
          if (groupRecord.next()) {
              var groupSysId = groupRecord.getValue("sys_id");
              ret.push(this.getCmdbGroupRecord(cmdbGroupName));
              var qbContains = this.getCmdbGroupContainsRecord(this.DEPENDED_TABLES.CMDB_GROUP_CONATINS_QB, groupSysId);
              if (qbContains.next()) {
                  var qbQueryId = qbContains.getValue("qb_query");
                  ret.push(this.getCmdbGroupContainsRecord(this.DEPENDED_TABLES.CMDB_GROUP_CONATINS_QB, groupSysId));
                  var qbRecord = new GlideRecord(this.DEPENDED_TABLES.CMDB_QB_SAVED_QUERY);
                  qbRecord.addQuery("sys_id", qbQueryId);
                  qbRecord.query();
                  ret.push(qbRecord);
              }
              ret.push(this.getCmdbGroupContainsRecord(this.DEPENDED_TABLES.CMDB_GROUP_CONATINS_EQ, groupSysId));
          }
      }
  },

  addTableBySysId: function(sysIds, table, ret) {
      if (!gs.nil(sysIds)) {
          var glideRecord = new GlideRecord(table);
          glideRecord.addQuery("sys_id", sysIds);
          glideRecord.query();
          ret.push(glideRecord);
      }
  },

  getCmdbGroupRecord: function(cmdbGroupName) {
      var groupRecord = new GlideRecord(this.DEPENDED_TABLES.CMDB_GROUP);
      groupRecord.addQuery("group_name", cmdbGroupName);
      groupRecord.query();
      return groupRecord;
  },

  getCmdbGroupContainsRecord: function(tableName, groupSysId) {
      var qbContains = new GlideRecord(tableName);
      qbContains.addQuery("group", groupSysId);
      qbContains.query();
      return qbContains;
  },

  _getPolicyName: function(policyId) {
      var gr = new GlideRecord(this.DEPENDED_TABLES.SN_AGENT_POLICY);
      if (gr.get(policyId))
          return gr.name;
      return null;
  },
  _addMidSyncRecordToUpdateset: function() {
      var currentTime = new GlideDateTime();
      var syncRecordXml =
          '<?xml version="1.0" encoding="UTF-8"?>' +
          '<unload unload_date="' + new GlideDateTime() + '">' +
          '<sn_agent_flags action="INSERT_OR_UPDATE">' +
          '<hash>true</hash>' +
          '<name>acc_sync_all_mids_after_import</name>' +
          '<sys_created_by>admin</sys_created_by>' +
          '<sys_created_on>' + new GlideDateTime() + '</sys_created_on>' +
          '<sys_domain>global</sys_domain>' +
          '<sys_id>c609408bb7561010c3608129ce11a9f2</sys_id>' +
          '<sys_mod_count>0</sys_mod_count>' +
          '<sys_updated_by>admin</sys_updated_by>' +
          '<sys_updated_on>' + new GlideDateTime() + '</sys_updated_on>' +
          '</sn_agent_flags>' +
          '</unload>';
      var nameValuePairs = {};
      nameValuePairs['application'] = 'deb59787c317030039a3553a81d3aee9';
      nameValuePairs['category'] = 'customer';
      nameValuePairs['name'] = 'sn_agent_flags_c609408bb7561010c3608129ce11a9f2';
      nameValuePairs['update_domain'] = 'global';
      nameValuePairs['target_name'] = 'acc_sync_all_mids_after_import';
      nameValuePairs['payload'] = syncRecordXml;
      nameValuePairs['action'] = 'INSERT_OR_UPDATE';
      nameValuePairs['type'] = 'ACC Flags';
      this.publisher.addVirtualRecordToUpdateset(nameValuePairs);
  },

  _addExportedSysIdsForDraftDeletion: function() {
      var currentTime = new GlideDateTime();
      var policySysIdRecordXml =
          '<?xml version="1.0" encoding="UTF-8"?>' +
          '<record_update sys_domain="global" table="sn_agent_flags">' +
          '<sn_agent_flags action="INSERT_OR_UPDATE">' +
          '<hash>' + this.policyList + '</hash>' +
          '<name>imported_policy_list</name>' +
          '<sys_created_by>admin</sys_created_by>' +
          '<sys_created_on>' + currentTime + '</sys_created_on>' +
          '<sys_domain>global</sys_domain>' +
          '<sys_id>6b73f1e6b730201018c58129ce11a9e2</sys_id>' +
          '<sys_mod_count>0</sys_mod_count>' +
          '<sys_updated_by>admin</sys_updated_by>' +
          '<sys_updated_on>' + currentTime + '</sys_updated_on>' +
          '</sn_agent_flags></record_update>';

      var nameValuePairs = {};
      nameValuePairs['application'] = 'deb59787c317030039a3553a81d3aee9';
      nameValuePairs['category'] = 'customer';
      nameValuePairs['name'] = 'sn_agent_flags_6b73f1e6b730201018c58129ce11a9e2';
      nameValuePairs['update_domain'] = 'global';
      nameValuePairs['target_name'] = 'imported_policy_list';
      nameValuePairs['payload'] = policySysIdRecordXml;
      nameValuePairs['action'] = 'INSERT_OR_UPDATE';
      nameValuePairs['type'] = 'ACC Flags';
      this.publisher.addVirtualRecordToUpdateset(nameValuePairs);
  },

  _parseCustomerUpdatePayload: function(xmlString) {
      var doc = new XMLDocument2();
      var result = {},
          n;
      try {
          doc.parseXML(xmlString);

          var recordNode = doc.getNode('record_update/*[node()]');
          var nodeName = recordNode.getNodeName();

          //sys_documentation, sys_ui_list, sys_ui_related, sys_ui_section, sys_choice records have extra node
          if (nodeName === 'sys_documentation' ||
              nodeName === 'sys_ui_list' ||
              nodeName === 'sys_ui_related' ||
              nodeName === 'sys_ui_section' ||
              nodeName === 'sys_choice')
              recordNode = doc.getNode('record_update/*[node()]/*[node()]');

          var recordIterator = recordNode.getChildNodeIterator();
          while (recordIterator.hasNext()) {
              n = recordIterator.next();
              result[n.getNodeName()] = n.getTextContent();
          }
      } catch (e) {
          gs.error("Invalid payload of sys_update_xml " + xmlString);
      }

      return result;
  },

  type: 'AccPolicyDependecyExporter'
};

Sys ID

eaa6e87db720e01018c58129ce11a928

Offical Documentation

Official Docs: