// SPDX-License-Identifier: Apache-2.0 import {type NamespaceName} from '../types/namespace/namespace-name.js'; import {type PodReference} from '../integration/kube/resources/pod/pod-reference.js'; import {HEDERA_HAPI_PATH, LOG_CONFIG_ZIP_SUFFIX, ROOT_CONTAINER, SOLO_LOGS_DIR} from './constants.js'; import fs from 'node:fs'; import {ContainerReference} from '../integration/kube/resources/container/container-reference.js'; import * as constants from './constants.js'; import {sleep} from './helpers.js'; import {Duration} from './time/duration.js'; import {inject, injectable} from 'tsyringe-neo'; import {type SoloLogger} from './logging/solo-logger.js'; import {type K8Factory} from '../integration/kube/k8-factory.js'; import {patchInject} from './dependency-injection/container-helper.js'; import {InjectTokens} from './dependency-injection/inject-tokens.js'; import {type Pod} from '../integration/kube/resources/pod/pod.js'; import {PathEx} from '../business/utils/path-ex.js'; import {K8} from '../integration/kube/k8.js'; import {Container} from '../integration/kube/resources/container/container.js'; import chalk from 'chalk'; /** * Class to manage network nodes */ @injectable() export class NetworkNodes { public constructor( @inject(InjectTokens.SoloLogger) private readonly logger?: SoloLogger, @inject(InjectTokens.K8Factory) private readonly k8Factory?: K8Factory, ) { this.logger = patchInject(logger, InjectTokens.SoloLogger, this.constructor.name); this.k8Factory = patchInject(k8Factory, InjectTokens.K8Factory, this.constructor.name); } /** * Download logs files from all network pods and save to local solo log directory * @param namespace - the namespace of the network * @param [contexts] * @param [baseDirectory] - optional base directory to save logs, defaults to SOLO_LOGS_DIR * @param [excludeSensitiveData] - when true, omit TLS certificates, private keys, and data/keys from the archive * @returns a promise that resolves when the logs are downloaded */ public async getLogs( namespace: NamespaceName, contexts?: string[], baseDirectory?: string, excludeSensitiveData?: boolean, ): Promise { const podsData: {pod: Pod; context?: string}[] = []; if (contexts) { for (const context of contexts) { const pods: Pod[] = await this.k8Factory .getK8(context) .pods() .list(namespace, ['solo.hedera.com/type=network-node']); for (const pod of pods) { podsData.push({pod, context}); } } } else { const pods: Pod[] = await this.k8Factory.default().pods().list(namespace, ['solo.hedera.com/type=network-node']); for (const pod of pods) { podsData.push({pod}); } } const logBaseDirectory: string = baseDirectory || SOLO_LOGS_DIR; const promises: Promise[] = []; for (const podData of podsData) { promises.push(this.getLog(podData.pod, namespace, logBaseDirectory, podData.context, excludeSensitiveData)); } this.logger.showUser(`Configurations and logs saved to ${logBaseDirectory}`); return await Promise.all(promises); } private async getLog( pod: Pod, namespace: NamespaceName, baseDirectory: string, context?: string, excludeSensitiveData?: boolean, ): Promise { const podReference: PodReference = pod.podReference; this.logger.debug(`getNodeLogs(${pod.podReference.name.name}): begin...`); const targetDirectory: string = PathEx.join(baseDirectory, namespace.name); try { if (!fs.existsSync(targetDirectory)) { fs.mkdirSync(targetDirectory, {recursive: true}); } const containerReference: ContainerReference = ContainerReference.of(podReference, ROOT_CONTAINER); const scriptName: string = 'support-zip.sh'; const sourcePath: string = PathEx.joinWithRealPath(constants.RESOURCES_DIR, scriptName); // script source path const k8: K8 = this.k8Factory.getK8(context); const container: Container = k8.containers().readByRef(containerReference); await container.copyTo(sourcePath, `${HEDERA_HAPI_PATH}`); await sleep(Duration.ofSeconds(3)); // wait for the script to sync to the file system await container.execContainer([ 'bash', '-c', `sync ${HEDERA_HAPI_PATH} && chown hedera:hedera ${HEDERA_HAPI_PATH}/${scriptName}`, ]); await container.execContainer(['bash', '-c', `chmod 0755 ${HEDERA_HAPI_PATH}/${scriptName}`]); await container.execContainer( `${HEDERA_HAPI_PATH}/${scriptName} true ${excludeSensitiveData === true ? 'true' : 'false'}`, ); await container.copyFrom( `${HEDERA_HAPI_PATH}/data/${podReference.name}${LOG_CONFIG_ZIP_SUFFIX}`, targetDirectory, ); this.logger.showUser( `Log zip file ${podReference.name}${LOG_CONFIG_ZIP_SUFFIX} downloaded to ${targetDirectory}`, ); } catch (error) { // not throw error here, so we can continue to finish downloading logs from other pods // and also delete namespace in the end this.logger.error(`${constants.NODE_LOG_FAILURE_MSG} ${podReference}`, error); this.logger.showUser(chalk.red(`${constants.NODE_LOG_FAILURE_MSG} ${podReference}`)); } this.logger.debug(`getNodeLogs(${pod.podReference.name.name}): ...end`); } /** * Download state files from a pod * @param namespace - the namespace of the network * @param nodeAlias - the pod name * @param [context] * @param [baseDirectory] - optional base directory to save state files, defaults to SOLO_LOGS_DIR * @returns a promise that resolves when the state files are downloaded */ public async getStatesFromPod( namespace: NamespaceName, nodeAlias: string, context?: string, baseDirectory?: string, ): Promise { const pods: Pod[] = await this.k8Factory .getK8(context) .pods() .list(namespace, [`solo.hedera.com/node-name=${nodeAlias}`, 'solo.hedera.com/type=network-node']); // get length of pods const stateBaseDirectory: string = baseDirectory || SOLO_LOGS_DIR; const promises: Promise[] = []; for (const pod of pods) { promises.push(this.getState(pod, namespace, stateBaseDirectory, context)); } return await Promise.all(promises); } private async getState(pod: Pod, namespace: NamespaceName, baseDirectory: string, context?: string): Promise { const podReference: PodReference = pod.podReference; this.logger.debug(`getNodeState(${pod.podReference.name.name}): begin...`); const targetDirectory: string = PathEx.join(baseDirectory, namespace.name); try { if (!fs.existsSync(targetDirectory)) { fs.mkdirSync(targetDirectory, {recursive: true}); } // Use zip for compression, similar to tar -czf with -C flag const containerReference: ContainerReference = ContainerReference.of(podReference, ROOT_CONTAINER); const k8: K8 = this.k8Factory.getK8(context); const zipFileName: string = `${HEDERA_HAPI_PATH}/${podReference.name}-state.zip`; // Zip doesn't have a -C flag like tar, so we use sh -c with subshell to change directory // Use the -X to archive for cross-platform compatibility await k8 .containers() .readByRef(containerReference) .execContainer([ 'sh', '-c', `(cd ${HEDERA_HAPI_PATH}/data/saved && zip -rX ${zipFileName} . && sync && test -f ${zipFileName})`, ]); await sleep(Duration.ofSeconds(1)); await k8.containers().readByRef(containerReference).copyFrom(`${zipFileName}`, targetDirectory); } catch (error: Error | unknown) { this.logger.error(`failed to download state from pod ${podReference.name}`, error); this.logger.showUser(`Failed to download state from pod ${podReference.name}` + error); } this.logger.debug(`getNodeState(${pod.podReference.name.name}): ...end`); } public async getNetworkNodePodStatus(podReference: PodReference, context?: string): Promise { return this.k8Factory .getK8(context) .containers() .readByRef(ContainerReference.of(podReference, constants.ROOT_CONTAINER)) .execContainer([ 'bash', '-c', String.raw`curl -s http://localhost:9999/metrics | grep platform_PlatformStatus | grep -v \#`, ]); } }