@contrail/cli 1.0.71 → 2.0.1

package/{lib/types/rule-set-uploader.js → dist/commands/types/uploadRuleSets.js}

@@ -1,172 +1,189 @@
-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;
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadRuleSets = void 0;
+const tslib_1 = require("tslib");
+const sdk_1 = require("@contrail/sdk");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const login_1 = require("../../auth/login");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const core_1 = require("@oclif/core");
+const yaml = require('js-yaml');
+class UploadRuleSets extends core_1.Command {
+    async run() {
+        await uploadRuleSets();
+    }
+}
+exports.default = UploadRuleSets;
+UploadRuleSets.description = 'Upload an extracted rule set';
+UploadRuleSets.examples = [
+    `$ contrail types uploadRuleSets
+`,
+];
+async function uploadRuleSets() {
+    try {
+        await (0, login_1.authUser)();
+        console.log('%s Uploading', chalk_1.default.yellow.bold('RULE SET'));
+        const [reducedRuleSets, reducedRuleSetLinks] = await loadReducedRuleSets();
+        await uploadRuleSetObjects(reducedRuleSets);
+        await uploadRuleSetLinkObjects(reducedRuleSetLinks);
+        console.log('%s Uploaded', chalk_1.default.yellow.bold('RULE SET'));
+    }
+    catch (e) {
+        console.log(`%s Rule Set Upload Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Rule set Upload Complete.', chalk_1.default.green.bold('COMPLETE'));
+}
+exports.uploadRuleSets = uploadRuleSets;
+function loadReducedRuleSets() {
+    const ruleSets = [];
+    let ruleSetLinks = [];
+    const TARGET_DIR = process.cwd();
+    try {
+        const files = fs_1.default.readdirSync(path.join(TARGET_DIR, 'rule-sets'));
+        for (const file of files) {
+            ruleSets.push(yaml.load(fs_1.default.readFileSync(path.join(TARGET_DIR, 'rule-sets', file), 'utf8')));
+        }
+        ruleSetLinks = yaml.load(fs_1.default.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 sdk_1.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 sdk_1.Entities().create({
+                    entityName: 'type-rule-set',
+                    object: reducedRuleSet
+                });
+            }
+            else {
+                console.log('Updating: ', reducedRuleSet.name);
+                await new sdk_1.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 sdk_1.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 sdk_1.Entities().get({
+        entityName: 'type',
+    });
+    const currentRuleSets = await new sdk_1.Entities().get({
+        entityName: 'type-rule-set',
+    });
+    const currentRuleSetLinks = await new sdk_1.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 sdk_1.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 sdk_1.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/dist/commands/types/uploadTypePropertyPolicies.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+export default class UploadTypePropertyPolicies extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}
+export declare function uploadTypePropertyPolicies(): Promise<void>;