trm-core 9.10.5 → 10.0.0

package/dist/transport/Transport.js

@@ -47,7 +47,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transport = exports.COMMENT_OBJ = void 0;
 const commons_1 = require("../commons");
-const node_r3trans_1 = require("node-r3trans");
+const R3transLogParser_1 = require("./R3transLogParser");
 const TrmTransportIdentifier_1 = require("./TrmTransportIdentifier");
 const manifest_1 = require("../manifest");
 const promises_1 = require("timers/promises");
@@ -57,6 +57,11 @@ const trm_commons_1 = require("trm-commons");
 const systemConnector_1 = require("../systemConnector");
 const chalk_1 = __importDefault(require("chalk"));
 exports.COMMENT_OBJ = 'ZTRM';
+const RELEASE_LOG_STEPS = [
+    { id: 'ETP182', name: 'CHECK WRITEABILITY OF BUFFERS', namePadding: '' },
+    { id: 'ETP183', name: 'EXPORT PREPARATION', namePadding: '           ' },
+    { id: 'ETP150', name: 'MAIN EXPORT', namePadding: '                  ' }
+];
 class Transport {
     constructor(trkorr, _trTarget) {
         this.trkorr = trkorr;
@@ -87,7 +92,8 @@ class Transport {
                     { fieldName: 'TRFUNCTION' },
                     { fieldName: 'TRSTATUS' },
                     { fieldName: 'AS4DATE' },
-                    { fieldName: 'AS4TIME' }
+                    { fieldName: 'AS4TIME' },
+                    { fieldName: 'TARSYSTEM' }
                 ];
                 var e070;
                 e070 = yield systemConnector_1.SystemConnector.readTable('E070', fields, `TRKORR EQ '${this.trkorr}'`);
@@ -111,6 +117,44 @@ class Transport {
             return this._e071;
         });
     }
+    getE071K() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._e071k) {
+                const fields = [
+                    { fieldName: 'PGMID' },
+                    { fieldName: 'OBJECT' },
+                    { fieldName: 'OBJNAME' },
+                    { fieldName: 'MASTERTYPE' },
+                    { fieldName: 'MASTERNAME' }
+                ];
+                this._e071k = yield systemConnector_1.SystemConnector.readTable('E071K', fields, `TRKORR EQ '${this.trkorr}'`);
+            }
+            return this._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() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = yield systemConnector_1.SystemConnector.readTable('E071K', [
+                { fieldName: 'OBJNAME' },
+                { fieldName: 'MASTERNAME' },
+                { fieldName: 'TABKEY' }
+            ], `TRKORR EQ '${this.trkorr}'`);
+            const objects = yield systemConnector_1.SystemConnector.readTable('E071', [
+                { fieldName: 'OBJECT' },
+                { fieldName: 'OBJ_NAME' },
+                { fieldName: 'OBJFUNC' }
+            ], `TRKORR EQ '${this.trkorr}'`);
+            return [
+                ...keys.map(o => ({ table: (o.objname || o.mastername || '').trim(), tabkey: (o.tabkey || '').trim() })),
+                ...objects.filter(o => (o.object || '').trim().toUpperCase() === 'TABU' && (o.objfunc || '').trim().toUpperCase() !== 'K')
+                    .map(o => ({ table: (o.objName || '').trim() }))
+            ];
+        });
+    }
     getE07T() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._e07t) {
@@ -139,6 +183,14 @@ class Transport {
             }
         });
     }
+    getEntries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._entries) {
+                this._entries = yield systemConnector_1.SystemConnector.getTransportEntries(this.trkorr);
+            }
+            return this._entries;
+        });
+    }
     getTasks() {
         return __awaiter(this, void 0, void 0, function* () {
             var tasks = [];
@@ -155,6 +207,7 @@ class Transport {
                 const aE071 = yield this.getE071();
                 if (!aTdevc) {
                     var aDevclass = aE071.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC').map(o => o.objName);
+                    //check support for bulk operations
                     if (!systemConnector_1.SystemConnector.getSupportedBulk().getTransportObjects) {
                         for (const oE071 of aE071) {
                             if (oE071.pgmid === 'R3TR') {
@@ -171,16 +224,31 @@ class Transport {
                         aDevclass = Array.from(new Set(aDevclass));
                     }
                     aTdevc = [];
+                    /*
+                        #143
+                        Find root package from E071 object list
+                        This is not 100% right because the root package found by E071 object list
+                        might not actually be the root of the package (cases where the root package doesn't have an object
+                        but has a subpackage with objects).
+                        The original logic used was this: find the root based on package hierachy.
+                        This is also not 100% right because after install, users might move the root package to another package
+                        making it a subpackage, invalidating the logic.
+                    */
+                    //for each devclass in aDevclass, add all the parent devclasses (#143 XX stop when parentcl is empty XX)
                     for (var devclass of aDevclass) {
+                        //while (devclass) {
                         var tdevc = aTdevc.find(o => o.devclass === devclass);
                         if (!tdevc) {
                             tdevc = yield systemConnector_1.SystemConnector.getDevclass(devclass);
                             aTdevc.push(tdevc);
                         }
+                        //devclass = tdevc.parentcl;
+                        //}
                     }
                 }
+                //now look for the first root package that is included in the original aDevclass
                 while (aTdevc.length > 0 && !this._rootDevclass) {
-                    const hierarchy = (0, commons_1.getPackageHierarchy)(aTdevc, true);
+                    const hierarchy = (0, commons_1.getPackageHierarchy)(aTdevc, true); //-> added parameter to ignore multiple roots
                     if (aTdevc.find(o => o.devclass === hierarchy.devclass)) {
                         this._rootDevclass = hierarchy.devclass;
                     }
@@ -259,8 +327,9 @@ class Transport {
     }
     setDocumentation(sDocumentation) {
         return __awaiter(this, void 0, void 0, function* () {
-            this._docs = undefined;
+            this._docs = undefined; //clear
             var doc = [];
+            //split at /n to preserve indentation, then split every line that exceedes 67 chars (TDLINE limit)
             const indentationSplit = sDocumentation.split('\n');
             indentationSplit.forEach(s => {
                 if (s.length <= 67) {
@@ -293,6 +362,7 @@ class Transport {
                 var doktl;
                 doktl = yield systemConnector_1.SystemConnector.readTable('DOKTL', fields, `ID EQ 'TA' AND OBJECT EQ '${this.trkorr}'`);
                 this._docs = Transport.doktlToDoc(doktl);
+                //sort by version descending
                 this._docs = this._docs.sort((a, b) => b.version - a.version);
                 trm_commons_1.Logger.success(`Found ${this.trkorr} ${this._docs.length} documentation.`, true);
             }
@@ -335,6 +405,11 @@ class Transport {
             yield systemConnector_1.SystemConnector.addToTransportRequest(this.trkorr, objects, lock);
         });
     }
+    lock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield systemConnector_1.SystemConnector.lockTransportObjs(this.trkorr);
+        });
+    }
     removeComments() {
         return __awaiter(this, void 0, void 0, function* () {
             yield systemConnector_1.SystemConnector.removeComments(this.trkorr, exports.COMMENT_OBJ);
@@ -385,14 +460,17 @@ class Transport {
                     }
                 }
                 try {
-                    oTrmPackage = manifest_1.Manifest.fromAbapXml(docVal).setLinkedTransport(this).getPackage();
+                    oTrmPackage = manifest_1.Manifest.fromAbapXml(docVal).getPackage();
+                    oTrmPackage.setTransport(this);
                 }
                 catch (e) {
+                    //invalid manifest
                 }
                 try {
                     oTrmPackage.setDevclass(yield this.getDevclass());
                 }
                 catch (e) {
+                    //devclass not found
                 }
                 this._linkedTrmPackage = oTrmPackage;
             }
@@ -401,14 +479,25 @@ class Transport {
     }
     delete() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield systemConnector_1.SystemConnector.deleteTrkorr(this.trkorr);
+            try {
+                yield systemConnector_1.SystemConnector.deleteTrkorr(this.trkorr);
+            }
+            finally {
+                //the request may be gone even if the call failed: re-read its status
+                this._e070 = undefined;
+            }
             return null;
         });
     }
     release(lock, skipLog, tmpFolder) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield systemConnector_1.SystemConnector.releaseTrkorr(this.trkorr, lock);
-            yield systemConnector_1.SystemConnector.dequeueTransport(this.trkorr);
+            try {
+                yield systemConnector_1.SystemConnector.releaseTrkorr(this.trkorr, lock);
+            }
+            finally {
+                //the status may have changed even if the call failed: re-read it
+                this._e070 = undefined;
+            }
             if (tmpFolder) {
                 yield this.readReleaseLog(tmpFolder);
             }
@@ -426,130 +515,95 @@ class Transport {
             trm_commons_1.Logger.log(`System R3trans: ${systemR3transVersion}`, true);
             trm_commons_1.Logger.log(`System R3trans unicode: ${systemR3transUnicode}`, true);
             const multibar = trm_commons_1.Logger.multibar('{stage} [{bar}] {exitCode} {result}', Transport.getTransportIcon());
-            var iEtp182 = 0;
-            var iEtp183 = 0;
-            var iEtp150 = 0;
-            const etp182 = multibar.create(100, iEtp182, {
-                stage: '',
-                exitCode: '',
-                result: 'Needs update'
-            });
-            const etp183 = multibar.create(100, iEtp183, {
-                stage: '',
-                exitCode: '',
-                result: 'Needs update'
-            });
-            const etp150 = multibar.create(100, iEtp150, {
-                stage: '',
-                exitCode: '',
-                result: 'Needs update'
-            });
+            const steps = RELEASE_LOG_STEPS.map(step => (Object.assign(Object.assign({}, step), { progress: 0, bar: multibar.create(100, 0, {
+                    stage: '',
+                    exitCode: '',
+                    result: 'Needs update'
+                }) })));
             var exitWhile = false;
             var whileResult = null;
-            while (!exitWhile) {
-                var logResult = [];
-                try {
-                    const logBinary = yield systemConnector_1.SystemConnector.getBinaryFile(filePaths.releaseLog);
-                    fs.writeFileSync(localPath, logBinary);
-                    logResult = yield (new node_r3trans_1.R3transLogParser(localPath, systemR3transUnicode)).getReleaseLog();
-                    fs.unlinkSync(localPath);
-                }
-                catch (e) {
-                    logResult = [];
-                }
-                var etp182LogResult = logResult.find(o => o.id === 'ETP182') || { name: 'CHECK WRITEABILITY OF BUFFERS', exitCode: null };
-                var etp183LogResult = logResult.find(o => o.id === 'ETP183') || { name: 'EXPORT PREPARATION', exitCode: null };
-                var etp150LogResult = logResult.find(o => o.id === 'ETP150') || { name: 'MAIN EXPORT', exitCode: null };
-                etp183LogResult.name += '           ';
-                etp150LogResult.name += '                  ';
-                const etp182ExitCode = node_r3trans_1.R3transLogParser.parseExitCode(etp182LogResult.exitCode);
-                const etp183ExitCode = node_r3trans_1.R3transLogParser.parseExitCode(etp183LogResult.exitCode);
-                const etp150ExitCode = node_r3trans_1.R3transLogParser.parseExitCode(etp150LogResult.exitCode);
-                exitWhile = (etp182LogResult.exitCode !== null) && (etp183LogResult.exitCode !== null) && (etp150LogResult.exitCode !== null);
-                if (etp182ExitCode.type === 'SUCCESS' || etp183ExitCode.type === 'SUCCESS' || etp150ExitCode.type === 'SUCCESS') {
-                    whileResult = 'SUCCESS';
-                }
-                if (etp182ExitCode.type === 'WARNING' || etp183ExitCode.type === 'WARNING' || etp150ExitCode.type === 'WARNING') {
-                    whileResult = 'WARNING';
-                }
-                if (etp182ExitCode.type === 'ERROR' || etp183ExitCode.type === 'ERROR' || etp150ExitCode.type === 'ERROR') {
-                    whileResult = 'ERROR';
-                }
-                const etp182Payload = {
-                    stage: etp182LogResult.name,
-                    exitCode: etp182LogResult.exitCode || '',
-                    result: etp182ExitCode.type !== 'UNKNOWN' ? etp182ExitCode.value : 'In progress'
-                };
-                const etp183Payload = {
-                    stage: etp183LogResult.name,
-                    exitCode: etp183LogResult.exitCode || '',
-                    result: etp183ExitCode.type !== 'UNKNOWN' ? etp183ExitCode.value : 'In progress'
-                };
-                const etp150Payload = {
-                    stage: etp150LogResult.name,
-                    exitCode: etp150LogResult.exitCode || '',
-                    result: etp150ExitCode.type !== 'UNKNOWN' ? etp150ExitCode.value : 'In progress'
-                };
-                if (iEtp182 < 99) {
-                    if (etp182ExitCode.type === 'UNKNOWN') {
-                        iEtp182++;
-                    }
-                    else {
-                        iEtp182 = 100;
+            const deadline = Date.now() + Transport.releaseLogTimeoutMs;
+            try {
+                //the log is downloaded into the temporary folder: a local file system error is not "log not ready yet"
+                fs.mkdirSync(tmpFolder, { recursive: true });
+                while (!exitWhile && Date.now() < deadline) {
+                    var logResult = [];
+                    var logBinary;
+                    try {
+                        logBinary = yield systemConnector_1.SystemConnector.getBinaryFile(filePaths.releaseLog);
                     }
-                }
-                else {
-                    if (etp182ExitCode.type === 'UNKNOWN') {
-                        iEtp182++;
+                    catch (e) {
+                        //log not written yet
+                        logBinary = undefined;
                     }
-                }
-                etp182.update(iEtp182, etp182Payload);
-                if (iEtp183 < 99) {
-                    if (etp183ExitCode.type === 'UNKNOWN') {
-                        iEtp183++;
+                    if (logBinary) {
+                        fs.writeFileSync(localPath, logBinary);
+                        try {
+                            logResult = yield (new R3transLogParser_1.R3transLogParser(localPath)).getReleaseLog();
+                        }
+                        catch (e) {
+                            //log incomplete
+                            logResult = [];
+                        }
+                        finally {
+                            fs.rmSync(localPath, { force: true });
+                        }
                     }
-                    else {
-                        iEtp183 = 100;
+                    const stepResults = steps.map(step => {
+                        const logStep = logResult.find(o => o.id === step.id) || { name: step.name, exitCode: null };
+                        return {
+                            step,
+                            stageName: logStep.name + step.namePadding,
+                            exitCode: logStep.exitCode,
+                            parsedExitCode: R3transLogParser_1.R3transLogParser.parseExitCode(logStep.exitCode)
+                        };
+                    });
+                    exitWhile = stepResults.every(o => o.exitCode !== null);
+                    if (stepResults.some(o => o.parsedExitCode.type === 'SUCCESS')) {
+                        whileResult = 'SUCCESS';
                     }
-                }
-                else {
-                    if (etp183ExitCode.type === 'UNKNOWN') {
-                        iEtp183++;
+                    if (stepResults.some(o => o.parsedExitCode.type === 'WARNING')) {
+                        whileResult = 'WARNING';
                     }
-                }
-                etp183.update(iEtp183, etp183Payload);
-                if (iEtp150 < 99) {
-                    if (etp150ExitCode.type === 'UNKNOWN') {
-                        iEtp150++;
+                    if (stepResults.some(o => o.parsedExitCode.type === 'ERROR')) {
+                        whileResult = 'ERROR';
                     }
-                    else {
-                        iEtp150 = 100;
+                    for (const { step, stageName, exitCode, parsedExitCode } of stepResults) {
+                        if (parsedExitCode.type === 'UNKNOWN') {
+                            step.progress++;
+                        }
+                        else if (step.progress < 99) {
+                            step.progress = 100;
+                        }
+                        step.bar.update(step.progress, {
+                            stage: stageName,
+                            exitCode: exitCode || '',
+                            result: parsedExitCode.type !== 'UNKNOWN' ? parsedExitCode.value : 'In progress'
+                        });
                     }
-                }
-                else {
-                    if (etp150ExitCode.type === 'UNKNOWN') {
-                        iEtp150++;
+                    if (!exitWhile) {
+                        yield (0, promises_1.setTimeout)(1000); //each second
                     }
                 }
-                etp150.update(iEtp150, etp150Payload);
-                yield (0, promises_1.setTimeout)(1000);
             }
-            multibar.stop();
+            finally {
+                multibar.stop();
+            }
             var error;
             var rc;
             if (!exitWhile) {
-                error = new Error(`Timed out waiting for release.`);
+                error = new Error(`Timed out waiting for transport ${this.trkorr} release log "${filePaths.releaseLog}".`);
             }
             else {
                 if (whileResult === "ERROR") {
                     error = new Error(`Error occurred during transport ${this.trkorr} release.`);
                 }
                 if (whileResult === "SUCCESS") {
-                    trm_commons_1.Logger.success(`${Transport.getTransportIcon()} ${this.trkorr}  released with success.`);
+                    trm_commons_1.Logger.success(`${Transport.getTransportIcon()}  ${this.trkorr} released with success.`);
                     rc = 0;
                 }
                 if (whileResult === "WARNING") {
-                    trm_commons_1.Logger.warning(`${Transport.getTransportIcon()} ${this.trkorr}  released with warning.`);
+                    trm_commons_1.Logger.warning(`${Transport.getTransportIcon()}  ${this.trkorr} released with warning.`, { important: true });
                     rc = 4;
                 }
             }
@@ -563,14 +617,13 @@ class Transport {
     }
     _isInTmsQueue(skipLog_1) {
         return __awaiter(this, arguments, void 0, function* (skipLog, checkImpSing = false) {
-            trm_commons_1.Logger.log(`TMS check for transport ${this.trkorr}`, true);
             var inQueue = false;
             var rc = 12;
             var message;
             var lastCheck;
             if (this._trTarget) {
                 var inQueueAttempts = 0;
-                trm_commons_1.Logger.loading(`Checking transport status...`, skipLog);
+                trm_commons_1.Logger.loading(`Checking ${this.trkorr} status...`, skipLog);
                 while (!inQueue) {
                     inQueueAttempts++;
                     trm_commons_1.Logger.log(`Attempt ${inQueueAttempts}, reading in 3 seconds...`, true);
@@ -596,16 +649,22 @@ class Transport {
                             trm_commons_1.Logger.error(e.toString(), true);
                         }
                     }
+                    //reading the queue is outdated now and getTransportImportStatus should be used
+                    //HOWEVER it doesn't work for VIRTUAL TARGETS!
+                    //for now, keep it like this
                     var tmsQueue = yield systemConnector_1.SystemConnector.readTmsQueue(this._trTarget);
                     tmsQueue = tmsQueue.filter(o => o.trkorr === this.trkorr);
                     tmsQueue = tmsQueue.sort((a, b) => parseInt(b.bufpos) - parseInt(a.bufpos));
                     if (!checkImpSing) {
+                        //without check if in import, simply check if in queue
                         inQueue = tmsQueue.length > 0;
                     }
                     else {
+                        //if importing, get the last transport in queue (if re installing, there are more than 1)
                         if (tmsQueue.length > 0) {
                             inQueue = tmsQueue[0].impsing !== 'X';
                             if (!tmsQueue[0].maxrc) {
+                                //no rc => transport wasn't imported! set as -1 (field is blank, do not confuse with 0 which is success)
                                 rc = -1;
                             }
                             else {
@@ -618,10 +677,13 @@ class Transport {
                     }
                 }
                 if (!checkImpSing) {
+                    //without check of import, we're releasing the transport (publish?)
+                    //set rc to -1 as it is irrelevant
                     trm_commons_1.Logger.success(`${Transport.getTransportIcon()}  ${this.trkorr} released.`, skipLog);
                     rc = -1;
                 }
                 else {
+                    //read final import message
                     try {
                         message = (yield systemConnector_1.SystemConnector.getTransportImportStatus(this.trkorr, this._trTarget)).message;
                     }
@@ -740,6 +802,43 @@ class Transport {
             return new Transport(trkorr, data.trTarget);
         });
     }
+    /**
+     * 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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePaths = yield Transport._getFilePaths(Transport._getFileNames(trkorr, systemConnector_1.SystemConnector.getDest()));
+            const read = (filePath) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const file = yield systemConnector_1.SystemConnector.getBinaryFile(filePath);
+                    return file && file.length > 0 ? file : undefined;
+                }
+                catch (e) {
+                    //RFC: exception key, REST: HTTP reason (wrapped in exceptionType or raw error message)
+                    if ((e === null || e === void 0 ? void 0 : e.exceptionType) === 'NOT_FOUND' || (e === null || e === void 0 ? void 0 : e.message) === 'NOT_FOUND') {
+                        trm_commons_1.Logger.log(`File "${filePath}" not found.`, true);
+                        return undefined;
+                    }
+                    throw e;
+                }
+            });
+            return {
+                header: yield read(filePaths.header),
+                data: yield read(filePaths.data)
+            };
+        });
+    }
+    /**
+     * Writes one of the transport's files (header/cofile or data) to the transport directory.
+     */
+    static writeBinaryFile(trkorr, kind, binary) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePaths = yield Transport._getFilePaths(Transport._getFileNames(trkorr, systemConnector_1.SystemConnector.getDest()));
+            yield systemConnector_1.SystemConnector.writeBinaryFile(filePaths[kind], binary);
+        });
+    }
     static getTransportsFromObject(objectKeys, transportsCache) {
         return __awaiter(this, void 0, void 0, function* () {
             var transports = [];
@@ -780,41 +879,102 @@ class Transport {
             return latest;
         });
     }
-    import() {
+    static importMultiple(transports_1, target_1) {
+        return __awaiter(this, arguments, void 0, function* (transports, target, forward = true) {
+            if (forward) {
+                for (const transport of transports) {
+                    trm_commons_1.Logger.loading(`Forwarding transport ${transport.trkorr}`, true);
+                    yield systemConnector_1.SystemConnector.forwardTransport(transport.trkorr, target, target, true);
+                }
+            }
+            trm_commons_1.Logger.loading(`Importing ${transports.map(o => o.trkorr).join(', ')} in batch`, true);
+            yield systemConnector_1.SystemConnector.importTransportMultiple(transports.map(o => o.trkorr), target, false);
+            const results = [];
+            const originalLPrefix = trm_commons_1.Logger.getPrefix();
+            try {
+                var index = 0;
+                for (const transport of transports) {
+                    index++;
+                    const prefix = `(${Transport.getTransportIcon()}  ${index}/${transports.length}) `;
+                    if (originalLPrefix) {
+                        trm_commons_1.Logger.setPrefix(`${originalLPrefix}-> ${prefix}`);
+                    }
+                    else {
+                        trm_commons_1.Logger.setPrefix(prefix);
+                    }
+                    trm_commons_1.Logger.log(`Starting transport ${transport.trkorr} TMS queue status check`, true);
+                    transport._trTarget = target;
+                    const queue = yield transport._isInTmsQueue(false, true);
+                    Transport._printImportResult(transport.trkorr, queue.rc, queue.message, false);
+                    results.push({ trkorr: transport.trkorr, rc: queue.rc, message: queue.message });
+                }
+                return results;
+            }
+            finally {
+                trm_commons_1.Logger.setPrefix(originalLPrefix);
+            }
+        });
+    }
+    import(test) {
         return __awaiter(this, void 0, void 0, function* () {
+            var rc;
+            var message;
             if (!this._trTarget) {
                 throw new Error('Missing transport target.');
             }
-            trm_commons_1.Logger.log(`Starting ${this.trkorr} import`, true);
+            trm_commons_1.Logger.log(`Starting ${this.trkorr} import ${test ? 'test' : ''}`, true);
             trm_commons_1.Logger.loading(`Forwarding transport ${this.trkorr}`, true);
             yield systemConnector_1.SystemConnector.forwardTransport(this.trkorr, this._trTarget, this._trTarget, true);
-            trm_commons_1.Logger.loading(`Importing ${this.trkorr}`, true);
-            yield systemConnector_1.SystemConnector.importTransport(this.trkorr, this._trTarget);
-            trm_commons_1.Logger.log(`Starting transport ${this.trkorr} TMS queue status check`, true);
-            const queue = yield this._isInTmsQueue(false, true);
-            trm_commons_1.Logger.log(`Transport ${this.trkorr} import ended: return code ${queue.rc}`, true);
-            switch (queue.rc) {
-                case -1:
-                    trm_commons_1.Logger.error(`${this.trkorr} import has no return code!`);
-                    break;
-                case 0:
-                    trm_commons_1.Logger.success(`${this.trkorr} import ended with success${queue.message ? ' -> ' + queue.message : '.'}`);
-                    break;
-                case 4:
-                    trm_commons_1.Logger.warning(`${this.trkorr} import ended with warning${queue.message ? ' -> ' + queue.message : '.'}`);
-                    break;
-                case 8:
-                    trm_commons_1.Logger.error(`${this.trkorr} import ended with error (check ${chalk_1.default.bold('STMS')})${queue.message ? ' -> ' + queue.message : '.'}`);
-                    break;
-                case 12:
-                    trm_commons_1.Logger.error(`${this.trkorr} import was cancelled${queue.message ? ' -> ' + queue.message : '.'}`);
-                    break;
-                case 16:
-                    trm_commons_1.Logger.error(`${this.trkorr} import was cancelled${queue.message ? ' -> ' + queue.message : '.'}`);
-                    break;
+            trm_commons_1.Logger.loading(`Importing ${this.trkorr}${test ? ' (TEST IMPORT)' : ''}`, true);
+            const result = yield systemConnector_1.SystemConnector.importTransport(this.trkorr, this._trTarget, test);
+            if (result) {
+                rc = Number(result.tpRetCode);
+                if (Array(result.tpStdout)) {
+                    result.tpStdout.forEach(line => trm_commons_1.Logger.log(line.line, true));
+                }
+                // tp can hand the import over to the background ("Going offline") and return at once: the objects are
+                // only imported (or deleted) afterwards. Wait for the import recorded in the queue and take its return code.
+                if (!test && rc < 8) {
+                    trm_commons_1.Logger.log(`Waiting for transport ${this.trkorr} import to complete`, true);
+                    const queue = yield this._isInTmsQueue(true, true);
+                    if (queue.rc >= 0) {
+                        rc = queue.rc;
+                        message = queue.message;
+                    }
+                }
+            }
+            else {
+                trm_commons_1.Logger.log(`Starting transport ${this.trkorr} TMS queue status check`, true);
+                const queue = yield this._isInTmsQueue(false, true);
+                rc = queue.rc;
+                message = queue.message;
             }
+            Transport._printImportResult(this.trkorr, rc, message, test);
+            return rc;
         });
     }
+    static _printImportResult(trkorr, rc, message, test) {
+        switch (rc) {
+            case -1:
+                trm_commons_1.Logger.error(`${trkorr} import has no return code!`, { debug: test, important: true });
+                break;
+            case 0:
+                trm_commons_1.Logger.success(`${trkorr} import ended with success${message ? ' -> ' + message : '.'}`, test);
+                break;
+            case 4:
+                trm_commons_1.Logger.warning(`${trkorr} import ended with warning${message ? ' -> ' + message : '.'}`, { debug: test, important: true });
+                break;
+            case 8:
+                trm_commons_1.Logger.error(`${trkorr} import ended with error (check ${chalk_1.default.bold('STMS')})${message ? ' -> ' + message : '.'}`, { debug: test, important: true });
+                break;
+            case 12:
+                trm_commons_1.Logger.error(`${trkorr} import was cancelled${message ? ' -> ' + message : '.'}`, { debug: test, important: true });
+                break;
+            case 16:
+                trm_commons_1.Logger.error(`${trkorr} import was cancelled${message ? ' -> ' + message : '.'}`, { debug: test, important: true });
+                break;
+        }
+    }
     rename(as4text) {
         return __awaiter(this, void 0, void 0, function* () {
             yield systemConnector_1.SystemConnector.renameTransportRequest(this.trkorr, as4text);
@@ -822,13 +982,15 @@ class Transport {
     }
     canBeDeleted() {
         return __awaiter(this, void 0, void 0, function* () {
-            const status = (yield this.getE070()).trstatus;
+            var _a;
+            const status = (_a = (yield this.getE070())) === null || _a === void 0 ? void 0 : _a.trstatus;
             return status === 'D';
         });
     }
     isReleased() {
         return __awaiter(this, void 0, void 0, function* () {
-            const status = (yield this.getE070()).trstatus;
+            var _a;
+            const status = (_a = (yield this.getE070())) === null || _a === void 0 ? void 0 : _a.trstatus;
             return status === 'R' || status === 'N';
         });
     }
@@ -857,3 +1019,7 @@ class Transport {
     }
 }
 exports.Transport = Transport;
+/**
+ * Maximum time to wait for a release log to report every export step.
+ */
+Transport.releaseLogTimeoutMs = 30 * 60 * 1000;

package/dist/transport/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./Transport";
+export * from "./E071KOwner";
 export * from "./BinaryTransport";
 export * from "./FileNames";
 export * from "./FilePaths";
 export * from "./Documentation";
 export * from "./TrmTransportIdentifier";
+export * from "./R3transLogParser";