@itentialopensource/adapter-mockdevice 1.0.0

package/adapter.js

@@ -0,0 +1,506 @@
+// Set globals
+/* global database pronghornProps log eventSystem */
+const path = require('path');
+const fs = require('fs');
+const { unzip } = require('zlib');
+const EventEmitterCl = require('events').EventEmitter;
+const util = require('util');
+
+const encProps = pronghornProps.pathProps.encrypted;
+const Ajv = require('ajv');
+
+const ajv = new Ajv({ allErrors: true });
+const mockDeviceSchema = JSON.parse(
+  fs.readFileSync(path.join(__dirname, './mockDeviceSchema.json'), 'utf-8')
+);
+const configMgrPath = path.join(__dirname, '../../@itential/app-configuration_manager');
+const utilsPath = path.join(__dirname, '../../@itential/itential-utils');
+let MOCK_DEVICES;
+let CONFIG_PARSERS;
+let getDriver;
+let translateChangesToNativeConfig;
+let Discovery;
+let discovery;
+
+if (process.env.NODE_ENV !== 'test') {
+  ({ Discovery } = require(`${utilsPath}`));
+  discovery = new Discovery();
+  console.log(discovery);
+  MOCK_DEVICES = database.collection('mock_devices');
+  CONFIG_PARSERS = database.collection('ucm_config_parsers');
+  ({ getDriver } = discovery.require(
+    `${configMgrPath}/shared/device-config/index.js`,
+    encProps
+  ));
+  ({ translateChangesToNativeConfig } = discovery.require(
+    `${configMgrPath}/config-tools/nativeConfigConverter.js`,
+    encProps
+  ));
+}
+
+const getDeviceParser = async (deviceType) => {
+  try {
+    const parserData = await CONFIG_PARSERS.findOne({ name: deviceType });
+    if (parserData) {
+      return parserData;
+    }
+    return null;
+  } catch (error) {
+    log.error(`Failed to get device parser. ${error.message || error}`);
+    return null;
+  }
+};
+
+// Converts lines of config into changesets
+// You need changesets to rebuild a config
+/**
+ * @param lineObj
+ * @param p
+ * @param changes
+ */
+function lineToChangeSet(lineObj, p, changes) {
+  const line = lineObj.words.join(' ');
+  const parent = [...p];
+  if (lineObj.lines.length === 0) {
+    changes.push({
+      parents: p,
+      new: line,
+      old: null
+    });
+  } else {
+    parent.push(line);
+    lineObj.lines.forEach((element) => {
+      lineToChangeSet(element, parent, changes);
+    });
+  }
+}
+
+// Puts ! comments on new lines because they get removed
+// This is sketchy at best
+/**
+ * @param native
+ */
+function bangOn(native) {
+  let indent = 0;
+  const newLines = [];
+  const lines = native.split('\n');
+  lines.forEach((line) => {
+    const spacecount = line.search(/\S|$/);
+    if (spacecount < indent) {
+      let bString = '';
+      for (let index = 0; index < spacecount; index += 1) {
+        bString += ' ';
+      }
+      bString += '!';
+      newLines.push(bString);
+    }
+    newLines.push(line);
+    indent = spacecount;
+  });
+  return newLines.join('\n');
+}
+
+// Finds misplaced end and moves it to the end
+// This is mostly important for cisco-ios
+/**
+ * @param native
+ */
+function findEnd(native) {
+  const lines = native.split('\n');
+  const index = lines.indexOf('end');
+  if (index > -1) {
+    lines.splice(index, 1);
+    lines.push('end');
+  }
+  return lines.join('\n');
+}
+
+/**
+ * @param native
+ * @param line
+ */
+function removeLine(native, line) {
+  const lines = native.split('\n');
+  const index = lines.indexOf(line);
+  if (index > -1) {
+    lines.splice(index, 1);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * @param native
+ */
+function negation(native) {
+  const regex = /no .*/g;
+  const lines = native.split('\n');
+  const negatives = lines.filter((line) => line.match(regex));
+
+  let updated = native;
+  negatives.forEach((n) => {
+    const pieces = n.split('no ');
+    let ltr = pieces[1];
+    if (pieces[0].length > 0) {
+      ltr = pieces[0].split('no ') + ltr;
+    }
+    updated = removeLine(updated, ltr);
+    updated = removeLine(updated, n);
+  });
+  return updated;
+}
+
+/**
+ * @param data
+ */
+function decompressData(data) {
+  return new Promise((resolve, reject) => {
+    const buffer = Buffer.from(data, 'base64');
+    unzip(buffer, (error, bufferString) => {
+      if (error) reject(error);
+      resolve(bufferString.toString());
+    });
+  });
+}
+
+/**
+ * @param device
+ */
+function validateSchema(device) {
+  const validate = ajv.compile(mockDeviceSchema);
+  const valid = validate(device);
+  return valid;
+}
+
+class MockDevice {
+  constructor(prongid, properties) {
+    log.debug(`Mock device properties ${JSON.stringify(properties)}`);
+    console.log(`config path: ${configMgrPath}`);
+    this.props = properties;
+    this.id = prongid;
+  }
+
+  connect() {
+    setTimeout(() => {
+      this.emit('ONLINE', { id: this.id });
+      const msg = {
+        id: this.id,
+        server: 'foo',
+        type: 'MockDevice',
+        time: Date.now().toString()
+      };
+      eventSystem.publish('adapterOnline', msg);
+    }, 1000);
+  }
+
+  healthCheck(callback) {
+    const status = {
+      id: this.id,
+      status: 'success'
+    };
+    callback(status);
+  }
+
+  hasEntities(entityType, deviceList, callback) {
+    (async () => {
+      if (entityType !== 'Device') {
+        return callback(
+          null,
+          `${this.id} does not support entity ${entityType}`
+        );
+      }
+      // TODO: $in deviceList
+      const devices = await MOCK_DEVICES.find({ deleted: false }).toArray();
+      const findings = deviceList.reduce((map, device) => {
+        map[device] = false;
+        devices.forEach((foundDevice) => {
+          if (foundDevice.name === device) {
+            map[device] = true;
+          }
+        });
+        return map;
+      }, {});
+      return callback(findings);
+    })();
+  }
+
+  getDevice(deviceId, callback) {
+    (async () => {
+      const device = await MOCK_DEVICES.findOne({
+        deleted: false,
+        name: deviceId
+      });
+      if (!device) {
+        return callback(null, 'Device not found');
+      }
+      const copy = JSON.parse(JSON.stringify(device));
+      delete copy.states;
+      delete copy.actions;
+      delete copy._id;
+      delete copy.deleted;
+      delete copy.online;
+      return callback(copy);
+    })();
+  }
+
+  getDevicesFiltered(searchOptions, callback) {
+    (async () => {
+      const result = await MOCK_DEVICES.find({
+        deleted: false,
+        name: { $regex: `.*${searchOptions.filter.name}.*` }
+      }).toArray();
+      const result2 = [];
+      // eslint-disable-next-line guard-for-in
+      for (const r in result) {
+        const validateDevice = result[r];
+        if (validateSchema(validateDevice)) {
+          delete result[r]._id;
+          delete result[r].deleted;
+          delete result[r].online;
+          result2.push(result[r]);
+        }
+      }
+      // eslint-disable-next-line prefer-object-spread
+      Object.assign({}, result2);
+      return callback({
+        total: result2.length,
+        list: result2
+      });
+    })();
+  }
+
+  addDevice(device, callback) {
+    return callback({
+      code: 0,
+      value: reply
+    });
+  }
+
+  deleteDevice(deviceId, callback) {
+    return callback({
+      code: 0,
+      value: reply
+    });
+  }
+
+  isAlive(deviceId, callback) {
+    (async () => {
+      const device = await MOCK_DEVICES.findOne({
+        deleted: false,
+        name: deviceId
+      });
+      if (!device) {
+        return callback(null, 'Device not found');
+      }
+      const newDev = {};
+      newDev.response = device.online;
+      return callback(device.online);
+    })();
+  }
+
+  getConfig(deviceId, format, callback) {
+    (async () => {
+      const result = await MOCK_DEVICES.findOne({
+        deleted: false,
+        name: deviceId
+      });
+      if (result) {
+        if (
+          result.config !== undefined
+          && Object.hasOwnProperty.call(result.config, 'type')
+          && result.config.type === 'Buffer'
+        ) {
+          const decompressConfig = await decompressData(result.config);
+
+          return callback({
+            code: 200,
+            config: decompressConfig,
+            value: '?'
+          });
+        }
+        return callback({
+          device: deviceId,
+          config: result.config
+        });
+      }
+      return callback({
+        code: 404,
+        config: '?',
+        value: '?'
+      });
+    })();
+  }
+
+  setConfig(deviceId, transactions, callback) {
+    (async () => {
+      console.log(
+        `Incoming Changeset:\n ${util.inspect(transactions, {
+          showHidden: false,
+          depth: null,
+          colors: true
+        })}`
+      );
+      console.log(`Remediating config for: ${deviceId}`);
+      const device = await MOCK_DEVICES.findOne({
+        deleted: false,
+        name: deviceId
+      });
+      console.log(`Getting parser for OS: ${device.ostype}`);
+      const deviceParser = await getDeviceParser(device.ostype);
+      if (!deviceParser) {
+        const e = `Unable to find a parser for ${deviceId} with type ${device.ostype}`;
+        return callback(null, new Error(e));
+      }
+      const driver = getDriver(device.ostype, deviceParser);
+      if (!driver) {
+        const e = `Unable to find a driver for type: ${device.ostype}`;
+        return callback(null, new Error(e));
+      }
+      const parsedConfig = driver.parse(device.config);
+      const changes = [];
+      parsedConfig.lines.forEach((element) => {
+        lineToChangeSet(element, [], changes);
+      });
+
+      translateChangesToNativeConfig(
+        changes.concat(transactions),
+        deviceParser,
+        async (native) => {
+          console.log(
+            `Remediation changeset successfully integrated into: ${deviceId}`
+          );
+          const newConfig = negation(bangOn(findEnd(native)));
+          device.config = newConfig;
+          const r = await MOCK_DEVICES.updateOne(
+            { name: deviceId },
+            { $set: device }
+          );
+          console.log(`Configuration saved for: ${deviceId}`);
+          return callback({
+            status: 200,
+            results: {
+              attemptedConfig: 'TODO'
+            }
+          });
+        }
+      );
+    })();
+  }
+
+  restoreConfig(deviceId, config, callback) {
+    (async () => {
+      const result = await MOCK_DEVICES.findOne({
+        deleted: false,
+        name: deviceId
+      });
+      if (!result) {
+        return callback(
+          null,
+          `Cannot call restoreConfig on ${deviceId} not found`
+        );
+      }
+      result.config = config;
+      const r = await MOCK_DEVICES.updateOne(
+        { name: deviceId },
+        { $set: { config } }
+      );
+      return callback('success');
+    })();
+  }
+
+  getDeviceGroups(callback) {
+    const groups = [];
+    groups.push({ name: 'mock', devices: [] });
+    return callback(groups);
+  }
+
+  /**
+   * @param {Array} devices Array of unique id strings
+   * @param {string} command The command to run against the devices
+   * @param {object} options (optional) Possible specific options
+   * @param {Function} callback The callback function
+   */
+  runCommand(devices, command, options = {}, callback) {
+    (async () => {
+      const cmd = command.split(' ')[0];
+      const results = [];
+      for (const deviceId of devices) {
+        const device = await MOCK_DEVICES.findOne({
+          deleted: false,
+          name: deviceId
+        });
+        if (device) {
+          let result = 'ok';
+          if (Object.hasOwnProperty.call(device.actions, cmd)) {
+            const r = await this.doAction(device.actions[cmd], device);
+            results.push({ device: device.name, result: r, status: 'success' });
+          } else {
+            if (
+              Object.hasOwnProperty.call(device.states, 'type')
+              && device.states.type === 'Buffer'
+            ) {
+              const decompressedState = await decompressData(device.states);
+              device.states = JSON.parse(decompressedState);
+            }
+            if (Object.hasOwnProperty.call(device.states[device.current_state], command)) {
+              result = device.states[device.current_state][command];
+              results.push({
+                device: device.name,
+                result,
+                status: 'success'
+              });
+            } else {
+              results.push({
+                device: device.name,
+                result,
+                status: 'error'
+              });
+            }
+          }
+        } else {
+          console.error(`${device.name} not found?`);
+          results.push({
+            device: device.name,
+            result: 'no such device',
+            status: 'error'
+          });
+        }
+      }
+      return callback(results);
+    })();
+  }
+
+  async doAction(cmd, device) {
+    switch (cmd.action) {
+      case 'next_state':
+        const max_state = device.states.length - 1;
+        if (device.current_state < max_state) {
+          device.current_state += 1;
+        } else {
+          device.current_state = 0;
+        }
+        break;
+      case 'reset_state':
+        device.current_state = 0;
+        break;
+      case 'turn_on':
+        device.online = true;
+        break;
+      case 'turn_off':
+        device.online = false;
+        break;
+      case 'overwrite_config':
+        device.config = device.states[device.current_state][cmd.value];
+        break;
+      default:
+        console.error(`unsupported action ${action}`);
+    }
+    const r = await MOCK_DEVICES.updateOne(
+      { name: device.name },
+      { $set: device }
+    );
+    return 'Device state has been updated!';
+  }
+}
+
+util.inherits(MockDevice, EventEmitterCl);
+module.exports = MockDevice;

package/configs/arista-dcs

@@ -0,0 +1,58 @@
+vlan 10
+name HOST_10
+!
+vlan 4093
+name BGP_PEER
+trunk group BGP_PEER
+!
+interface Port-Channel1
+switchport mode trunk
+switchport trunk group BGP_PEER
+switchport trunk group MLAG
+!
+interface Ethernet5
+channel-group 1 mode active
+!
+interface Ethernet6
+no switchport
+ip address 192.168.255.1/31
+!
+interface Ethernet7
+no switchport
+ip address 192.168.255.17/31
+!
+interface Loopback0
+ip address 192.168.254.3/32
+!
+interface Vlan10
+ip address 192.168.10.2/24
+ip virtual-router address 192.168.10.1
+!
+interface Vlan4093
+ip address 1.1.1.2/31
+!
+ip routing
+no ip hardware fib route unprogrammed parent-drop
+!
+route-map BGP_PREPEND permit 10
+set as-path prepend 65101
+!
+router bgp 65000
+router-id 192.168.254.3
+update wait-install
+bgp log-neighbor-changes
+distance bgp 20 200 200
+maximum-paths 32 ecmp 32
+neighbor ARISTA peer-group
+neighbor ARISTA remote-as 64600
+neighbor ARISTA allowas-in 1
+neighbor ARISTA fall-over bfd
+neighbor ARISTA route-map BGP_PREPEND out
+neighbor ARISTA password p4ssw0rd
+neighbor 1.1.1.3 peer-group ARISTA
+neighbor 1.1.1.3 remote-as 65000
+neighbor 1.1.1.3 next-hop-self
+neighbor 192.168.255.0 peer-group ARISTA
+neighbor 192.168.255.16 peer-group ARISTA
+network 192.168.10.0/24
+network 192.168.254.3/32

package/configs/cisco-asa

@@ -0,0 +1,105 @@
+:
+ASA Version 9.0(1)
+names
+!
+interface Ethernet0
+nameif test
+security-level 10
+ip address 10.1.1.2 255.255.255.254
+!
+interface Ethernet1
+nameif inside
+security-level 100
+ip address 10.1.1.3 255.255.254.0
+!
+interface Ethernet2
+shutdown
+no nameif
+security-level 0
+no ip address
+!
+interface Ethernet3
+shutdown
+no nameif
+security-level 0
+no ip address
+!
+interface Ethernet4
+shutdown
+no nameif
+security-level 0
+no ip address
+!
+interface Ethernet5
+shutdown
+no nameif
+security-level 0
+no ip address
+!
+enable password 8Ry2YjIyt7RRXU24 encrypted
+passwd 2KFQnbNIdI.2KYOU encrypted
+hostname example1
+domain-name example.com
+boot system flash:/cdisk.bin
+ftp mode passive
+pager lines 24
+mtu test 1500
+mtu inside 1500
+monitor-interface test
+monitor-interface inside
+ASDM image flash:ASDM
+no ASDM history enable
+arp timeout 14400
+route inside 0.0.0.0 0.0.0.0 10.1.1.2
+timeout xlate 3:00:00
+timeout conn 2:00:00 half-closed 1:00:00 udp 0:02:00 icmp 1:00:00 rpc 1:00:00 h3
+23 0:05:00 h225 1:00:00 mgcp 0:05:00 mgcp-pat 0:05:00 sip 0:30:00 sip_media 0:02
+:00
+timeout uauth 0:00:00 absolute
+http server enable
+http 0.0.0.0 0.0.0.0 inside
+no snmp-server location
+no snmp-server contact
+snmp-server enable traps snmp
+fragment size 200 test
+fragment chain 24 test
+fragment timeout 5 test
+fragment size 200 inside
+fragment chain 24 inside
+fragment timeout 5 inside
+telnet 0.0.0.0 0.0.0.0 inside
+telnet timeout 1440
+ssh timeout 5
+console timeout 0
+group-policy todd internal
+!
+class-map inspection_default
+match default-inspection-traffic
+!
+!
+policy-map abc_global_fw_policy
+class inspection_default
+inspect dns
+inspect ftp
+inspect h323 h225
+inspect h323 ras
+inspect http
+inspect ils
+inspect mgcp
+inspect netbios
+inspect rpc
+inspect rsh
+inspect rtsp
+inspect sip
+inspect skinny
+inspect sqlnet
+inspect tftp
+inspect xdmcp
+inspect ctiqbe
+inspect cuseeme
+inspect icmp
+!
+terminal width 80
+service-policy abc_global_fw_policy global
+Cryptochecksum:bfecf4b9d1b98b7e8d97434851f57e14
+: end