@grnsft/if 0.0.2

package/build/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const args_1 = require("./util/args");
+const errors_1 = require("./util/errors");
+const helpers_1 = require("./util/helpers");
+const models_universe_1 = require("./util/models-universe");
+const supercomputer_1 = require("./util/supercomputer");
+const validations_1 = require("./util/validations");
+const yaml_1 = require("./util/yaml");
+const config_1 = require("./config");
+const { CliInputError } = errors_1.ERRORS;
+const { DISCLAIMER_MESSAGE, SOMETHING_WRONG } = config_1.STRINGS;
+/**
+ * 1. Parses yml input/output process arguments.
+ * 2. Opens yaml file as an object.
+ * 3. Initializes models.
+ * 4. Initializes graph, does computing.
+ * 5. Saves processed object as a yaml file.
+ * @example run `npx ts-node impact-engine.ts --impl ./test.yml --ompl ./result.yml`
+ * @example run `npm run impact-engine -- --impl ./test.yml --ompl ./result.yml`
+ */
+const impactEngine = async () => {
+    console.log(DISCLAIMER_MESSAGE);
+    const processParams = (0, args_1.parseProcessArgument)();
+    if (processParams) {
+        const { inputPath, outputPath } = processParams;
+        const rawImpl = await (0, yaml_1.openYamlFileAsObject)(inputPath);
+        // Lifecycle Validation
+        const impl = (0, validations_1.validateImpl)(rawImpl);
+        // Lifecycle Initialize Models
+        const modelsHandbook = new models_universe_1.ModelsUniverse();
+        impl.initialize.models.forEach((model) => modelsHandbook.writeDown(model));
+        // Lifecycle Computing
+        const ateruiComputer = new supercomputer_1.Supercomputer(impl, modelsHandbook);
+        const ompl = await ateruiComputer.compute();
+        if (!outputPath) {
+            console.log(JSON.stringify(ompl));
+            return;
+        }
+        await (0, yaml_1.saveYamlFileAs)(ompl, outputPath);
+        return;
+    }
+    return Promise.reject(new CliInputError(SOMETHING_WRONG));
+};
+impactEngine().catch(helpers_1.andHandle);
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/azure-importer/index.d.ts

@@ -0,0 +1,55 @@
+import { IOutputModelInterface } from '../interfaces';
+export declare class AzureImporterModel implements IOutputModelInterface {
+    authParams: object | undefined;
+    staticParams: object | undefined;
+    name: string | undefined;
+    authenticate(authParams: object): void;
+    modelIdentifier(): string;
+    /**
+     * Validates given `inputs` params. If it's valid, then captures params, then passes to monitor.
+     * Returns flattened result from Azure monitor client.
+     */
+    execute(inputs: any[]): Promise<any>;
+    /**
+     * Gets CPU metrics by calling monitor client.
+     */
+    private getCPUMetrics;
+    /**
+     * Gets RAW metrics by calling monitor client.
+     */
+    private getRawMetrics;
+    /**
+     * Use DefaultAzureCredential which works with AZURE_TENANT_ID, AZURE_CLIENT_ID, and AZURE_CLIENT_SECRET environment variables.
+     * You can also use other credentials provided by @azure/identity package.
+     */
+    private getVmUsage;
+    /**
+     * Initalize static params.
+     */
+    configure(name: string, staticParams: object | undefined): Promise<IOutputModelInterface>;
+    /**
+     * Takes impl timestamp and duration and returns an Azure formatted `timespan` value.
+     */
+    private getTimeSpan;
+    /**
+     * Formats given `amountOfTime` according to given `unit`.
+     * Throws error if given `unit` is not supported.
+     */
+    private timeUnitConverter;
+    /**
+     * Takes granularity as e.g. "1 m", "1 hr" and translates into ISO8601 as expected by the azure API.
+     */
+    private getInterval;
+    /**
+     * Caculates total memory based on data from ComputeManagementClient response.
+     */
+    private calculateTotalMemory;
+    /**
+     * Gathers instance metadata.
+     */
+    private getInstanceMetadata;
+    /**
+     * Calculates number of seconds covered by each individual input using azure-time-window value
+     */
+    private calculateDurationPerInput;
+}

package/build/lib/azure-importer/index.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureImporterModel = void 0;
+const identity_1 = require("@azure/identity");
+const arm_monitor_1 = require("@azure/arm-monitor");
+const arm_compute_1 = require("@azure/arm-compute");
+const dotenv = require("dotenv");
+const zod_1 = require("zod");
+/**
+ * @todo Move all input validation schemas to separate file.
+ */
+const azureInputSchema = zod_1.z
+    .object({
+    'azure-observation-window': zod_1.z.string(),
+    'azure-observation-aggregation': zod_1.z.string(),
+    'azure-resource-group': zod_1.z.string(),
+    'azure-vm-name': zod_1.z.string(),
+    'azure-subscription-id': zod_1.z.string(),
+    timestamp: zod_1.z.string().datetime(),
+    duration: zod_1.z.number(),
+})
+    .required()
+    .array();
+class AzureImporterModel {
+    constructor() {
+        this.authParams = undefined;
+        /**
+         * Gets CPU metrics by calling monitor client.
+         */
+        this.getCPUMetrics = (monitorClient, params) => {
+            const { subscriptionId, resourceGroupName, timespan, interval, aggregation, vmName, } = params;
+            const metricnames = 'Percentage CPU';
+            return monitorClient.metrics.list(`subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.Compute/virtualMachines/${vmName}`, {
+                metricnames,
+                timespan,
+                interval,
+                aggregation,
+            });
+        };
+        /**
+         * Gets RAW metrics by calling monitor client.
+         */
+        this.getRawMetrics = (monitorClient, params) => {
+            const { subscriptionId, resourceGroupName, timespan, interval, aggregation, vmName, } = params;
+            const metricnames = 'Available Memory Bytes';
+            return monitorClient.metrics.list(`subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.Compute/virtualMachines/${vmName}`, {
+                metricnames,
+                timespan,
+                interval,
+                aggregation,
+            });
+        };
+    }
+    authenticate(authParams) {
+        this.authParams = authParams;
+    }
+    modelIdentifier() {
+        return 'azure';
+    }
+    /**
+     * Validates given `inputs` params. If it's valid, then captures params, then passes to monitor.
+     * Returns flattened result from Azure monitor client.
+     */
+    async execute(inputs) {
+        dotenv.config();
+        azureInputSchema.parse(inputs);
+        const input = inputs[0];
+        const params = {
+            aggregation: input['azure-observation-aggregation'],
+            resourceGroupName: input['azure-resource-group'],
+            vmName: input['azure-vm-name'],
+            subscriptionId: input['azure-subscription-id'],
+            timestamp: input['timestamp'],
+            duration: input['duration'],
+            window: input['azure-observation-window'],
+            timespan: this.getTimeSpan(input['duration'], input['timestamp']),
+            interval: this.getInterval(input['azure-observation-window']),
+        };
+        // Call the function and get data back in AzureOutputs object
+        const rawResults = await this.getVmUsage(params);
+        const rawMetadataResults = await this.getInstanceMetadata(params.subscriptionId, params.vmName, params.resourceGroupName);
+        input['duration'] = this.calculateDurationPerInput(params);
+        const enrichedOutputs = rawResults.timestamps.map((timestamp, index) => ({
+            timestamp,
+            'cloud-vendor': 'azure',
+            'cpu-util': rawResults.cpu_utils[index],
+            'mem-availableGB': parseFloat(rawResults.memAvailable[index]) * 1e-9,
+            'mem-usedGB': parseFloat(rawMetadataResults.totalMemoryGB) -
+                parseFloat(rawResults.memAvailable[index]) * 1e-9,
+            'total-memoryGB': rawMetadataResults.totalMemoryGB,
+            'mem-util': ((parseFloat(rawMetadataResults.totalMemoryGB) -
+                parseFloat(rawResults.memAvailable[index]) * 1e-9) /
+                parseFloat(rawMetadataResults.totalMemoryGB)) *
+                100,
+            location: rawMetadataResults.location,
+            'cloud-instance-type': rawMetadataResults.instanceType,
+        }));
+        for (let i = 0; i < Object.entries(enrichedOutputs).length; i++) {
+            enrichedOutputs[i] = Object.assign(enrichedOutputs[i], input);
+        }
+        return enrichedOutputs;
+    }
+    /**
+     * Use DefaultAzureCredential which works with AZURE_TENANT_ID, AZURE_CLIENT_ID, and AZURE_CLIENT_SECRET environment variables.
+     * You can also use other credentials provided by @azure/identity package.
+     */
+    async getVmUsage(params) {
+        const { subscriptionId, resourceGroupName, vmName, timespan, interval, aggregation, } = params;
+        const getMetricParams = {
+            subscriptionId,
+            resourceGroupName,
+            vmName,
+            timespan,
+            interval,
+            aggregation,
+        };
+        const timestamps = [];
+        const cpu_utils = [];
+        const memAvailable = [];
+        const credential = new identity_1.DefaultAzureCredential();
+        const monitorClient = new arm_monitor_1.MonitorClient(credential, subscriptionId);
+        const cpuMetricsResponse = await this.getCPUMetrics(monitorClient, getMetricParams);
+        // parse CPU util data
+        for (const timeSeries of cpuMetricsResponse.value[0].timeseries || []) {
+            const timeSeriesData = timeSeries.data || [];
+            for (const data of timeSeriesData) {
+                try {
+                    timestamps.push(data.timeStamp.toISOString());
+                    if (!(data.average === undefined)) {
+                        cpu_utils.push(data.average.toString());
+                    }
+                }
+                catch (error) {
+                    console.log('error retrieving CPU data');
+                }
+            }
+        }
+        const ramMetricsResponse = await this.getRawMetrics(monitorClient, getMetricParams);
+        // parse ram util data
+        for (const timeSeries of ramMetricsResponse.value[0].timeseries || []) {
+            for (const data of timeSeries.data || []) {
+                if (!(typeof data.average === 'undefined')) {
+                    memAvailable.push(data.average.toString());
+                }
+            }
+        }
+        return {
+            timestamps,
+            cpu_utils,
+            memAvailable,
+        };
+    }
+    /**
+     * Initalize static params.
+     */
+    async configure(name, staticParams) {
+        this.staticParams = staticParams;
+        this.name = name;
+        return this;
+    }
+    /**
+     * Takes impl timestamp and duration and returns an Azure formatted `timespan` value.
+     */
+    getTimeSpan(duration, timestamp) {
+        const start = new Date(timestamp);
+        const end = new Date(start.getTime() + duration * 1000).toISOString();
+        return `${start.toISOString()}/${end}`;
+    }
+    /**
+     * Formats given `amountOfTime` according to given `unit`.
+     * Throws error if given `unit` is not supported.
+     */
+    timeUnitConverter(amountOfTime, unit) {
+        const seconds = ['seconds', 'second', 'secs', 'sec', 's'];
+        const minutes = ['minutes', 'm', 'min', 'mins'];
+        const hours = ['hour', 'hours', 'h', 'hr', 'hrs'];
+        const days = ['days', 'd'];
+        const weeks = ['week', 'weeks', 'w', 'wk', 'wks'];
+        const months = ['month', 'months', 'mth'];
+        const years = ['year', 'years', 'yr', 'yrs', 'y', 'ys'];
+        if (seconds.includes(unit)) {
+            throw new Error('The minimum unit of time for azure importer is minutes');
+        }
+        if (minutes.includes(unit)) {
+            return `T${amountOfTime}M`;
+        }
+        if (hours.includes(unit)) {
+            return `T${amountOfTime}H`;
+        }
+        if (days.includes(unit)) {
+            return `${amountOfTime}D`;
+        }
+        if (weeks.includes(unit)) {
+            return `${amountOfTime}W`;
+        }
+        if (months.includes(unit)) {
+            return `${amountOfTime}M`;
+        }
+        if (years.includes(unit)) {
+            return `${amountOfTime}Y`;
+        }
+        throw new Error('azure-observation-window parameter is malformed');
+    }
+    /**
+     * Takes granularity as e.g. "1 m", "1 hr" and translates into ISO8601 as expected by the azure API.
+     */
+    getInterval(window) {
+        const splits = window.split(' ', 2);
+        const floatNumber = parseFloat(splits[0]);
+        // if number is a whole number, cast as int to avoid the ".0"
+        const amountOfTime = floatNumber % 1 === 0 ? Math.floor(floatNumber) : floatNumber;
+        const unit = splits[1];
+        const numberInFormat = this.timeUnitConverter(amountOfTime, unit);
+        return `P${numberInFormat}`;
+    }
+    /**
+     * Caculates total memory based on data from ComputeManagementClient response.
+     */
+    async calculateTotalMemory(params) {
+        const { client, instanceType, location } = params;
+        // here we grab the total memory for the instance
+        const memResponseData = [];
+        for await (const item of client.resourceSkus.list()) {
+            memResponseData.push(item);
+        }
+        let totalMemoryGB = '';
+        const filteredMemData = memResponseData
+            .filter(item => item.resourceType === 'virtualMachines')
+            .filter(item => item.name === instanceType)
+            .filter(item => item.locations !== undefined);
+        const vmCapabilitiesData = filteredMemData
+            .filter(item => item.locations !== undefined && item.locations[0] === location)
+            .map(item => item.capabilities)[0];
+        if (vmCapabilitiesData !== undefined) {
+            const totalMemoryObject = vmCapabilitiesData.filter((item) => item.name === 'MemoryGB')[0];
+            if (totalMemoryObject.value !== undefined) {
+                totalMemoryGB = totalMemoryObject.value;
+            }
+        }
+        return totalMemoryGB;
+    }
+    /**
+     * Gathers instance metadata.
+     */
+    async getInstanceMetadata(subscriptionId, vmName, resourceGroupName) {
+        const credential = new identity_1.DefaultAzureCredential();
+        const client = new arm_compute_1.ComputeManagementClient(credential, subscriptionId);
+        const vmData = [];
+        for await (const item of client.virtualMachines.list(resourceGroupName)) {
+            vmData.push(item);
+        }
+        const filteredVmData = vmData.filter(item => item.name === vmName);
+        const location = filteredVmData.map(item => item.location ?? 'unknown')[0];
+        const instanceType = filteredVmData.map(item => item.hardwareProfile?.vmSize ?? 'unknown')[0];
+        const totalMemoryGB = await this.calculateTotalMemory({
+            client,
+            instanceType,
+            location,
+        });
+        return {
+            location,
+            instanceType,
+            totalMemoryGB,
+        };
+    }
+    /**
+     * Calculates number of seconds covered by each individual input using azure-time-window value
+     */
+    calculateDurationPerInput(params) {
+        const window = params.window;
+        const splits = window.split(' ', 2);
+        const floatNumber = parseFloat(splits[0]);
+        const unit = splits[1];
+        let duration = 0;
+        const seconds = ['seconds', 'second', 'secs', 'sec', 's'];
+        const minutes = ['minutes', 'm', 'min', 'mins'];
+        const hours = ['hour', 'hours', 'h', 'hr', 'hrs'];
+        const days = ['days', 'd'];
+        const weeks = ['week', 'weeks', 'w', 'wk', 'wks'];
+        const months = ['month', 'months', 'mth'];
+        const years = ['year', 'years', 'yr', 'yrs', 'y', 'ys'];
+        if (seconds.includes(unit)) {
+            const secs_per_unit = 1;
+            duration = secs_per_unit * floatNumber;
+        }
+        if (minutes.includes(unit)) {
+            const secs_per_unit = 60;
+            duration = secs_per_unit * floatNumber;
+        }
+        if (hours.includes(unit)) {
+            const secs_per_unit = 3600;
+            duration = secs_per_unit * floatNumber;
+        }
+        if (days.includes(unit)) {
+            const secs_per_unit = 86400;
+            duration = secs_per_unit * floatNumber;
+        }
+        if (weeks.includes(unit)) {
+            const secs_per_unit = 604800;
+            duration = secs_per_unit * floatNumber;
+        }
+        if (months.includes(unit)) {
+            const secs_per_unit = 2419200;
+            duration = secs_per_unit * floatNumber;
+        }
+        if (years.includes(unit)) {
+            const secs_per_unit = 29030400;
+            duration = secs_per_unit * floatNumber;
+        }
+        return duration;
+    }
+}
+exports.AzureImporterModel = AzureImporterModel;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/azure-importer/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {DefaultAzureCredential} from '@azure/identity';\nimport {MonitorClient} from '@azure/arm-monitor';\nimport {ComputeManagementClient} from '@azure/arm-compute';\nimport * as dotenv from 'dotenv';\nimport {z} from 'zod';\n\nimport {IOutputModelInterface} from '../interfaces';\nimport {\n  AzureInputs,\n  AzureOutputs,\n  GetMetricsParams,\n  AzureMetadataOutputs,\n} from '../../types/azure-importer';\n\n/**\n * @todo Move all input validation schemas to separate file.\n */\nconst azureInputSchema = z\n  .object({\n    'azure-observation-window': z.string(),\n    'azure-observation-aggregation': z.string(),\n    'azure-resource-group': z.string(),\n    'azure-vm-name': z.string(),\n    'azure-subscription-id': z.string(),\n    timestamp: z.string().datetime(),\n    duration: z.number(),\n  })\n  .required()\n  .array();\n\nexport class AzureImporterModel implements IOutputModelInterface {\n  authParams: object | undefined = undefined;\n  staticParams: object | undefined;\n  name: string | undefined;\n\n  authenticate(authParams: object): void {\n    this.authParams = authParams;\n  }\n\n  modelIdentifier(): string {\n    return 'azure';\n  }\n\n  /**\n   * Validates given `inputs` params. If it's valid, then captures params, then passes to monitor.\n   * Returns flattened result from Azure monitor client.\n   */\n  async execute(inputs: any[]): Promise<any> {\n    dotenv.config();\n\n    azureInputSchema.parse(inputs);\n\n    const input = inputs[0];\n\n    const params: AzureInputs = {\n      aggregation: input['azure-observation-aggregation'],\n      resourceGroupName: input['azure-resource-group'],\n      vmName: input['azure-vm-name'],\n      subscriptionId: input['azure-subscription-id'],\n      timestamp: input['timestamp'],\n      duration: input['duration'],\n      window: input['azure-observation-window'],\n      timespan: this.getTimeSpan(input['duration'], input['timestamp']),\n      interval: this.getInterval(input['azure-observation-window']),\n    };\n\n    // Call the function and get data back in AzureOutputs object\n    const rawResults = await this.getVmUsage(params);\n    const rawMetadataResults = await this.getInstanceMetadata(\n      params.subscriptionId,\n      params.vmName,\n      params.resourceGroupName\n    );\n    input['duration'] = this.calculateDurationPerInput(params);\n\n    const enrichedOutputs = rawResults.timestamps.map((timestamp, index) => ({\n      timestamp,\n      'cloud-vendor': 'azure',\n      'cpu-util': rawResults.cpu_utils[index],\n      'mem-availableGB': parseFloat(rawResults.memAvailable[index]) * 1e-9,\n      'mem-usedGB':\n        parseFloat(rawMetadataResults.totalMemoryGB) -\n        parseFloat(rawResults.memAvailable[index]) * 1e-9,\n      'total-memoryGB': rawMetadataResults.totalMemoryGB,\n      'mem-util':\n        ((parseFloat(rawMetadataResults.totalMemoryGB) -\n          parseFloat(rawResults.memAvailable[index]) * 1e-9) /\n          parseFloat(rawMetadataResults.totalMemoryGB)) *\n        100,\n      location: rawMetadataResults.location,\n      'cloud-instance-type': rawMetadataResults.instanceType,\n    }));\n\n    for (let i = 0; i < Object.entries(enrichedOutputs).length; i++) {\n      enrichedOutputs[i] = Object.assign(enrichedOutputs[i], input);\n    }\n    return enrichedOutputs;\n  }\n\n  /**\n   * Gets CPU metrics by calling monitor client.\n   */\n  private getCPUMetrics = (\n    monitorClient: MonitorClient,\n    params: GetMetricsParams\n  ) => {\n    const {\n      subscriptionId,\n      resourceGroupName,\n      timespan,\n      interval,\n      aggregation,\n      vmName,\n    } = params;\n    const metricnames = 'Percentage CPU';\n    return monitorClient.metrics.list(\n      `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.Compute/virtualMachines/${vmName}`,\n      {\n        metricnames,\n        timespan,\n        interval,\n        aggregation,\n      }\n    );\n  };\n\n  /**\n   * Gets RAW metrics by calling monitor client.\n   */\n  private getRawMetrics = (\n    monitorClient: MonitorClient,\n    params: GetMetricsParams\n  ) => {\n    const {\n      subscriptionId,\n      resourceGroupName,\n      timespan,\n      interval,\n      aggregation,\n      vmName,\n    } = params;\n    const metricnames = 'Available Memory Bytes';\n    return monitorClient.metrics.list(\n      `subscriptions/${subscriptionId}/resourceGroups/${resourceGroupName}/providers/Microsoft.Compute/virtualMachines/${vmName}`,\n      {\n        metricnames,\n        timespan,\n        interval,\n        aggregation,\n      }\n    );\n  };\n\n  /**\n   * Use DefaultAzureCredential which works with AZURE_TENANT_ID, AZURE_CLIENT_ID, and AZURE_CLIENT_SECRET environment variables.\n   * You can also use other credentials provided by @azure/identity package.\n   */\n  private async getVmUsage(params: AzureInputs): Promise<AzureOutputs> {\n    const {\n      subscriptionId,\n      resourceGroupName,\n      vmName,\n      timespan,\n      interval,\n      aggregation,\n    } = params;\n    const getMetricParams = {\n      subscriptionId,\n      resourceGroupName,\n      vmName,\n      timespan,\n      interval,\n      aggregation,\n    };\n\n    const timestamps: string[] = [];\n    const cpu_utils: string[] = [];\n    const memAvailable: string[] = [];\n\n    const credential = new DefaultAzureCredential();\n    const monitorClient = new MonitorClient(credential, subscriptionId);\n    const cpuMetricsResponse = await this.getCPUMetrics(\n      monitorClient,\n      getMetricParams\n    );\n\n    // parse CPU util data\n    for (const timeSeries of cpuMetricsResponse.value[0].timeseries || []) {\n      const timeSeriesData = timeSeries.data || [];\n      for (const data of timeSeriesData) {\n        try {\n          timestamps.push(data.timeStamp.toISOString());\n\n          if (!(data.average === undefined)) {\n            cpu_utils.push(data.average.toString());\n          }\n        } catch (error) {\n          console.log('error retrieving CPU data');\n        }\n      }\n    }\n\n    const ramMetricsResponse = await this.getRawMetrics(\n      monitorClient,\n      getMetricParams\n    );\n\n    // parse ram util data\n    for (const timeSeries of ramMetricsResponse.value[0].timeseries || []) {\n      for (const data of timeSeries.data || []) {\n        if (!(typeof data.average === 'undefined')) {\n          memAvailable.push(data.average.toString());\n        }\n      }\n    }\n\n    return {\n      timestamps,\n      cpu_utils,\n      memAvailable,\n    };\n  }\n\n  /**\n   * Initalize static params.\n   */\n  async configure(\n    name: string,\n    staticParams: object | undefined\n  ): Promise<IOutputModelInterface> {\n    this.staticParams = staticParams;\n    this.name = name;\n\n    return this;\n  }\n\n  /**\n   * Takes impl timestamp and duration and returns an Azure formatted `timespan` value.\n   */\n  private getTimeSpan(duration: number, timestamp: string): string {\n    const start = new Date(timestamp);\n    const end = new Date(start.getTime() + duration * 1000).toISOString();\n\n    return `${start.toISOString()}/${end}`;\n  }\n\n  /**\n   * Formats given `amountOfTime` according to given `unit`.\n   * Throws error if given `unit` is not supported.\n   */\n  private timeUnitConverter(amountOfTime: number, unit: string) {\n    const seconds = ['seconds', 'second', 'secs', 'sec', 's'];\n    const minutes = ['minutes', 'm', 'min', 'mins'];\n    const hours = ['hour', 'hours', 'h', 'hr', 'hrs'];\n    const days = ['days', 'd'];\n    const weeks = ['week', 'weeks', 'w', 'wk', 'wks'];\n    const months = ['month', 'months', 'mth'];\n    const years = ['year', 'years', 'yr', 'yrs', 'y', 'ys'];\n\n    if (seconds.includes(unit)) {\n      throw new Error('The minimum unit of time for azure importer is minutes');\n    }\n\n    if (minutes.includes(unit)) {\n      return `T${amountOfTime}M`;\n    }\n\n    if (hours.includes(unit)) {\n      return `T${amountOfTime}H`;\n    }\n\n    if (days.includes(unit)) {\n      return `${amountOfTime}D`;\n    }\n\n    if (weeks.includes(unit)) {\n      return `${amountOfTime}W`;\n    }\n\n    if (months.includes(unit)) {\n      return `${amountOfTime}M`;\n    }\n\n    if (years.includes(unit)) {\n      return `${amountOfTime}Y`;\n    }\n\n    throw new Error('azure-observation-window parameter is malformed');\n  }\n\n  /**\n   * Takes granularity as e.g. \"1 m\", \"1 hr\" and translates into ISO8601 as expected by the azure API.\n   */\n  private getInterval(window: string): string {\n    const splits = window.split(' ', 2);\n    const floatNumber: number = parseFloat(splits[0]);\n    // if number is a whole number, cast as int to avoid the \".0\"\n    const amountOfTime =\n      floatNumber % 1 === 0 ? Math.floor(floatNumber) : floatNumber;\n    const unit: string = splits[1];\n    const numberInFormat = this.timeUnitConverter(amountOfTime, unit);\n\n    return `P${numberInFormat}`;\n  }\n\n  /**\n   * Caculates total memory based on data from ComputeManagementClient response.\n   */\n  private async calculateTotalMemory(params: any) {\n    const {client, instanceType, location} = params;\n    // here we grab the total memory for the instance\n    const memResponseData = [];\n\n    for await (const item of client.resourceSkus.list()) {\n      memResponseData.push(item);\n    }\n\n    let totalMemoryGB = '';\n    const filteredMemData = memResponseData\n      .filter(item => item.resourceType === 'virtualMachines')\n      .filter(item => item.name === instanceType)\n      .filter(item => item.locations !== undefined);\n\n    const vmCapabilitiesData = filteredMemData\n      .filter(\n        item => item.locations !== undefined && item.locations[0] === location\n      )\n      .map(item => item.capabilities)[0];\n\n    if (vmCapabilitiesData !== undefined) {\n      const totalMemoryObject = vmCapabilitiesData.filter(\n        (item: any) => item.name === 'MemoryGB'\n      )[0];\n      if (totalMemoryObject.value !== undefined) {\n        totalMemoryGB = totalMemoryObject.value;\n      }\n    }\n\n    return totalMemoryGB;\n  }\n\n  /**\n   * Gathers instance metadata.\n   */\n  private async getInstanceMetadata(\n    subscriptionId: string,\n    vmName: string,\n    resourceGroupName: string\n  ): Promise<AzureMetadataOutputs> {\n    const credential = new DefaultAzureCredential();\n    const client = new ComputeManagementClient(credential, subscriptionId);\n\n    const vmData = [];\n    for await (const item of client.virtualMachines.list(resourceGroupName)) {\n      vmData.push(item);\n    }\n\n    const filteredVmData = vmData.filter(item => item.name === vmName);\n    const location = filteredVmData.map(item => item.location ?? 'unknown')[0];\n    const instanceType = filteredVmData.map(\n      item => item.hardwareProfile?.vmSize ?? 'unknown'\n    )[0];\n\n    const totalMemoryGB = await this.calculateTotalMemory({\n      client,\n      instanceType,\n      location,\n    });\n\n    return {\n      location,\n      instanceType,\n      totalMemoryGB,\n    };\n  }\n\n  /**\n   * Calculates number of seconds covered by each individual input using azure-time-window value\n   */\n  private calculateDurationPerInput(params: AzureInputs): number {\n    const window = params.window;\n    const splits = window.split(' ', 2);\n    const floatNumber = parseFloat(splits[0]);\n    const unit = splits[1];\n    let duration = 0;\n\n    const seconds = ['seconds', 'second', 'secs', 'sec', 's'];\n    const minutes = ['minutes', 'm', 'min', 'mins'];\n    const hours = ['hour', 'hours', 'h', 'hr', 'hrs'];\n    const days = ['days', 'd'];\n    const weeks = ['week', 'weeks', 'w', 'wk', 'wks'];\n    const months = ['month', 'months', 'mth'];\n    const years = ['year', 'years', 'yr', 'yrs', 'y', 'ys'];\n\n    if (seconds.includes(unit)) {\n      const secs_per_unit = 1;\n      duration = secs_per_unit * floatNumber;\n    }\n    if (minutes.includes(unit)) {\n      const secs_per_unit = 60;\n      duration = secs_per_unit * floatNumber;\n    }\n    if (hours.includes(unit)) {\n      const secs_per_unit = 3600;\n      duration = secs_per_unit * floatNumber;\n    }\n    if (days.includes(unit)) {\n      const secs_per_unit = 86400;\n      duration = secs_per_unit * floatNumber;\n    }\n    if (weeks.includes(unit)) {\n      const secs_per_unit = 604800;\n      duration = secs_per_unit * floatNumber;\n    }\n    if (months.includes(unit)) {\n      const secs_per_unit = 2419200;\n      duration = secs_per_unit * floatNumber;\n    }\n    if (years.includes(unit)) {\n      const secs_per_unit = 29030400;\n      duration = secs_per_unit * floatNumber;\n    }\n\n    return duration;\n  }\n}\n"]}

package/build/lib/boavizta/index.d.ts

@@ -0,0 +1,53 @@
+import { IOutputModelInterface } from '../interfaces';
+import { BoaviztaInstanceTypes } from '../../types/boavizta';
+import { KeyValuePair } from '../../types/common';
+declare abstract class BoaviztaOutputModel implements IOutputModelInterface {
+    name: string | undefined;
+    sharedParams: object | undefined;
+    metricType: 'cpu-util' | 'gpu-util' | 'ram-util';
+    expectedLifespan: number;
+    protected authCredentials: object | undefined;
+    authenticate(authParams: object): Promise<void>;
+    configure(name: string, staticParams?: object | undefined): Promise<IOutputModelInterface>;
+    abstract modelIdentifier(): string;
+    abstract fetchData(usageData: object | undefined): Promise<object>;
+    supportedLocations(): Promise<string[]>;
+    transformToBoaviztaUsage(duration: number, metric: number): KeyValuePair;
+    execute(inputs?: object | object[] | undefined): Promise<any[]>;
+    addLocationToUsage(usageRaw: KeyValuePair): KeyValuePair;
+    protected abstract captureStaticParams(staticParams: object): object;
+    protected formatResponse(data: KeyValuePair): KeyValuePair;
+    protected calculateUsageForinput(input: KeyValuePair): Promise<KeyValuePair>;
+}
+export declare class BoaviztaCpuOutputModel extends BoaviztaOutputModel implements IOutputModelInterface {
+    sharedParams: object | undefined;
+    name: string | undefined;
+    verbose: boolean;
+    allocation: string;
+    private readonly componentType;
+    constructor();
+    modelIdentifier(): string;
+    fetchData(usageData: object | undefined): Promise<object>;
+    protected captureStaticParams(staticParams: object): Promise<object>;
+}
+export declare class BoaviztaCloudOutputModel extends BoaviztaOutputModel implements IOutputModelInterface {
+    sharedParams: object | undefined;
+    instanceTypes: BoaviztaInstanceTypes;
+    name: string | undefined;
+    verbose: boolean;
+    allocation: string;
+    modelIdentifier(): string;
+    validateLocation(staticParamsCast: object): Promise<string | void>;
+    validateInstanceType(staticParamsCast: object): Promise<void>;
+    validateProvider(staticParamsCast: object): Promise<void>;
+    supportedInstancesList(provider: string): Promise<any>;
+    supportedProvidersList(): Promise<string[]>;
+    fetchData(usageData: object | undefined): Promise<object>;
+    protected captureStaticParams(staticParams: object): Promise<object>;
+}
+/**
+ * For JSII.
+ */
+export { IOutputModelInterface } from '../interfaces';
+export { BoaviztaInstanceTypes, IBoaviztaUsageSCI } from '../../types/boavizta';
+export { KeyValuePair } from '../../types/common';