@contrail/cli 1.0.67 → 1.0.69

package/lib/types/rule-set-uploader.js

@@ -1,172 +1,172 @@
-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;
+}

package/lib/types/type-property-policy-uploader.d.ts

@@ -1 +1 @@
-export declare function uploadTypePropertyPolicies(args: any): Promise<void>;
+export declare function uploadTypePropertyPolicies(args: any): Promise<void>;