@terascope/scripts 0.83.3 → 1.0.0

package/dist/src/helpers/test-runner/services.js

@@ -1,53 +1,24 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureRabbitMQ = exports.ensureOpensearch = exports.ensureRestrainedOpensearch = exports.ensureRestrainedElasticsearch = exports.ensureElasticsearch = exports.ensureMinio = exports.ensureZookeeper = exports.ensureKafka = exports.ensureServices = exports.loadOrPullServiceImages = void 0;
-const ms_1 = __importDefault(require("ms"));
-const got_1 = __importDefault(require("got"));
-const semver_1 = __importDefault(require("semver"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const ts = __importStar(require("@terascope/utils"));
-const kafkajs_1 = require("kafkajs");
-const execa_1 = __importDefault(require("execa"));
-const misc_1 = require("../misc");
-const scripts_1 = require("../scripts");
-const kind_1 = require("../kind");
-const interfaces_1 = require("../interfaces");
-const config = __importStar(require("../config"));
-const signale_1 = __importDefault(require("../signale"));
-const logger = ts.debugLogger('ts-scripts:cmd:test');
-const serviceUpTimeout = (0, ms_1.default)(config.SERVICE_UP_TIMEOUT);
-const rabbitConfigPath = path_1.default.join((0, misc_1.getRootDir)(), '/.ts-test-config/rabbitmq.conf');
-const restrainedElasticsearchConfigPath = path_1.default.join((0, misc_1.getRootDir)(), '/.ts-test-config/elasticsearch.yml');
+import ms from 'ms';
+import got from 'got';
+import semver from 'semver';
+import fs from 'fs-extra';
+import path from 'node:path';
+import { Kafka } from 'kafkajs';
+import execa from 'execa';
+import { pWhile, TSError, debugLogger, toHumanTime, getErrorStatusCode } from '@terascope/utils';
+import { getServicesForSuite, getRootDir } from '../misc.js';
+import { dockerRun, getContainerInfo, dockerStop, k8sStartService, k8sStopService, loadThenDeleteImageFromCache, dockerPull } from '../scripts.js';
+import { Kind } from '../kind.js';
+import { Service } from '../interfaces.js';
+import * as config from '../config.js';
+import signale from '../signale.js';
+const logger = debugLogger('ts-scripts:cmd:test');
+const serviceUpTimeout = ms(config.SERVICE_UP_TIMEOUT);
+const rabbitConfigPath = path.join(getRootDir(), '/.ts-test-config/rabbitmq.conf');
+const restrainedElasticsearchConfigPath = path.join(getRootDir(), '/.ts-test-config/elasticsearch.yml');
 const disableXPackSecurity = !config.ELASTICSEARCH_DOCKER_IMAGE.includes('blacktop');
 const services = {
-    [interfaces_1.Service.Elasticsearch]: {
+    [Service.Elasticsearch]: {
         image: config.ELASTICSEARCH_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_${config.ELASTICSEARCH_NAME}`,
         tmpfs: config.SERVICES_USE_TMPFS
@@ -65,7 +36,7 @@ const services = {
         },
         network: config.DOCKER_NETWORK_NAME
     },
-    [interfaces_1.Service.RestrainedElasticsearch]: {
+    [Service.RestrainedElasticsearch]: {
         image: config.ELASTICSEARCH_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_${config.ELASTICSEARCH_NAME}`,
         mount: [`type=bind,source=${restrainedElasticsearchConfigPath},target=/usr/share/elasticsearch/config/elasticsearch.yml`],
@@ -81,7 +52,7 @@ const services = {
         },
         network: config.DOCKER_NETWORK_NAME
     },
-    [interfaces_1.Service.RestrainedOpensearch]: {
+    [Service.RestrainedOpensearch]: {
         image: config.OPENSEARCH_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_${config.OPENSEARCH_NAME}`,
         ports: [`${config.RESTRAINED_OPENSEARCH_PORT}:${config.RESTRAINED_OPENSEARCH_PORT}`],
@@ -95,7 +66,7 @@ const services = {
         },
         network: config.DOCKER_NETWORK_NAME
     },
-    [interfaces_1.Service.Opensearch]: {
+    [Service.Opensearch]: {
         image: config.OPENSEARCH_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_${config.OPENSEARCH_NAME}`,
         ports: [`${config.OPENSEARCH_PORT}:${config.OPENSEARCH_PORT}`],
@@ -110,7 +81,7 @@ const services = {
         },
         network: config.DOCKER_NETWORK_NAME
     },
-    [interfaces_1.Service.Kafka]: {
+    [Service.Kafka]: {
         image: config.KAFKA_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_${config.KAFKA_NAME}`,
         tmpfs: config.SERVICES_USE_TMPFS
@@ -129,7 +100,7 @@ const services = {
         },
         network: config.DOCKER_NETWORK_NAME
     },
-    [interfaces_1.Service.Zookeeper]: {
+    [Service.Zookeeper]: {
         image: config.ZOOKEEPER_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_zookeeper`,
         tmpfs: config.SERVICES_USE_TMPFS
@@ -142,7 +113,7 @@ const services = {
         },
         network: config.DOCKER_NETWORK_NAME
     },
-    [interfaces_1.Service.Minio]: {
+    [Service.Minio]: {
         image: config.MINIO_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_${config.MINIO_NAME}`,
         /// We will be able to go back and use this on a later version of minio
@@ -152,7 +123,7 @@ const services = {
         //     : undefined,
         ports: [`${config.MINIO_PORT}:${config.MINIO_PORT}`],
         mount: config.ENCRYPT_MINIO
-            ? [`type=bind,source=${path_1.default.join((0, misc_1.getRootDir)(), '/e2e/test/certs')},target=/opt/certs`,
+            ? [`type=bind,source=${path.join(getRootDir(), '/e2e/test/certs')},target=/opt/certs`,
                 `type=bind,source=${config.MINIO_VOLUME},target=/data`
             ]
             : [`type=bind,source=${config.MINIO_VOLUME},target=/data`],
@@ -165,7 +136,7 @@ const services = {
             ? ['server', '-S', '/opt/certs', '--address', `0.0.0.0:${config.MINIO_PORT}`, '/data']
             : ['server', '--address', `0.0.0.0:${config.MINIO_PORT}`, '/data']
     },
-    [interfaces_1.Service.RabbitMQ]: {
+    [Service.RabbitMQ]: {
         image: config.RABBITMQ_DOCKER_IMAGE,
         name: `${config.TEST_NAMESPACE}_${config.RABBITMQ_NAME}`,
         ports: [`${config.RABBITMQ_MANAGEMENT_PORT}:15672`, `${config.RABBITMQ_PORT}:5672`],
@@ -178,46 +149,46 @@ const services = {
         network: config.DOCKER_NETWORK_NAME,
     }
 };
-async function loadOrPullServiceImages(suite) {
-    const launchServices = (0, misc_1.getServicesForSuite)(suite);
+export async function loadOrPullServiceImages(suite) {
+    const launchServices = getServicesForSuite(suite);
     try {
         const images = [];
         const loadFailedList = [];
-        if (launchServices.includes(interfaces_1.Service.Elasticsearch)) {
+        if (launchServices.includes(Service.Elasticsearch)) {
             const image = `${config.ELASTICSEARCH_DOCKER_IMAGE}:${config.ELASTICSEARCH_VERSION}`;
             images.push(image);
         }
-        if (launchServices.includes(interfaces_1.Service.Opensearch)) {
+        if (launchServices.includes(Service.Opensearch)) {
             const image = `${config.OPENSEARCH_DOCKER_IMAGE}:${config.OPENSEARCH_VERSION}`;
             images.push(image);
         }
-        if (launchServices.includes(interfaces_1.Service.RestrainedOpensearch)) {
+        if (launchServices.includes(Service.RestrainedOpensearch)) {
             const image = `${config.OPENSEARCH_DOCKER_IMAGE}:${config.OPENSEARCH_VERSION}`;
             images.push(image);
         }
-        if (launchServices.includes(interfaces_1.Service.RestrainedElasticsearch)) {
+        if (launchServices.includes(Service.RestrainedElasticsearch)) {
             const image = `${config.ELASTICSEARCH_DOCKER_IMAGE}:${config.ELASTICSEARCH_VERSION}`;
             images.push(image);
         }
-        if (launchServices.includes(interfaces_1.Service.Kafka)) {
+        if (launchServices.includes(Service.Kafka)) {
             const image = `${config.KAFKA_DOCKER_IMAGE}:${config.KAFKA_IMAGE_VERSION}`;
             images.push(image);
         }
-        if (launchServices.includes(interfaces_1.Service.Zookeeper)) {
+        if (launchServices.includes(Service.Zookeeper)) {
             const image = `${config.ZOOKEEPER_DOCKER_IMAGE}:${config.ZOOKEEPER_VERSION}`;
             images.push(image);
         }
-        if (launchServices.includes(interfaces_1.Service.Minio)) {
+        if (launchServices.includes(Service.Minio)) {
             const image = `${config.MINIO_DOCKER_IMAGE}:${config.MINIO_VERSION}`;
             images.push(image);
         }
-        if (launchServices.includes(interfaces_1.Service.RabbitMQ)) {
+        if (launchServices.includes(Service.RabbitMQ)) {
             const image = `${config.RABBITMQ_DOCKER_IMAGE}`;
             images.push(image);
         }
-        if (fs_extra_1.default.existsSync(config.DOCKER_CACHE_PATH)) {
+        if (fs.existsSync(config.DOCKER_CACHE_PATH)) {
             await Promise.all(images.map(async (imageName) => {
-                const success = await (0, scripts_1.loadThenDeleteImageFromCache)(imageName);
+                const success = await loadThenDeleteImageFromCache(imageName);
                 if (!success) {
                     loadFailedList.push(imageName);
                 }
@@ -229,55 +200,54 @@ async function loadOrPullServiceImages(suite) {
         if (loadFailedList.length > 0) {
             await Promise.all(loadFailedList.map(async (image) => {
                 const label = `docker pull ${image}`;
-                signale_1.default.time(label);
-                await (0, scripts_1.dockerPull)(image);
-                signale_1.default.timeEnd(label);
+                signale.time(label);
+                await dockerPull(image);
+                signale.timeEnd(label);
             }));
         }
     }
     catch (err) {
-        throw new ts.TSError(err, {
+        throw new TSError(err, {
             message: `Failed to pull services for test suite "${suite}", ${err.message}`
         });
     }
 }
-exports.loadOrPullServiceImages = loadOrPullServiceImages;
-async function ensureServices(suite, options) {
-    const launchServices = (0, misc_1.getServicesForSuite)(suite);
+export async function ensureServices(suite, options) {
+    const launchServices = getServicesForSuite(suite);
     const promises = [];
-    if (launchServices.includes(interfaces_1.Service.Elasticsearch)) {
+    if (launchServices.includes(Service.Elasticsearch)) {
         promises.push(ensureElasticsearch(options));
     }
-    if (launchServices.includes(interfaces_1.Service.RestrainedElasticsearch)) {
+    if (launchServices.includes(Service.RestrainedElasticsearch)) {
         // we create the elasticsearch.yml file for tests
         if (!options.ignoreMount) {
-            await fs_extra_1.default.outputFile(restrainedElasticsearchConfigPath, 'network.host: 0.0.0.0\nthread_pool.write.queue_size: 2');
+            await fs.outputFile(restrainedElasticsearchConfigPath, 'network.host: 0.0.0.0\nthread_pool.write.queue_size: 2');
         }
         promises.push(ensureRestrainedElasticsearch(options));
     }
-    if (launchServices.includes(interfaces_1.Service.RestrainedOpensearch)) {
+    if (launchServices.includes(Service.RestrainedOpensearch)) {
         // we create the elasticsearch.yml file for tests
         if (!options.ignoreMount) {
-            await fs_extra_1.default.outputFile(restrainedElasticsearchConfigPath, 'network.host: 0.0.0.0\nthread_pool.write.queue_size: 2');
+            await fs.outputFile(restrainedElasticsearchConfigPath, 'network.host: 0.0.0.0\nthread_pool.write.queue_size: 2');
         }
         promises.push(ensureRestrainedOpensearch(options));
     }
-    if (launchServices.includes(interfaces_1.Service.Opensearch)) {
+    if (launchServices.includes(Service.Opensearch)) {
         promises.push(ensureOpensearch(options));
     }
-    if (launchServices.includes(interfaces_1.Service.Kafka)) {
+    if (launchServices.includes(Service.Kafka)) {
         promises.push(ensureKafka(options));
     }
-    if (launchServices.includes(interfaces_1.Service.Zookeeper)) {
+    if (launchServices.includes(Service.Zookeeper)) {
         promises.push(ensureZookeeper(options));
     }
-    if (launchServices.includes(interfaces_1.Service.Minio)) {
+    if (launchServices.includes(Service.Minio)) {
         promises.push(ensureMinio(options));
     }
-    if (launchServices.includes(interfaces_1.Service.RabbitMQ)) {
+    if (launchServices.includes(Service.RabbitMQ)) {
         // we create the rabbitmq.conf file for tests
         if (!options.ignoreMount) {
-            await fs_extra_1.default.outputFile(rabbitConfigPath, 'loopback_users = none\nloopback_users.guest = false');
+            await fs.outputFile(rabbitConfigPath, 'loopback_users = none\nloopback_users.guest = false');
         }
         promises.push(ensureRabbitMQ(options));
     }
@@ -286,92 +256,83 @@ async function ensureServices(suite, options) {
         fns.forEach((fn) => fn());
     };
 }
-exports.ensureServices = ensureServices;
-async function ensureKafka(options) {
+export async function ensureKafka(options) {
     let fn = () => { };
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.Kafka);
+    fn = await startService(options, Service.Kafka);
     await checkKafka(options, startTime);
     return fn;
 }
-exports.ensureKafka = ensureKafka;
-async function ensureZookeeper(options) {
+export async function ensureZookeeper(options) {
     let fn = () => { };
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.Zookeeper);
+    fn = await startService(options, Service.Zookeeper);
     await checkZookeeper(options, startTime);
     return fn;
 }
-exports.ensureZookeeper = ensureZookeeper;
-async function ensureMinio(options) {
+export async function ensureMinio(options) {
     let fn = () => { };
     // Create fresh certs before loading minio if encryption enabled
     if (options.encryptMinio) {
         try {
-            signale_1.default.pending('Generating new ca-certificates for minio...');
-            const scriptLocation = path_1.default.join((0, misc_1.getRootDir)(), '/scripts/generate-cert.sh');
-            await (0, execa_1.default)(scriptLocation, ['localhost', 'minio', config.MINIO_HOSTNAME]);
+            signale.pending('Generating new ca-certificates for minio...');
+            const scriptLocation = path.join(getRootDir(), '/scripts/generate-cert.sh');
+            await execa(scriptLocation, ['localhost', 'minio', config.MINIO_HOSTNAME]);
         }
         catch (err) {
-            throw new ts.TSError(`Error generating ca-certificates for minio: ${err.message}`);
+            throw new TSError(`Error generating ca-certificates for minio: ${err.message}`);
         }
-        signale_1.default.success('Successfully created new certificates for minio');
+        signale.success('Successfully created new certificates for minio');
     }
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.Minio);
+    fn = await startService(options, Service.Minio);
     await checkMinio(options, startTime);
     return fn;
 }
-exports.ensureMinio = ensureMinio;
-async function ensureElasticsearch(options) {
+export async function ensureElasticsearch(options) {
     let fn = () => { };
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.Elasticsearch);
+    fn = await startService(options, Service.Elasticsearch);
     await checkElasticsearch(options, startTime);
     return fn;
 }
-exports.ensureElasticsearch = ensureElasticsearch;
-async function ensureRestrainedElasticsearch(options) {
+export async function ensureRestrainedElasticsearch(options) {
     let fn = () => { };
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.RestrainedElasticsearch);
+    fn = await startService(options, Service.RestrainedElasticsearch);
     await checkRestrainedElasticsearch(options, startTime);
     return fn;
 }
-exports.ensureRestrainedElasticsearch = ensureRestrainedElasticsearch;
-async function ensureRestrainedOpensearch(options) {
+export async function ensureRestrainedOpensearch(options) {
     let fn = () => { };
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.RestrainedOpensearch);
+    fn = await startService(options, Service.RestrainedOpensearch);
     await checkRestrainedOpensearch(options, startTime);
     return fn;
 }
-exports.ensureRestrainedOpensearch = ensureRestrainedOpensearch;
-async function ensureOpensearch(options) {
+export async function ensureOpensearch(options) {
     let fn = () => { };
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.Opensearch);
+    fn = await startService(options, Service.Opensearch);
     await checkOpensearch(options, startTime);
     return fn;
 }
-exports.ensureOpensearch = ensureOpensearch;
-async function ensureRabbitMQ(options) {
+export async function ensureRabbitMQ(options) {
     let fn = () => { };
     const startTime = Date.now();
-    fn = await startService(options, interfaces_1.Service.RabbitMQ);
+    fn = await startService(options, Service.RabbitMQ);
     await checkRabbitMQ(options, startTime);
     return fn;
 }
-exports.ensureRabbitMQ = ensureRabbitMQ;
 async function stopService(service) {
     const { name } = services[service];
-    const info = await (0, scripts_1.getContainerInfo)(name);
+    const info = await getContainerInfo(name);
     if (!info)
         return;
     const startTime = Date.now();
-    signale_1.default.pending(`stopping service ${service}`);
-    await (0, scripts_1.dockerStop)(name);
-    signale_1.default.success(`stopped service ${service}, took ${ts.toHumanTime(Date.now() - startTime)}`);
+    signale.pending(`stopping service ${service}`);
+    await dockerStop(name);
+    signale.success(`stopped service ${service}, took ${toHumanTime(Date.now() - startTime)}`);
 }
 async function checkRestrainedOpensearch(options, startTime) {
     const host = config.RESTRAINED_OPENSEARCH_HOST;
@@ -381,17 +342,16 @@ async function checkRestrainedOpensearch(options, startTime) {
     if (dockerGateways.includes(config.OPENSEARCH_HOSTNAME))
         return;
     let error = '';
-    await ts.pWhile(async () => {
-        var _a;
+    await pWhile(async () => {
         if (options.trace) {
-            signale_1.default.debug(`checking restrained opensearch at ${host}`);
+            signale.debug(`checking restrained opensearch at ${host}`);
         }
         else {
             logger.debug(`checking restrained opensearch at ${host}`);
         }
         let body;
         try {
-            ({ body } = await (0, got_1.default)(host, {
+            ({ body } = await got(host, {
                 username,
                 password,
                 https: { rejectUnauthorized: false },
@@ -405,22 +365,22 @@ async function checkRestrainedOpensearch(options, startTime) {
             return false;
         }
         if (options.trace) {
-            signale_1.default.debug('got response from restrained opensearch service', body);
+            signale.debug('got response from restrained opensearch service', body);
         }
         else {
             logger.debug('got response from restrained opensearch service', body);
         }
-        if (!((_a = body === null || body === void 0 ? void 0 : body.version) === null || _a === void 0 ? void 0 : _a.number)) {
+        if (!body?.version?.number) {
             return false;
         }
         const actual = body.version.number;
         const expected = config.OPENSEARCH_VERSION;
-        if (semver_1.default.satisfies(actual, `^${expected}`)) {
-            const took = ts.toHumanTime(Date.now() - startTime);
-            signale_1.default.success(`restrained opensearch@${actual} is running at ${host}, took ${took}`);
+        if (semver.satisfies(actual, `^${expected}`)) {
+            const took = toHumanTime(Date.now() - startTime);
+            signale.success(`restrained opensearch@${actual} is running at ${host}, took ${took}`);
             return true;
         }
-        throw new ts.TSError(`restrained opensearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
+        throw new TSError(`restrained opensearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
             retryable: false,
         });
     }, {
@@ -438,17 +398,16 @@ async function checkOpensearch(options, startTime) {
     if (dockerGateways.includes(config.OPENSEARCH_HOSTNAME))
         return;
     let error = '';
-    await ts.pWhile(async () => {
-        var _a;
+    await pWhile(async () => {
         if (options.trace) {
-            signale_1.default.debug(`checking opensearch at ${host}`);
+            signale.debug(`checking opensearch at ${host}`);
         }
         else {
             logger.debug(`checking opensearch at ${host}`);
         }
         let body;
         try {
-            ({ body } = await (0, got_1.default)(host, {
+            ({ body } = await got(host, {
                 username,
                 password,
                 https: { rejectUnauthorized: false },
@@ -462,22 +421,22 @@ async function checkOpensearch(options, startTime) {
             return false;
         }
         if (options.trace) {
-            signale_1.default.debug('got response from opensearch service', body);
+            signale.debug('got response from opensearch service', body);
         }
         else {
             logger.debug('got response from opensearch service', body);
         }
-        if (!((_a = body === null || body === void 0 ? void 0 : body.version) === null || _a === void 0 ? void 0 : _a.number)) {
+        if (!body?.version?.number) {
             return false;
         }
         const actual = body.version.number;
         const expected = config.OPENSEARCH_VERSION;
-        if (semver_1.default.satisfies(actual, `^${expected}`)) {
-            const took = ts.toHumanTime(Date.now() - startTime);
-            signale_1.default.success(`opensearch@${actual} is running at ${host}, took ${took}`);
+        if (semver.satisfies(actual, `^${expected}`)) {
+            const took = toHumanTime(Date.now() - startTime);
+            signale.success(`opensearch@${actual} is running at ${host}, took ${took}`);
             return true;
         }
-        throw new ts.TSError(`Opensearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
+        throw new TSError(`Opensearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
             retryable: false,
         });
     }, {
@@ -493,17 +452,16 @@ async function checkRestrainedElasticsearch(options, startTime) {
     if (dockerGateways.includes(config.ELASTICSEARCH_HOSTNAME))
         return;
     let error = '';
-    await ts.pWhile(async () => {
-        var _a;
+    await pWhile(async () => {
         if (options.trace) {
-            signale_1.default.debug(`checking restrained elasticsearch at ${host}`);
+            signale.debug(`checking restrained elasticsearch at ${host}`);
         }
         else {
             logger.debug(`checking restrained elasticsearch at ${host}`);
         }
         let body;
         try {
-            ({ body } = await (0, got_1.default)(host, {
+            ({ body } = await got(host, {
                 responseType: 'json',
                 throwHttpErrors: true,
                 retry: 0,
@@ -514,22 +472,22 @@ async function checkRestrainedElasticsearch(options, startTime) {
             return false;
         }
         if (options.trace) {
-            signale_1.default.debug('got response from restrained elasticsearch service', body);
+            signale.debug('got response from restrained elasticsearch service', body);
         }
         else {
             logger.debug('got response from restrained elasticsearch service', body);
         }
-        if (!((_a = body === null || body === void 0 ? void 0 : body.version) === null || _a === void 0 ? void 0 : _a.number)) {
+        if (!body?.version?.number) {
             return false;
         }
         const actual = body.version.number;
         const expected = config.ELASTICSEARCH_VERSION;
-        if (semver_1.default.satisfies(actual, `^${expected}`)) {
-            const took = ts.toHumanTime(Date.now() - startTime);
-            signale_1.default.success(`elasticsearch@${actual} is running at ${host}, took ${took}`);
+        if (semver.satisfies(actual, `^${expected}`)) {
+            const took = toHumanTime(Date.now() - startTime);
+            signale.success(`elasticsearch@${actual} is running at ${host}, took ${took}`);
             return true;
         }
-        throw new ts.TSError(`Restrained Elasticsearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
+        throw new TSError(`Restrained Elasticsearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
             retryable: false,
         });
     }, {
@@ -545,17 +503,16 @@ async function checkElasticsearch(options, startTime) {
     if (dockerGateways.includes(config.ELASTICSEARCH_HOSTNAME))
         return;
     let error = '';
-    await ts.pWhile(async () => {
-        var _a;
+    await pWhile(async () => {
         if (options.trace) {
-            signale_1.default.debug(`checking elasticsearch at ${host}`);
+            signale.debug(`checking elasticsearch at ${host}`);
         }
         else {
             logger.debug(`checking elasticsearch at ${host}`);
         }
         let body;
         try {
-            ({ body } = await (0, got_1.default)(host, {
+            ({ body } = await got(host, {
                 responseType: 'json',
                 throwHttpErrors: true,
                 retry: 0,
@@ -566,22 +523,22 @@ async function checkElasticsearch(options, startTime) {
             return false;
         }
         if (options.trace) {
-            signale_1.default.debug('got response from elasticsearch service', body);
+            signale.debug('got response from elasticsearch service', body);
         }
         else {
             logger.debug('got response from elasticsearch service', body);
         }
-        if (!((_a = body === null || body === void 0 ? void 0 : body.version) === null || _a === void 0 ? void 0 : _a.number)) {
+        if (!body?.version?.number) {
             return false;
         }
         const actual = body.version.number;
         const expected = config.ELASTICSEARCH_VERSION;
-        if (semver_1.default.satisfies(actual, `^${expected}`)) {
-            const took = ts.toHumanTime(Date.now() - startTime);
-            signale_1.default.success(`elasticsearch@${actual} is running at ${host}, took ${took}`);
+        if (semver.satisfies(actual, `^${expected}`)) {
+            const took = toHumanTime(Date.now() - startTime);
+            signale.success(`elasticsearch@${actual} is running at ${host}, took ${took}`);
             return true;
         }
-        throw new ts.TSError(`Elasticsearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
+        throw new TSError(`Elasticsearch at ${host} does not satisfy required version of ${expected}, got ${actual}`, {
             retryable: false,
         });
     }, {
@@ -597,39 +554,39 @@ async function checkMinio(options, startTime) {
     if (dockerGateways.includes(config.MINIO_HOSTNAME))
         return;
     let error = '';
-    await ts.pWhile(async () => {
+    await pWhile(async () => {
         if (options.trace) {
-            signale_1.default.debug(`checking MinIO at ${host}`);
+            signale.debug(`checking MinIO at ${host}`);
         }
         else {
             logger.debug(`checking MinIO at ${host}`);
         }
         let statusCode;
-        const rootCaPath = path_1.default.join((0, misc_1.getRootDir)(), 'e2e/test/certs/CAs/rootCA.pem');
+        const rootCaPath = path.join(getRootDir(), 'e2e/test/certs/CAs/rootCA.pem');
         try {
-            ({ statusCode } = await (0, got_1.default)('minio/health/live', {
+            ({ statusCode } = await got('minio/health/live', {
                 prefixUrl: host,
                 responseType: 'json',
                 throwHttpErrors: false,
                 https: config.ENCRYPT_MINIO
-                    ? { certificateAuthority: fs_extra_1.default.readFileSync(rootCaPath) }
+                    ? { certificateAuthority: fs.readFileSync(rootCaPath) }
                     : {},
                 retry: 0,
             }));
         }
         catch (err) {
             error = err.message;
-            statusCode = ts.getErrorStatusCode(err);
+            statusCode = getErrorStatusCode(err);
         }
         if (options.trace) {
-            signale_1.default.debug('got response from MinIO service', { statusCode });
+            signale.debug('got response from MinIO service', { statusCode });
         }
         else {
             logger.debug('got response from MinIO service', { statusCode });
         }
         if (statusCode === 200) {
-            const took = ts.toHumanTime(Date.now() - startTime);
-            signale_1.default.success(`MinIO is running at ${host}, took ${took}`);
+            const took = toHumanTime(Date.now() - startTime);
+            signale.success(`MinIO is running at ${host}, took ${took}`);
             return true;
         }
         return false;
@@ -646,16 +603,16 @@ async function checkRabbitMQ(options, startTime) {
     if (dockerGateways.includes(config.RABBITMQ_HOSTNAME))
         return;
     let error = '';
-    await ts.pWhile(async () => {
+    await pWhile(async () => {
         if (options.trace) {
-            signale_1.default.debug(`checking RabbitMQ at ${managementEndpoint}`);
+            signale.debug(`checking RabbitMQ at ${managementEndpoint}`);
         }
         else {
             logger.debug(`checking RabbitMQ at ${managementEndpoint}`);
         }
         let statusCode;
         try {
-            ({ statusCode } = await (0, got_1.default)('api/overview', {
+            ({ statusCode } = await got('api/overview', {
                 prefixUrl: managementEndpoint,
                 responseType: 'json',
                 throwHttpErrors: false,
@@ -666,17 +623,17 @@ async function checkRabbitMQ(options, startTime) {
         }
         catch (err) {
             error = err.message;
-            statusCode = ts.getErrorStatusCode(err);
+            statusCode = getErrorStatusCode(err);
         }
         if (options.trace) {
-            signale_1.default.debug('got response from RabbitMQ service', { statusCode });
+            signale.debug('got response from RabbitMQ service', { statusCode });
         }
         else {
             logger.debug('got response from RabbitMQ service', { statusCode });
         }
         if (statusCode === 200) {
-            const took = ts.toHumanTime(Date.now() - startTime);
-            signale_1.default.success(`RabbitMQ is running at ${managementEndpoint}, took ${took}`);
+            const took = toHumanTime(Date.now() - startTime);
+            signale.success(`RabbitMQ is running at ${managementEndpoint}, took ${took}`);
             return true;
         }
         return false;
@@ -697,12 +654,12 @@ async function checkKafka(options, startTime) {
     if (dockerGateways.includes(config.KAFKA_HOSTNAME))
         return;
     if (options.trace) {
-        signale_1.default.debug(`checking kafka at ${host}`);
+        signale.debug(`checking kafka at ${host}`);
     }
     else {
         logger.debug(`checking kafka at ${host}`);
     }
-    const kafka = new kafkajs_1.Kafka({
+    const kafka = new Kafka({
         clientId: 'tera-test',
         brokers: [kafkaBroker],
         logLevel: 0,
@@ -714,7 +671,7 @@ async function checkKafka(options, startTime) {
         }
     });
     const producer = kafka.producer();
-    const took = ts.toHumanTime(Date.now() - startTime);
+    const took = toHumanTime(Date.now() - startTime);
     try {
         await producer.connect();
     }
@@ -727,48 +684,48 @@ async function checkKafka(options, startTime) {
         }
         throw new Error(err.message);
     }
-    signale_1.default.success(`kafka@${config.KAFKA_VERSION} is running at ${config.KAFKA_BROKER}, took ${took}`);
+    signale.success(`kafka@${config.KAFKA_VERSION} is running at ${config.KAFKA_BROKER}, took ${took}`);
 }
 async function checkZookeeper(options, startTime) {
-    const took = ts.toHumanTime(Date.now() - startTime);
-    signale_1.default.success(` zookeeper*might* be running, took ${took}`);
+    const took = toHumanTime(Date.now() - startTime);
+    signale.success(` zookeeper*might* be running, took ${took}`);
 }
 async function startService(options, service) {
     let serviceName = service;
     if (serviceName === 'restrained_elasticsearch') {
-        serviceName = interfaces_1.Service.Elasticsearch;
+        serviceName = Service.Elasticsearch;
     }
     if (serviceName === 'restrained_opensearch') {
-        serviceName = interfaces_1.Service.Opensearch;
+        serviceName = Service.Opensearch;
     }
     let version;
     if (serviceName === 'kafka') {
         version = config[`${serviceName.toUpperCase()}_IMAGE_VERSION`];
-        signale_1.default.pending(`starting ${service}@${config.KAFKA_VERSION} service...`);
+        signale.pending(`starting ${service}@${config.KAFKA_VERSION} service...`);
     }
     else {
         version = config[`${serviceName.toUpperCase()}_VERSION`];
-        signale_1.default.pending(`starting ${service}@${version} service...`);
+        signale.pending(`starting ${service}@${version} service...`);
     }
     if (options.useExistingServices) {
-        signale_1.default.warn(`expecting ${service}@${version} to be running (this can be dangerous)...`);
+        signale.warn(`expecting ${service}@${version} to be running (this can be dangerous)...`);
         return () => { };
     }
     if (options.testPlatform === 'kubernetes' || options.testPlatform === 'kubernetesV2') {
-        const kind = new kind_1.Kind(config.K8S_VERSION, options.kindClusterName);
+        const kind = new Kind(config.K8S_VERSION, options.kindClusterName);
         await kind.loadServiceImage(service, services[service].image, version);
-        await (0, scripts_1.k8sStopService)(service);
-        await (0, scripts_1.k8sStartService)(service, services[service].image, version, kind);
+        await k8sStopService(service);
+        await k8sStartService(service, services[service].image, version, kind);
         return () => { };
     }
     await stopService(service);
-    const fn = await (0, scripts_1.dockerRun)(services[service], version, options.ignoreMount, options.debug || options.trace);
+    const fn = await dockerRun(services[service], version, options.ignoreMount, options.debug || options.trace);
     return () => {
         try {
             fn();
         }
         catch (err) {
-            signale_1.default.error(new ts.TSError(err, {
+            signale.error(new TSError(err, {
                 reason: `Failed to stop ${service}@${version} service`,
             }));
         }