@contrail/cli 1.0.67 → 1.0.69

package/src/types/rule-set-uploader.ts

@@ -1,187 +1,187 @@
-import { Entities } from '@contrail/sdk';
-import fs from 'fs';
-import * as path from 'path';
-import { authUser } from '../auth/login';
-import chalk from 'chalk';
-
-const yaml = require('js-yaml');
-
-export async function uploadRuleSets(args) {
-  try {
-    await authUser();
-
-    console.log('%s Uploading', chalk.yellow.bold('RULE SET'));
-    const [reducedRuleSets, reducedRuleSetLinks] = await loadReducedRuleSets();
-    await uploadRuleSetObjects(reducedRuleSets);
-    await uploadRuleSetLinkObjects(reducedRuleSetLinks);
-    console.log('%s Uploaded', chalk.yellow.bold('RULE SET'));
-
-  }
-  catch (e) {
-    console.log(`%s Rule Set Upload Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  console.log('%s Rule set Upload Complete.', chalk.green.bold('COMPLETE'));
-}
-
-function loadReducedRuleSets() {
-  const ruleSets = [];
-  let ruleSetLinks = [];
-  const TARGET_DIR = process.cwd();
-  try {
-    const files = fs.readdirSync(path.join(TARGET_DIR, 'rule-sets'));
-    for(const file of files) {
-      ruleSets.push(yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'rule-sets', file), 'utf8')));
-    }
-    ruleSetLinks = yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'rule-set-links.yml'), 'utf8'));
-    return [ruleSets, ruleSetLinks];
-  } catch (e) {
-    throw new Error(`ERROR PARSING YAML: ${e}`);
-  }
-}
-
-async function uploadRuleSetObjects(reducedRuleSets) {
-
-  const currentRuleSets = await new Entities().get({
-    entityName: 'type-rule-set',
-  });
-
-  const currentRuleSetsByName = {};
-  for (const currentRuleSet of currentRuleSets) {
-    currentRuleSetsByName[currentRuleSet.name] = currentRuleSet;
-  }
-
-  const loadedRuleSetsByName = {};
-  for (const loadedRuleSet of reducedRuleSets) {
-    loadedRuleSetsByName[loadedRuleSet.name] = loadedRuleSet;
-  }
-
-  console.debug('current rule sets:', currentRuleSets);
-  console.debug('reduced rule sets:', reducedRuleSets);
-
-  for (const reducedRuleSet of reducedRuleSets) {
-    try {
-      const found = currentRuleSetsByName[reducedRuleSet.name];
-      if (!found) {
-        console.log('Creating: ', reducedRuleSet.name);
-        await new Entities().create({
-          entityName: 'type-rule-set',
-          object: reducedRuleSet
-        });
-      } else {
-        console.log('Updating: ', reducedRuleSet.name);
-        await new Entities().update({
-          entityName: 'type-rule-set',
-          id: found.id,
-          object: reducedRuleSet,
-        });
-      }
-    } catch (err) {
-      throw new Error(`Error Uploading rule sets: ${err}`);
-    }
-  }
-
-  for (const currentRuleSet of currentRuleSets) {
-    try {
-      const found = loadedRuleSetsByName[currentRuleSet.name];
-      if (!found) {
-        console.log('Deleting: ', currentRuleSet.name);
-        await new Entities().delete({
-          entityName: 'type-rule-set',
-          id: currentRuleSet.id,
-        });
-      }
-    } catch (err) {
-      throw new Error(`Error Deleting rule set: ${err}`);
-    }
-  }
-
-}
-
-async function uploadRuleSetLinkObjects(loadedRuleSetLinks) {
-
-  const types = await new Entities().get({
-    entityName: 'type',
-  });
-
-  const currentRuleSets = await new Entities().get({
-    entityName: 'type-rule-set',
-  });
-
-  const currentRuleSetLinks = await new Entities().get({
-    entityName: 'type-rule-set-link',
-  });
-
-  const currentLinksHashes = {};
-  for (const currentLink of currentRuleSetLinks) {
-    const foundType = types.find(t => t.id === currentLink.typeId);
-    const foundRuleSet = currentRuleSets.find(rs => rs.id === currentLink.typeRuleSetId);
-    const hash = `${foundType.slug}|${foundRuleSet.name}`;
-    currentLinksHashes[hash] = currentLink;
-  }
-
-  const reducedLinksByHashes = {};
-  for (const loadedLink of loadedRuleSetLinks) {
-    const hash = `${loadedLink.type}|${loadedLink.ruleSet}`;
-    reducedLinksByHashes[hash] = loadedLink;
-  }
-
-  console.debug('current rule set links:', currentLinksHashes);
-  console.debug('reduced rule set links:', reducedLinksByHashes);
-
-  for (const loadedRuleSetLink of loadedRuleSetLinks) {
-    try {
-      const found = currentLinksHashes[`${loadedRuleSetLink.type}|${loadedRuleSetLink.ruleSet}`];
-      if (!found) {
-        if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) { continue; }
-        console.log('Creating: ', loadedRuleSetLink);
-        await new Entities().create({
-          entityName: 'type-rule-set-link',
-          object: {
-            typeRuleSetId: loadedRuleSetLink.ruleSet,
-            typeId: loadedRuleSetLink.type,
-          },
-        });
-      } else {
-        if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) { continue; }
-        console.log('skipping updating existing rule set link: ', loadedRuleSetLink);
-      }
-    } catch (err) {
-      throw new Error(`Error Uploading rule set links: ${err}`);
-    }
-  }
-
-  for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
-    try {
-      const found = reducedLinksByHashes[currentLinkHash];
-      if (!found) {
-        console.log('Deleting: ', currentLinkHash);
-        await new Entities().delete({
-          entityName: 'type-rule-set-link',
-          id: currentLink['id'],
-        });
-      }
-    } catch (err) {
-      throw new Error(`Error Deleting rule set link: ${err}`);
-    }
-  }
-
-}
-
-function transformReducedLink(ruleSetLink, types, ruleSets) {
-  const foundType = types.find(t => t.slug === ruleSetLink.type);
-  if (!foundType) {
-    console.error('Could not find type with name', ruleSetLink.type);
-    return false;
-  }
-  ruleSetLink.type = foundType.id;
-
-  const foundRuleSet = ruleSets.find(rs => rs.name === ruleSetLink.ruleSet);
-  if (!foundRuleSet) {
-    console.error('Could not find rule set with name', foundType.ruleSet);
-    return false;
-  }
-  ruleSetLink.ruleSet = foundRuleSet.id;
-  return true;
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import * as path from 'path';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+
+const yaml = require('js-yaml');
+
+export async function uploadRuleSets(args) {
+  try {
+    await authUser();
+
+    console.log('%s Uploading', chalk.yellow.bold('RULE SET'));
+    const [reducedRuleSets, reducedRuleSetLinks] = await loadReducedRuleSets();
+    await uploadRuleSetObjects(reducedRuleSets);
+    await uploadRuleSetLinkObjects(reducedRuleSetLinks);
+    console.log('%s Uploaded', chalk.yellow.bold('RULE SET'));
+
+  }
+  catch (e) {
+    console.log(`%s Rule Set Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Rule set Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+
+function loadReducedRuleSets() {
+  const ruleSets = [];
+  let ruleSetLinks = [];
+  const TARGET_DIR = process.cwd();
+  try {
+    const files = fs.readdirSync(path.join(TARGET_DIR, 'rule-sets'));
+    for(const file of files) {
+      ruleSets.push(yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'rule-sets', file), 'utf8')));
+    }
+    ruleSetLinks = yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'rule-set-links.yml'), 'utf8'));
+    return [ruleSets, ruleSetLinks];
+  } catch (e) {
+    throw new Error(`ERROR PARSING YAML: ${e}`);
+  }
+}
+
+async function uploadRuleSetObjects(reducedRuleSets) {
+
+  const currentRuleSets = await new Entities().get({
+    entityName: 'type-rule-set',
+  });
+
+  const currentRuleSetsByName = {};
+  for (const currentRuleSet of currentRuleSets) {
+    currentRuleSetsByName[currentRuleSet.name] = currentRuleSet;
+  }
+
+  const loadedRuleSetsByName = {};
+  for (const loadedRuleSet of reducedRuleSets) {
+    loadedRuleSetsByName[loadedRuleSet.name] = loadedRuleSet;
+  }
+
+  console.debug('current rule sets:', currentRuleSets);
+  console.debug('reduced rule sets:', reducedRuleSets);
+
+  for (const reducedRuleSet of reducedRuleSets) {
+    try {
+      const found = currentRuleSetsByName[reducedRuleSet.name];
+      if (!found) {
+        console.log('Creating: ', reducedRuleSet.name);
+        await new Entities().create({
+          entityName: 'type-rule-set',
+          object: reducedRuleSet
+        });
+      } else {
+        console.log('Updating: ', reducedRuleSet.name);
+        await new Entities().update({
+          entityName: 'type-rule-set',
+          id: found.id,
+          object: reducedRuleSet,
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Uploading rule sets: ${err}`);
+    }
+  }
+
+  for (const currentRuleSet of currentRuleSets) {
+    try {
+      const found = loadedRuleSetsByName[currentRuleSet.name];
+      if (!found) {
+        console.log('Deleting: ', currentRuleSet.name);
+        await new Entities().delete({
+          entityName: 'type-rule-set',
+          id: currentRuleSet.id,
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Deleting rule set: ${err}`);
+    }
+  }
+
+}
+
+async function uploadRuleSetLinkObjects(loadedRuleSetLinks) {
+
+  const types = await new Entities().get({
+    entityName: 'type',
+  });
+
+  const currentRuleSets = await new Entities().get({
+    entityName: 'type-rule-set',
+  });
+
+  const currentRuleSetLinks = await new Entities().get({
+    entityName: 'type-rule-set-link',
+  });
+
+  const currentLinksHashes = {};
+  for (const currentLink of currentRuleSetLinks) {
+    const foundType = types.find(t => t.id === currentLink.typeId);
+    const foundRuleSet = currentRuleSets.find(rs => rs.id === currentLink.typeRuleSetId);
+    const hash = `${foundType.slug}|${foundRuleSet.name}`;
+    currentLinksHashes[hash] = currentLink;
+  }
+
+  const reducedLinksByHashes = {};
+  for (const loadedLink of loadedRuleSetLinks) {
+    const hash = `${loadedLink.type}|${loadedLink.ruleSet}`;
+    reducedLinksByHashes[hash] = loadedLink;
+  }
+
+  console.debug('current rule set links:', currentLinksHashes);
+  console.debug('reduced rule set links:', reducedLinksByHashes);
+
+  for (const loadedRuleSetLink of loadedRuleSetLinks) {
+    try {
+      const found = currentLinksHashes[`${loadedRuleSetLink.type}|${loadedRuleSetLink.ruleSet}`];
+      if (!found) {
+        if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) { continue; }
+        console.log('Creating: ', loadedRuleSetLink);
+        await new Entities().create({
+          entityName: 'type-rule-set-link',
+          object: {
+            typeRuleSetId: loadedRuleSetLink.ruleSet,
+            typeId: loadedRuleSetLink.type,
+          },
+        });
+      } else {
+        if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) { continue; }
+        console.log('skipping updating existing rule set link: ', loadedRuleSetLink);
+      }
+    } catch (err) {
+      throw new Error(`Error Uploading rule set links: ${err}`);
+    }
+  }
+
+  for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+    try {
+      const found = reducedLinksByHashes[currentLinkHash];
+      if (!found) {
+        console.log('Deleting: ', currentLinkHash);
+        await new Entities().delete({
+          entityName: 'type-rule-set-link',
+          id: currentLink['id'],
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Deleting rule set link: ${err}`);
+    }
+  }
+
+}
+
+function transformReducedLink(ruleSetLink, types, ruleSets) {
+  const foundType = types.find(t => t.slug === ruleSetLink.type);
+  if (!foundType) {
+    console.error('Could not find type with name', ruleSetLink.type);
+    return false;
+  }
+  ruleSetLink.type = foundType.id;
+
+  const foundRuleSet = ruleSets.find(rs => rs.name === ruleSetLink.ruleSet);
+  if (!foundRuleSet) {
+    console.error('Could not find rule set with name', foundType.ruleSet);
+    return false;
+  }
+  ruleSetLink.ruleSet = foundRuleSet.id;
+  return true;
 }