trm-core 9.10.5 → 10.0.0

package/dist/transport/R3transLogParser.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.R3transLogParser = void 0;
+const fs = __importStar(require("fs"));
+const readline = __importStar(require("readline"));
+// Note: no "g" flag, these are only ever tested/executed once per line (a shared "g" regex
+// would carry lastIndex state across lines and silently start missing matches).
+const STEP_BLOCK_START_REGEX = /^\d\s*ETP199X/i;
+const STEP_BLOCK_END_REGEX = /^\d\s*ETP199/i;
+const STEP_HEADER_REGEX = /^\d\s*(ETP\d{3})\s*(.*)/i;
+const STEP_LOG_LINE_REGEX = /^\d\s*\w{3}\d{3}\s(.*)/i;
+const STEP_END_DATETIME_REGEX = /^\d\sETP110\s*.*:\s*"(\d*)"/i;
+const STEP_EXIT_CODE_REGEX = /^\d\sETP111\s*.*:\s*"(\d*)"/i;
+class R3transLogParser {
+    constructor(_log) {
+        this._log = _log;
+    }
+    _getStream() {
+        return fs.createReadStream(this._log);
+    }
+    _parseStepHeader(line) {
+        const match = STEP_HEADER_REGEX.exec(line);
+        if (!match) {
+            return null;
+        }
+        return {
+            id: match[1],
+            name: match[2],
+            endDateTime: null,
+            exitCode: null,
+            log: null
+        };
+    }
+    _appendStepDetails(step, line) {
+        const logMatch = STEP_LOG_LINE_REGEX.exec(line);
+        if (logMatch) {
+            step.log = step.log ? `${step.log}\n${logMatch[1]}` : logMatch[1];
+        }
+        const endDateTimeMatch = STEP_END_DATETIME_REGEX.exec(line);
+        if (endDateTimeMatch) {
+            step.endDateTime = parseInt(endDateTimeMatch[1]);
+        }
+        const exitCodeMatch = STEP_EXIT_CODE_REGEX.exec(line);
+        if (exitCodeMatch) {
+            step.exitCode = parseInt(exitCodeMatch[1]);
+        }
+    }
+    getReleaseLog() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield new Promise((res) => {
+                const steps = [];
+                var atStepBoundary = false;
+                var currentStep;
+                const rl = readline.createInterface({
+                    input: this._getStream(),
+                    crlfDelay: Infinity
+                });
+                rl.on('line', (line) => {
+                    if (atStepBoundary) {
+                        currentStep = this._parseStepHeader(line) || currentStep;
+                    }
+                    if (STEP_BLOCK_START_REGEX.test(line)) {
+                        atStepBoundary = true;
+                    }
+                    else {
+                        atStepBoundary = false;
+                        if (STEP_BLOCK_END_REGEX.test(line)) {
+                            if (currentStep) {
+                                steps.push(currentStep);
+                            }
+                        }
+                        else if (currentStep) {
+                            this._appendStepDetails(currentStep, line);
+                        }
+                    }
+                });
+                rl.on('close', () => {
+                    res(steps);
+                });
+            });
+        });
+    }
+    static parseExitCode(exitCode) {
+        if (exitCode === undefined || exitCode === null) {
+            return {
+                type: 'UNKNOWN',
+                value: 'Unknown exit code.'
+            };
+        }
+        switch (exitCode) {
+            case 0:
+                return { type: 'SUCCESS', value: 'No errors or problems have occurred.' };
+            case 4:
+                return { type: 'WARNING', value: 'Warnings have occurred but they can be ignored.' };
+            case 8:
+                return { type: 'ERROR', value: 'Transport could not be completed. Problems occurred with certain objects.' };
+            case 12:
+                return { type: 'ERROR', value: 'Fatal errors have occurred, such as errors while reading or writing a file or unexpected errors within the database interface, in particular database problems.' };
+            case 16:
+                return { type: 'ERROR', value: 'Situations have occurred that are normally not allowed.' };
+            default:
+                return { type: 'ERROR', value: 'Return code not set by R3trans itself but point to errors, such as segmentation faults.' };
+        }
+    }
+}
+exports.R3transLogParser = R3transLogParser;

package/dist/transport/Transport.d.ts

@@ -4,20 +4,26 @@ import { FilePaths } from "./FilePaths";
 import { Documentation } from "./Documentation";
 import { TrmTransportIdentifier } from "./TrmTransportIdentifier";
 import { TrmPackage } from "../trmPackage";
-import { TROBJTYPE, E070, E071, E07T, TRKORR, TR_TARGET, DEVCLASS, TROBJ_NAME, AS4TEXT, PGMID, SOBJ_NAME, TMSSYSNAM, TDEVC, TR_AS4USER } from "../client";
+import { TROBJTYPE, E070, E071, E071K, E07T, TRKORR, TR_TARGET, DEVCLASS, TROBJ_NAME, AS4TEXT, PGMID, SOBJ_NAME, TMSSYSNAM, TDEVC, TR_AS4USER, TransportEntries } from "../client";
 export declare const COMMENT_OBJ: TROBJTYPE;
 export declare class Transport {
     trkorr: TRKORR;
     private _trTarget?;
+    /**
+     * Maximum time to wait for a release log to report every export step.
+     */
+    static releaseLogTimeoutMs: number;
     private _fileNames;
     private _e070;
     private _e071;
+    private _e071k;
     private _e07t;
     private _docs;
     private _trmPackageName;
     private _trmPackageVersion;
     private _linkedTrmPackage;
     private _rootDevclass;
+    private _entries;
     trmIdentifier?: TrmTransportIdentifier;
     constructor(trkorr: TRKORR, _trTarget?: TR_TARGET);
     setTrmIdentifier(identifier?: TrmTransportIdentifier): Transport;
@@ -25,8 +31,18 @@ export declare class Transport {
     isIgnored(): Promise<boolean>;
     getE070(): Promise<E070>;
     getE071(): Promise<E071[]>;
+    getE071K(): Promise<E071K[]>;
+    /**
+     * Table content carried by the transport: one entry per E071K key, and one entry without key
+     * (the whole table content) per TABU object that has no key list.
+     */
+    getCustomizingKeys(): Promise<{
+        table: string;
+        tabkey?: string;
+    }[]>;
     getE07T(): Promise<E07T[]>;
     getDescription(): Promise<AS4TEXT>;
+    getEntries(): Promise<TransportEntries>;
     getTasks(): Promise<Transport[]>;
     getDevclass(aTdevc?: TDEVC[]): Promise<DEVCLASS>;
     getDate(): Promise<Date>;
@@ -46,6 +62,7 @@ export declare class Transport {
         doktext: string;
     }[]): Documentation[];
     addObjects(objects: E071[], lock: boolean): Promise<void>;
+    lock(): Promise<void>;
     removeComments(): Promise<void>;
     addComment(comment: TROBJ_NAME): Promise<void>;
     addTranslations(aDevclass: DEVCLASS[]): Promise<void>;
@@ -74,17 +91,33 @@ export declare class Transport {
         text: AS4TEXT;
         target?: TR_TARGET;
     }): Promise<Transport>;
-    static upload(trkorr: any, data: {
+    static upload(trkorr: TRKORR, data: {
         binary: BinaryTransport;
         trTarget?: TR_TARGET;
     }): Promise<Transport>;
+    /**
+     * Reads the transport's header (cofile) and data files from the transport directory, if present.
+     *
+     * A missing (`NOT_FOUND`) or empty file is returned as `undefined`; any other read error is rethrown.
+     */
+    static readBinaryFiles(trkorr: TRKORR): Promise<Partial<BinaryTransport>>;
+    /**
+     * Writes one of the transport's files (header/cofile or data) to the transport directory.
+     */
+    static writeBinaryFile(trkorr: TRKORR, kind: keyof BinaryTransport, binary: Buffer): Promise<void>;
     static getTransportsFromObject(objectKeys: {
         pgmid: PGMID;
         object: TROBJTYPE;
         objName: SOBJ_NAME;
     }, transportsCache?: Transport[]): Promise<Transport[]>;
     static getLatest(transports: Transport[]): Promise<Transport>;
-    import(): Promise<void>;
+    static importMultiple(transports: Transport[], target: TR_TARGET, forward?: boolean): Promise<{
+        trkorr: TRKORR;
+        rc: number;
+        message?: string;
+    }[]>;
+    import(test: boolean): Promise<number>;
+    private static _printImportResult;
     rename(as4text: string): Promise<void>;
     canBeDeleted(): Promise<boolean>;
     isReleased(): Promise<boolean>;