tm1npm 1.0.0

package/src/services/JobService.ts

@@ -0,0 +1,59 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { formatUrl, requireVersion } from '../utils/Utils';
+
+export class JobService extends ObjectService {
+    /** Service to handle TM1 Job objects introduced in v12
+     */
+
+    constructor(rest: RestService) {
+        super(rest);
+    }
+
+    @requireVersion("12.0.0")
+    public async getAll(): Promise<any[]> {
+        /** Return a dict of the currently running jobs from the TM1 Server
+         *
+         *    :return:
+         *        dict: the response
+         */
+        const url = '/Jobs';
+        const response = await this.rest.get(url);
+        return response.data.value;
+    }
+
+    @requireVersion("12.0.0")
+    public async cancel(jobId: string | number): Promise<AxiosResponse> {
+        /** Cancels a running Job
+         *
+         * :param job_id:
+         * :return:
+         */
+        const url = formatUrl("/Jobs('{}')/tm1.Cancel", jobId.toString());
+        const response = await this.rest.post(url);
+        return response;
+    }
+
+    @requireVersion("12.0.0")
+    public async cancelAll(): Promise<any[]> {
+        const jobs = await this.getAll();
+        const canceledJobs: any[] = [];
+        
+        for (const job of jobs) {
+            await this.cancel(job["ID"]);
+            canceledJobs.push(job);
+        }
+        
+        return canceledJobs;
+    }
+
+    @requireVersion("12.0.0")
+    public async getAsDataFrame(): Promise<any[]> {
+        /** Gets jobs and returns them as an array (equivalent to dataframe)
+         * Note: In JavaScript/TypeScript, we return array of objects instead of pandas DataFrame
+         */
+        const jobs = await this.getAll();
+        return jobs;
+    }
+}

package/src/services/LoggerService.ts

@@ -0,0 +1,118 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { formatUrl, CaseAndSpaceInsensitiveDict, requireOpsAdmin } from '../utils/Utils';
+
+export class LoggerService extends ObjectService {
+    /** Service to query and update loggers
+     */
+
+    constructor(rest: RestService) {
+        super(rest);
+    }
+
+    
+    public async getAll(): Promise<any[]> {
+        const url = "/Loggers";
+        const response = await this.rest.get(url);
+        return response.data.value;
+    }
+
+    
+    public async getAllNames(): Promise<string[]> {
+        const loggers = await this.getAll();
+        return loggers.map((logger: any) => logger.Name);
+    }
+
+    
+    public async get(logger: string): Promise<any> {
+        /** Get level for specified logger
+         *
+         * :param logger: string name of logger
+         * :return: Dict of logger and level
+         */
+        const url = formatUrl("/Loggers('{}')", logger);
+        const response = await this.rest.get(url);
+        const loggerData = response.data;
+        delete loggerData["@odata.context"];
+        return loggerData;
+    }
+
+    
+    public async search(wildcard: string = '', level: string = ''): Promise<any[]> {
+        /** Searches logger names by wildcard or by level. Combining wildcard and level will filter via AND and not OR
+         *
+         * :param wildcard: string to match in logger name
+         * :param level: string e.g. FATAL, ERROR, WARNING, INFO, DEBUG, UNKOWN, OFF
+         * :return: Dict of matching loggers and levels
+         */
+        let url = "/Loggers";
+
+        const loggerFilters: string[] = [];
+
+        if (level) {
+            const levelDict = new CaseAndSpaceInsensitiveDict([
+                ['FATAL', 0], ['ERROR', 1], ['WARNING', 2], ['INFO', 3], ['DEBUG', 4], ['UNKNOWN', 5], ['OFF', 6]
+            ]);
+            const levelIndex = levelDict.get(level);
+            if (levelIndex !== undefined) {
+                loggerFilters.push(`Level eq ${levelIndex}`);
+            }
+        }
+
+        if (wildcard) {
+            loggerFilters.push(`contains(tolower(Name), tolower('${wildcard}'))`);
+        }
+
+        if (loggerFilters.length > 0) {
+            url += `?$filter=${loggerFilters.join(" and ")}`;
+        }
+
+        const response = await this.rest.get(url);
+        return response.data.value;
+    }
+
+    
+    public async exists(logger: string): Promise<boolean> {
+        /** Test if logger exists
+         * :param logger: string name of logger
+         * :return: bool
+         */
+        const url = formatUrl("/Loggers('{}')", logger);
+        return await this._exists(url);
+    }
+
+    
+    public async setLevel(logger: string, level: string): Promise<AxiosResponse> {
+        /** Set logger level
+         * :param logger: string name of logger
+         * :param level: string e.g. FATAL, ERROR, WARNING, INFO, DEBUG, UNKOWN, OFF
+         * :return: response
+         */
+        const url = formatUrl("/Loggers('{}')", logger);
+
+        if (!(await this.exists(logger))) {
+            throw new Error(`${logger} is not a valid logger`);
+        }
+
+        const levelDict = new CaseAndSpaceInsensitiveDict([
+            ['FATAL', 0], ['ERROR', 1], ['WARNING', 2], ['INFO', 3], ['DEBUG', 4], ['UNKNOWN', 5], ['OFF', 6]
+        ]);
+        const levelIndex = levelDict.get(level);
+        if (levelIndex !== undefined) {
+            const loggerData = { 'Level': levelIndex };
+            return await this.rest.patch(url, JSON.stringify(loggerData));
+        } else {
+            throw new Error(`${level} is not a valid level`);
+        }
+    }
+
+    private async _exists(url: string): Promise<boolean> {
+        try {
+            await this.rest.get(url);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/services/ManageService.ts

@@ -0,0 +1,322 @@
+import axios, { AxiosResponse } from 'axios';
+
+export interface DatabaseResourceConfig {
+    cpuRequests?: string;
+    cpuLimits?: string;
+    memoryRequests?: string;
+    memoryLimits?: string;
+    storageSize?: string;
+}
+
+export class ManageService {
+    /** Manage service to interact with the manage endpoint.
+     * The manage endpoint uses basic auth using the root client and secret
+     */
+
+    private _domain: string;
+    private _rootClient: string;
+    private _rootSecret: string;
+    private _rootUrl: string;
+    private _authConfig: any;
+
+    constructor(domain: string, rootClient: string, rootSecret: string) {
+        this._domain = domain;
+        this._rootClient = rootClient;
+        this._rootSecret = rootSecret;
+        this._rootUrl = `${this._domain}/manage/v1`;
+        this._authConfig = {
+            auth: {
+                username: this._rootClient,
+                password: this._rootSecret
+            }
+        };
+    }
+
+    public async getInstances(): Promise<any[]> {
+        const url = `${this._rootUrl}/Instances`;
+        const response = await axios.get(url, this._authConfig);
+        return response.data.value;
+    }
+
+    public async getInstance(instanceName: string): Promise<any> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')`;
+        const response = await axios.get(url, this._authConfig);
+        return response.data;
+    }
+
+    public async createInstance(instanceName: string): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances`;
+        const payload = { "Name": instanceName };
+        const response = await axios.post(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async deleteInstance(instanceName: string): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')`;
+        const response = await axios.delete(url, this._authConfig);
+        return response;
+    }
+
+    public async instanceExists(instanceName: string): Promise<boolean> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')`;
+        try {
+            const response = await axios.get(url, this._authConfig);
+            return response.status === 200;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    public async getDatabases(instanceName: string): Promise<any[]> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases`;
+        const response = await axios.get(url, this._authConfig);
+        return response.data.value;
+    }
+
+    public async getDatabase(instanceName: string, databaseName: string): Promise<any> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')`;
+        const response = await axios.get(url, this._authConfig);
+        return response.data;
+    }
+
+    public async createDatabase(
+        instanceName: string,
+        databaseName: string,
+        numberReplicas: number,
+        productVersion: string,
+        resourceConfig: DatabaseResourceConfig = {}
+    ): Promise<AxiosResponse> {
+        const {
+            cpuRequests = "1000m",
+            cpuLimits = "2000m",
+            memoryRequests = "1G",
+            memoryLimits = "2G",
+            storageSize = "20Gi"
+        } = resourceConfig;
+
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases`;
+
+        const payload = {
+            "Name": databaseName,
+            "Replicas": numberReplicas,
+            "ProductVersion": productVersion,
+            "Resources": {
+                "Replica": {
+                    "CPU": {
+                        "Requests": cpuRequests,
+                        "Limits": cpuLimits
+                    },
+                    "Memory": {
+                        "Requests": memoryRequests,
+                        "Limits": memoryLimits
+                    }
+                },
+                "Storage": {
+                    "Size": storageSize
+                }
+            }
+        };
+
+        const response = await axios.post(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async updateDatabaseCpu(
+        instanceName: string,
+        databaseName: string,
+        cpuRequests: string,
+        cpuLimits: string
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')`;
+
+        const payload = {
+            "Resources": {
+                "Replica": {
+                    "CPU": {
+                        "Requests": cpuRequests,
+                        "Limits": cpuLimits
+                    }
+                }
+            }
+        };
+
+        const response = await axios.patch(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async updateDatabaseMemory(
+        instanceName: string,
+        databaseName: string,
+        memoryRequests: string,
+        memoryLimits: string
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')`;
+
+        const payload = {
+            "Resources": {
+                "Replica": {
+                    "Memory": {
+                        "Requests": memoryRequests,
+                        "Limits": memoryLimits
+                    }
+                }
+            }
+        };
+
+        const response = await axios.patch(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async updateDatabaseStorage(
+        instanceName: string,
+        databaseName: string,
+        storageSize: string
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')`;
+
+        const payload = {
+            "Resources": {
+                "Storage": {
+                    "Size": storageSize
+                }
+            }
+        };
+
+        const response = await axios.patch(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async deleteDatabase(instanceName: string, databaseName: string): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')`;
+        const response = await axios.delete(url, this._authConfig);
+        return response;
+    }
+
+    public async databaseExists(instanceName: string, databaseName: string): Promise<boolean> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')`;
+        try {
+            const response = await axios.get(url, this._authConfig);
+            return response.status === 200;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    public async upgradeDatabase(
+        instanceName: string,
+        databaseName: string,
+        targetVersion: string = ""
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')/tm1s.Upgrade`;
+        const payload = { "ProductVersion": targetVersion };
+        const response = await axios.post(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async createDatabaseBackup(
+        instanceName: string,
+        databaseName: string,
+        backupSetName: string
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')/tm1s.Backup`;
+        const payload = { "URL": `${backupSetName}.tgz` };
+        const response = await axios.post(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async createAndUploadDatabaseBackupSetFile(
+        instanceName: string,
+        databaseName: string,
+        backupSetName: string
+    ): Promise<AxiosResponse> {
+        const createUrl = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')/Contents('Files')/Contents('.backupsets')/Contents`;
+        const payload = {
+            "@odata.type": "#ibm.tm1.api.v1.Document",
+            "Name": `${backupSetName}.tgz`
+        };
+        await axios.post(createUrl, payload, this._authConfig);
+
+        const uploadUrl = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')/Contents('Files')/Contents('.backupsets')/Contents('${backupSetName}.tgz')/Content`;
+        const response = await axios.post(uploadUrl, payload, this._authConfig);
+        return response;
+    }
+
+    public async restoreDatabase(
+        instanceName: string,
+        databaseName: string,
+        backupUrl: string
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')/tm1s.Restore`;
+        const payload = { "URL": backupUrl };
+        const response = await axios.post(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async scaleDatabase(
+        instanceName: string,
+        databaseName: string,
+        replicas: number
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')`;
+        const payload = { "Replicas": replicas };
+        const response = await axios.patch(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async getApplications(instanceName: string): Promise<any> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Applications`;
+        const response = await axios.get(url, this._authConfig);
+        return response.data;
+    }
+
+    public async getApplication(instanceName: string, applicationName: string): Promise<any> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Applications('${applicationName}')`;
+        const response = await axios.get(url, this._authConfig);
+        return response.data;
+    }
+
+    public async createApplication(
+        instanceName: string,
+        applicationName: string
+    ): Promise<{ clientId: string; clientSecret: string }> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Applications`;
+        const payload = { "Name": applicationName };
+        const response = await axios.post(url, payload, this._authConfig);
+        const responseJson = response.data;
+        return {
+            clientId: responseJson['ClientID'],
+            clientSecret: responseJson['ClientSecret']
+        };
+    }
+
+    public async getMetadata(): Promise<any> {
+        const url = `${this._rootUrl}/$metadata?$format=json`;
+        const response = await axios.get(url, this._authConfig);
+        return response.data;
+    }
+
+    public async subscribeToDataChanges(
+        instanceName: string,
+        databaseName: string,
+        targetUrl: string,
+        additionalProperties: Record<string, any> = {}
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')/tm1.Subscribe`;
+        const payload = {
+            "URL": targetUrl,
+            "AdditionalProperties": additionalProperties
+        };
+        const response = await axios.post(url, payload, this._authConfig);
+        return response;
+    }
+
+    public async unsubscribeFromDataChanges(
+        instanceName: string,
+        databaseName: string,
+        targetUrl: string
+    ): Promise<AxiosResponse> {
+        const url = `${this._rootUrl}/Instances('${instanceName}')/Databases('${databaseName}')/tm1.Unsubscribe`;
+        const response = await axios.post(url, this._authConfig);
+        return response;
+    }
+}