@hashgraph/solo
Version:
An opinionated CLI tool to deploy and manage private Hedera Networks.
681 lines (595 loc) • 27.9 kB
text/typescript
// SPDX-License-Identifier: Apache-2.0
import {Templates} from '../../core/templates.js';
import * as constants from '../../core/constants.js';
import {AccountId, PrivateKey} from '@hiero-ledger/sdk';
import {SoloError} from '../../core/errors/solo-error.js';
import * as helpers from '../../core/helpers.js';
import {checkNamespace} from '../../core/helpers.js';
import fs from 'node:fs';
import {resolveNamespaceFromDeployment} from '../../core/resolvers.js';
import {Flags as flags} from '../flags.js';
import {type AnyObject, type ArgvStruct} from '../../types/aliases.js';
import {type NodeAddConfigClass} from './config-interfaces/node-add-config-class.js';
import {type K8Factory} from '../../integration/kube/k8-factory.js';
import {type ConsensusNode} from '../../core/model/consensus-node.js';
import {inject, injectable} from 'tsyringe-neo';
import {InjectTokens} from '../../core/dependency-injection/inject-tokens.js';
import {type ConfigManager} from '../../core/config-manager.js';
import {patchInject} from '../../core/dependency-injection/container-helper.js';
import {type AccountManager} from '../../core/account-manager.js';
import {PathEx} from '../../business/utils/path-ex.js';
import {type NodeSetupConfigClass} from './config-interfaces/node-setup-config-class.js';
import {type NodeStartConfigClass} from './config-interfaces/node-start-config-class.js';
import {type NodeKeysConfigClass} from './config-interfaces/node-keys-config-class.js';
import {type NodeRefreshConfigClass} from './config-interfaces/node-refresh-config-class.js';
import {type NodeLogsConfigClass} from './config-interfaces/node-logs-config-class.js';
import {type NodeDestroyConfigClass} from './config-interfaces/node-destroy-config-class.js';
import {type NodeUpdateConfigClass} from './config-interfaces/node-update-config-class.js';
import {type NodeUpgradeConfigClass} from './config-interfaces/node-upgrade-config-class.js';
import {type NodePrepareUpgradeConfigClass} from './config-interfaces/node-prepare-upgrade-config-class.js';
import {type SoloListrTaskWrapper} from '../../types/index.js';
import {type NodeUpgradeContext} from './config-interfaces/node-upgrade-context.js';
import {type NodeUpdateContext} from './config-interfaces/node-update-context.js';
import {type NodeDestroyContext} from './config-interfaces/node-destroy-context.js';
import {type NodeAddContext} from './config-interfaces/node-add-context.js';
import {type NodeLogsContext} from './config-interfaces/node-logs-context.js';
import {type NodeStatesConfigClass} from './config-interfaces/node-states-config-class.js';
import {type NodeStatesContext} from './config-interfaces/node-states-context.js';
import {type NodeRefreshContext} from './config-interfaces/node-refresh-context.js';
import {type NodeKeysContext} from './config-interfaces/node-keys-context.js';
import {type NodeStopConfigClass} from './config-interfaces/node-stop-config-class.js';
import {type NodeStopContext} from './config-interfaces/node-stop-context.js';
import {type NodeFreezeConfigClass} from './config-interfaces/node-freeze-config-class.js';
import {type NodeFreezeContext} from './config-interfaces/node-freeze-context.js';
import {type NodeStartContext} from './config-interfaces/node-start-context.js';
import {type NodeRestartConfigClass} from './config-interfaces/node-restart-config-class.js';
import {type NodeRestartContext} from './config-interfaces/node-restart-context.js';
import {type NodeSetupContext} from './config-interfaces/node-setup-context.js';
import {type NodePrepareUpgradeContext} from './config-interfaces/node-prepare-upgrade-context.js';
import {type LocalConfigRuntimeState} from '../../business/runtime-state/config/local/local-config-runtime-state.js';
import {type RemoteConfigRuntimeStateApi} from '../../business/runtime-state/api/remote-config-runtime-state-api.js';
import {SemanticVersion} from '../../business/utils/semantic-version.js';
import {assertUpgradeVersionNotOlder} from '../../core/upgrade-version-guard.js';
import {SOLO_USER_AGENT_HEADER} from '../../core/constants.js';
import {type NodeConnectionsConfigClass} from './config-interfaces/node-connections-config-class.js';
import {type NodeConnectionsContext} from './config-interfaces/node-connections-context.js';
import {NodeCollectJfrLogsConfigClass} from './config-interfaces/node-collect-jfr-logs-config-class.js';
import {NodeCollectJfrLogsContext} from './config-interfaces/node-collect-jfr-logs-context.js';
import {optionFromFlag} from '../command-helpers.js';
const PREPARE_UPGRADE_CONFIGS_NAME: string = 'prepareUpgradeConfig';
const ADD_CONFIGS_NAME: string = 'addConfigs';
const DESTROY_CONFIGS_NAME: string = 'destroyConfigs';
const UPDATE_CONFIGS_NAME: string = 'updateConfigs';
const UPGRADE_CONFIGS_NAME: string = 'upgradeConfigs';
const REFRESH_CONFIGS_NAME: string = 'refreshConfigs';
const KEYS_CONFIGS_NAME: string = 'keyConfigs';
const SETUP_CONFIGS_NAME: string = 'setupConfigs';
const START_CONFIGS_NAME: string = 'startConfigs';
export class NodeCommandConfigs {
public constructor(
private readonly configManager: ConfigManager,
private readonly localConfig: LocalConfigRuntimeState,
private readonly remoteConfig: RemoteConfigRuntimeStateApi,
private readonly k8Factory: K8Factory,
private readonly accountManager: AccountManager,
) {
this.configManager = patchInject(configManager, InjectTokens.ConfigManager, this.constructor.name);
this.localConfig = patchInject(localConfig, InjectTokens.LocalConfigRuntimeState, this.constructor.name);
this.k8Factory = patchInject(k8Factory, InjectTokens.K8Factory, this.constructor.name);
this.accountManager = patchInject(accountManager, InjectTokens.AccountManager, this.constructor.name);
this.remoteConfig = patchInject(remoteConfig, InjectTokens.RemoteConfigRuntimeState, this.constructor.name);
}
private async initializeSetup(config: AnyObject, k8Factory: K8Factory): Promise<void> {
// compute other config parameters
config.keysDir = PathEx.join(config.cacheDir, 'keys');
config.stagingDir = Templates.renderStagingDir(config.cacheDir, config.releaseTag);
config.stagingKeysDir = PathEx.join(config.stagingDir, 'keys');
if (!(await k8Factory.default().namespaces().has(config.namespace))) {
throw new SoloError(`namespace ${config.namespace} does not exist`);
}
// prepare staging keys directory
if (!fs.existsSync(config.stagingKeysDir)) {
fs.mkdirSync(config.stagingKeysDir, {recursive: true});
}
// create cached keys dir if it does not exist yet
if (!fs.existsSync(config.keysDir)) {
fs.mkdirSync(config.keysDir);
}
}
public async prepareUpgradeConfigBuilder(
argv: ArgvStruct,
context_: NodePrepareUpgradeContext,
task: SoloListrTaskWrapper<NodePrepareUpgradeContext>,
): Promise<NodePrepareUpgradeConfigClass> {
context_.config = this.configManager.getConfig(PREPARE_UPGRADE_CONFIGS_NAME, argv.flags, [
'nodeClient',
'freezeAdminPrivateKey',
'namespace',
'consensusNodes',
'contexts',
]) as NodePrepareUpgradeConfigClass;
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
await this.initializeSetup(context_.config, this.k8Factory);
context_.config.nodeClient = await this.accountManager.refreshNodeClient(
context_.config.namespace,
this.remoteConfig.getClusterRefs(),
context_.config.skipNodeAlias,
context_.config.deployment,
);
const freezeAdminAccountId: AccountId = this.accountManager.getFreezeAccountId(context_.config.deployment);
const accountKeys = await this.accountManager.getAccountKeysFromSecret(
freezeAdminAccountId.toString(),
context_.config.namespace,
);
context_.config.freezeAdminPrivateKey = accountKeys.privateKey;
return context_.config;
}
public async upgradeConfigBuilder(
argv: ArgvStruct,
context_: NodeUpgradeContext,
task: SoloListrTaskWrapper<NodeUpgradeContext>,
shouldLoadNodeClient: boolean = true,
): Promise<NodeUpgradeConfigClass> {
context_.config = this.configManager.getConfig(UPGRADE_CONFIGS_NAME, argv.flags, [
'allNodeAliases',
'existingNodeAliases',
'keysDir',
'nodeClient',
'podRefs',
'stagingDir',
'stagingKeysDir',
'namespace',
'consensusNodes',
'contexts',
]) as NodeUpgradeConfigClass;
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
context_.config.curDate = new Date();
context_.config.existingNodeAliases = [];
context_.config.nodeAliases = helpers.parseNodeAliases(
context_.config.nodeAliasesUnparsed,
this.remoteConfig.getConsensusNodes(),
this.configManager,
);
// check if the intended package version exists
if (context_.config.upgradeVersion) {
const semVersion: SemanticVersion<string> = new SemanticVersion<string>(context_.config.upgradeVersion);
const HEDERA_BUILDS_URL: string = 'https://builds.hedera.com';
const BUILD_ZIP_URL: string = `${HEDERA_BUILDS_URL}/node/software/v${semVersion.major}.${semVersion.minor}/build-${context_.config.upgradeVersion}.zip`;
try {
// do not fetch or download, just check if URL exists or not
const response = await fetch(BUILD_ZIP_URL, {
method: 'HEAD',
headers: {
'User-Agent': SOLO_USER_AGENT_HEADER,
},
});
if (!response.ok) {
throw new SoloError(`Upgrade version ${context_.config.upgradeVersion} does not exist.`);
}
} catch (error) {
throw new SoloError(`Failed to fetch upgrade version ${context_.config.upgradeVersion}: ${error.message}`);
}
// Compare target version against the version stored in remote config
assertUpgradeVersionNotOlder(
'Consensus node',
context_.config.upgradeVersion,
this.remoteConfig.configuration.versions.consensusNode,
optionFromFlag(flags.upgradeVersion),
);
}
await this.initializeSetup(context_.config, this.k8Factory);
if (shouldLoadNodeClient) {
context_.config.nodeClient = await this.accountManager.loadNodeClient(
context_.config.namespace,
this.remoteConfig.getClusterRefs(),
context_.config.deployment,
);
}
const freezeAdminAccountId: AccountId = this.accountManager.getFreezeAccountId(context_.config.deployment);
const accountKeys = await this.accountManager.getAccountKeysFromSecret(
freezeAdminAccountId.toString(),
context_.config.namespace,
);
context_.config.freezeAdminPrivateKey = accountKeys.privateKey;
return context_.config;
}
public async updateConfigBuilder(
argv: ArgvStruct,
context_: NodeUpdateContext,
task: SoloListrTaskWrapper<NodeUpdateContext>,
shouldLoadNodeClient: boolean = true,
): Promise<NodeUpdateConfigClass> {
context_.config = this.configManager.getConfig(UPDATE_CONFIGS_NAME, argv.flags, [
'allNodeAliases',
'existingNodeAliases',
'freezeAdminPrivateKey',
'keysDir',
'nodeClient',
'podRefs',
'serviceMap',
'stagingDir',
'stagingKeysDir',
'treasuryKey',
'namespace',
'consensusNodes',
'contexts',
]) as NodeUpdateConfigClass;
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
context_.config.curDate = new Date();
context_.config.existingNodeAliases = [];
await this.initializeSetup(context_.config, this.k8Factory);
if (shouldLoadNodeClient) {
context_.config.nodeClient = await this.accountManager.loadNodeClient(
context_.config.namespace,
this.remoteConfig.getClusterRefs(),
context_.config.deployment,
);
}
// check consensus releaseTag to make sure it is a valid semantic version string starting with 'v'
context_.config.releaseTag = SemanticVersion.getValidSemanticVersion(
context_.config.releaseTag,
true,
'Consensus release tag',
);
const freezeAdminAccountId: AccountId = this.accountManager.getFreezeAccountId(context_.config.deployment);
const accountKeys = await this.accountManager.getAccountKeysFromSecret(
freezeAdminAccountId.toString(),
context_.config.namespace,
);
context_.config.freezeAdminPrivateKey = accountKeys.privateKey;
const treasuryAccount = await this.accountManager.getTreasuryAccountKeys(
context_.config.namespace,
context_.config.deployment,
);
const treasuryAccountPrivateKey = treasuryAccount.privateKey;
context_.config.treasuryKey = PrivateKey.fromStringED25519(treasuryAccountPrivateKey);
if (context_.config.domainNames) {
context_.config.domainNamesMapping = Templates.parseNodeAliasToDomainNameMapping(context_.config.domainNames);
}
return context_.config;
}
public async destroyConfigBuilder(
argv: ArgvStruct,
context_: NodeDestroyContext,
task: SoloListrTaskWrapper<NodeDestroyContext>,
shouldLoadNodeClient: boolean = true,
): Promise<NodeDestroyConfigClass> {
context_.config = this.configManager.getConfig(DESTROY_CONFIGS_NAME, argv.flags, [
'adminKey',
'allNodeAliases',
'existingNodeAliases',
'freezeAdminPrivateKey',
'keysDir',
'nodeClient',
'podRefs',
'serviceMap',
'stagingDir',
'stagingKeysDir',
'treasuryKey',
'namespace',
'consensusNodes',
'contexts',
]) as NodeDestroyConfigClass;
context_.config.curDate = new Date();
context_.config.existingNodeAliases = [];
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
await this.initializeSetup(context_.config, this.k8Factory);
if (shouldLoadNodeClient) {
context_.config.nodeClient = await this.accountManager.loadNodeClient(
context_.config.namespace,
this.remoteConfig.getClusterRefs(),
context_.config.deployment,
);
}
const freezeAdminAccountId: AccountId = this.accountManager.getFreezeAccountId(context_.config.deployment);
const accountKeys = await this.accountManager.getAccountKeysFromSecret(
freezeAdminAccountId.toString(),
context_.config.namespace,
);
context_.config.freezeAdminPrivateKey = accountKeys.privateKey;
const treasuryAccount = await this.accountManager.getTreasuryAccountKeys(
context_.config.namespace,
context_.config.deployment,
);
const treasuryAccountPrivateKey = treasuryAccount.privateKey;
context_.config.treasuryKey = PrivateKey.fromStringED25519(treasuryAccountPrivateKey);
if (context_.config.domainNames) {
context_.config.domainNamesMapping = Templates.parseNodeAliasToDomainNameMapping(context_.config.domainNames);
}
return context_.config;
}
public async addConfigBuilder(
argv: ArgvStruct,
context_: NodeAddContext,
task: SoloListrTaskWrapper<NodeAddContext>,
shouldLoadNodeClient: boolean = true,
): Promise<NodeAddConfigClass> {
context_.config = this.configManager.getConfig(ADD_CONFIGS_NAME, argv.flags, [
'allNodeAliases',
'newNodeAliases',
'curDate',
'existingNodeAliases',
'freezeAdminPrivateKey',
'keysDir',
'lastStateZipPath',
'nodeClient',
'podRefs',
'serviceMap',
'stagingDir',
'stagingKeysDir',
'treasuryKey',
'namespace',
'consensusNodes',
'contexts',
]) as NodeAddConfigClass;
context_.adminKey = argv[flags.adminKey?.name]
? PrivateKey.fromStringED25519(argv[flags.adminKey?.name])
: PrivateKey.fromStringED25519(constants.GENESIS_KEY);
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
context_.config.curDate = new Date();
context_.config.existingNodeAliases = [];
await this.initializeSetup(context_.config, this.k8Factory);
if (shouldLoadNodeClient) {
context_.config.nodeClient = await this.accountManager.loadNodeClient(
context_.config.namespace,
this.remoteConfig.getClusterRefs(),
context_.config.deployment,
);
}
const freezeAdminAccountId: AccountId = this.accountManager.getFreezeAccountId(context_.config.deployment);
const accountKeys = await this.accountManager.getAccountKeysFromSecret(
freezeAdminAccountId.toString(),
context_.config.namespace,
);
context_.config.freezeAdminPrivateKey = accountKeys.privateKey;
const treasuryAccount = await this.accountManager.getTreasuryAccountKeys(
context_.config.namespace,
context_.config.deployment,
);
const treasuryAccountPrivateKey = treasuryAccount.privateKey;
context_.config.treasuryKey = PrivateKey.fromStringED25519(treasuryAccountPrivateKey);
context_.config.serviceMap = await this.accountManager.getNodeServiceMap(
context_.config.namespace,
this.remoteConfig.getClusterRefs(),
context_.config.deployment,
);
context_.config.consensusNodes = this.remoteConfig.getConsensusNodes();
context_.config.contexts = this.remoteConfig.getContexts();
if (!context_.config.clusterRef) {
context_.config.clusterRef = this.remoteConfig.getClusterRefs()?.entries()?.next()?.value[0];
if (!context_.config.clusterRef) {
throw new SoloError('Error during initialization, cluster ref could not be determined');
}
}
if (context_.config.domainNames) {
context_.config.domainNamesMapping = Templates.parseNodeAliasToDomainNameMapping(context_.config.domainNames);
}
return context_.config;
}
public async logsConfigBuilder(
_argv: ArgvStruct,
context_: NodeLogsContext,
task: SoloListrTaskWrapper<NodeLogsContext>,
): Promise<NodeLogsConfigClass> {
context_.config = {
namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
nodeAliases: helpers.parseNodeAliases(
this.configManager.getFlag(flags.nodeAliasesUnparsed),
this.remoteConfig.getConsensusNodes(),
this.configManager,
),
nodeAliasesUnparsed: this.configManager.getFlag(flags.nodeAliasesUnparsed),
deployment: this.configManager.getFlag(flags.deployment),
consensusNodes: this.remoteConfig.getConsensusNodes(),
contexts: this.remoteConfig.getContexts(),
} as NodeLogsConfigClass;
return context_.config;
}
public async connectionsConfigBuilder(
_argv: ArgvStruct,
context_: NodeConnectionsContext,
task: SoloListrTaskWrapper<NodeConnectionsContext>,
): Promise<NodeConnectionsConfigClass> {
context_.config = {
deployment: this.configManager.getFlag(flags.deployment),
namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
contexts: this.remoteConfig.getContexts()[0],
} as any as NodeConnectionsConfigClass;
return context_.config;
}
public async statesConfigBuilder(
_argv: ArgvStruct,
context_: NodeStatesContext,
task: SoloListrTaskWrapper<NodeStatesContext>,
): Promise<NodeStatesConfigClass> {
const consensusNodes: ConsensusNode[] = this.remoteConfig.getConsensusNodes();
context_.config = {
namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
nodeAliases: helpers.parseNodeAliases(
this.configManager.getFlag(flags.nodeAliasesUnparsed),
consensusNodes,
this.configManager,
),
nodeAliasesUnparsed: this.configManager.getFlag(flags.nodeAliasesUnparsed),
deployment: this.configManager.getFlag(flags.deployment),
consensusNodes,
contexts: this.remoteConfig.getContexts(),
} as NodeStatesConfigClass;
return context_.config;
}
public async refreshConfigBuilder(
argv: ArgvStruct,
context_: NodeRefreshContext,
task: SoloListrTaskWrapper<NodeRefreshContext>,
): Promise<NodeRefreshConfigClass> {
context_.config = this.configManager.getConfig(REFRESH_CONFIGS_NAME, argv.flags, [
'nodeAliases',
'podRefs',
'namespace',
'consensusNodes',
'contexts',
]) as NodeRefreshConfigClass;
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
context_.config.nodeAliases = helpers.parseNodeAliases(
context_.config.nodeAliasesUnparsed,
this.remoteConfig.getConsensusNodes(),
this.configManager,
);
await this.initializeSetup(context_.config, this.k8Factory);
if (context_.config.domainNames) {
context_.config.domainNamesMapping = Templates.parseNodeAliasToDomainNameMapping(context_.config.domainNames);
}
return context_.config;
}
public async keysConfigBuilder(argv: ArgvStruct, context_: NodeKeysContext): Promise<NodeKeysConfigClass> {
context_.config = this.configManager.getConfig(KEYS_CONFIGS_NAME, argv.flags, [
'curDate',
'keysDir',
'nodeAliases',
'consensusNodes',
'contexts',
]) as NodeKeysConfigClass;
context_.config.curDate = new Date();
context_.config.nodeAliases = helpers.parseNodeAliases(
context_.config.nodeAliasesUnparsed,
this.remoteConfig.getConsensusNodes(),
this.configManager,
);
context_.config.keysDir = PathEx.join(this.configManager.getFlag(flags.cacheDir), 'keys');
if (!fs.existsSync(context_.config.keysDir)) {
fs.mkdirSync(context_.config.keysDir);
}
return context_.config;
}
public async stopConfigBuilder(
_argv: ArgvStruct,
context_: NodeStopContext,
task: SoloListrTaskWrapper<NodeStopContext>,
): Promise<NodeStopConfigClass> {
const consensusNodes: ConsensusNode[] = this.remoteConfig.getConsensusNodes();
context_.config = {
namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
nodeAliases: helpers.parseNodeAliases(
this.configManager.getFlag(flags.nodeAliasesUnparsed),
consensusNodes,
this.configManager,
),
nodeAliasesUnparsed: this.configManager.getFlag(flags.nodeAliasesUnparsed),
deployment: this.configManager.getFlag(flags.deployment),
consensusNodes,
contexts: this.remoteConfig.getContexts(),
} as NodeStopConfigClass;
await checkNamespace(context_.config.consensusNodes, this.k8Factory, context_.config.namespace);
return context_.config;
}
public async freezeConfigBuilder(
_argv: ArgvStruct,
context_: NodeFreezeContext,
task: SoloListrTaskWrapper<NodeFreezeContext>,
): Promise<NodeFreezeConfigClass> {
context_.config = {
namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
deployment: this.configManager.getFlag(flags.deployment),
consensusNodes: this.remoteConfig.getConsensusNodes(),
contexts: this.remoteConfig.getContexts(),
} as NodeFreezeConfigClass;
await checkNamespace(context_.config.consensusNodes, this.k8Factory, context_.config.namespace);
const freezeAdminAccountId: AccountId = this.accountManager.getFreezeAccountId(context_.config.deployment);
const accountKeys = await this.accountManager.getAccountKeysFromSecret(
freezeAdminAccountId.toString(),
context_.config.namespace,
);
context_.config.freezeAdminPrivateKey = accountKeys.privateKey;
return context_.config;
}
public async startConfigBuilder(
argv: ArgvStruct,
context_: NodeStartContext,
task: SoloListrTaskWrapper<NodeStartContext>,
): Promise<NodeStartConfigClass> {
context_.config = this.configManager.getConfig(START_CONFIGS_NAME, argv.flags, [
'nodeAliases',
'namespace',
'consensusNodes',
'contexts',
]) as NodeStartConfigClass;
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
context_.config.consensusNodes = this.remoteConfig.getConsensusNodes();
for (const consensusNode of context_.config.consensusNodes) {
const k8 = this.k8Factory.getK8(consensusNode.context);
if (!(await k8.namespaces().has(context_.config.namespace))) {
throw new SoloError(`namespace ${context_.config.namespace} does not exist`);
}
}
context_.config.nodeAliases = helpers.parseNodeAliases(
context_.config.nodeAliasesUnparsed,
context_.config.consensusNodes,
this.configManager,
);
return context_.config;
}
public async restartConfigBuilder(
_argv: ArgvStruct,
context_: NodeRestartContext,
task: SoloListrTaskWrapper<NodeRestartContext>,
): Promise<NodeRestartConfigClass> {
context_.config = {
namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
deployment: this.configManager.getFlag(flags.deployment),
consensusNodes: this.remoteConfig.getConsensusNodes(),
contexts: this.remoteConfig.getContexts(),
} as NodeRestartConfigClass;
await checkNamespace(context_.config.consensusNodes, this.k8Factory, context_.config.namespace);
return context_.config;
}
public async collectJfrConfigBuilder(
_argv: ArgvStruct,
context_: NodeCollectJfrLogsContext,
task: SoloListrTaskWrapper<NodeCollectJfrLogsContext>,
): Promise<NodeCollectJfrLogsConfigClass> {
context_.config = {
namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
deployment: this.configManager.getFlag(flags.deployment),
consensusNodes: this.remoteConfig.getConsensusNodes(),
contexts: this.remoteConfig.getContexts(),
nodeAlias: this.configManager.getFlag(flags.nodeAlias),
} as NodeCollectJfrLogsConfigClass;
await checkNamespace(context_.config.consensusNodes, this.k8Factory, context_.config.namespace);
return context_.config;
}
public async setupConfigBuilder(
argv: ArgvStruct,
context_: NodeSetupContext,
task: SoloListrTaskWrapper<NodeSetupContext>,
): Promise<NodeSetupConfigClass> {
context_.config = this.configManager.getConfig(SETUP_CONFIGS_NAME, argv.flags, [
'nodeAliases',
'podRefs',
'namespace',
'consensusNodes',
'contexts',
]) as NodeSetupConfigClass;
const savedVersion: SemanticVersion<string> = this.remoteConfig.configuration.versions.consensusNode;
if (
!savedVersion.equals(context_.config.releaseTag) && // allow different versions only for local builds
!context_.config.localBuildPath
) {
throw new SoloError(
`Consensus node version saved in remote config ${savedVersion} is different from ${context_.config.releaseTag}`,
);
}
context_.config.namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
context_.config.consensusNodes = this.remoteConfig.getConsensusNodes();
context_.config.nodeAliases = helpers.parseNodeAliases(
context_.config.nodeAliasesUnparsed,
context_.config.consensusNodes,
this.configManager,
);
await this.initializeSetup(context_.config, this.k8Factory);
if (context_.config.domainNames) {
context_.config.domainNamesMapping = Templates.parseNodeAliasToDomainNameMapping(context_.config.domainNames);
}
return context_.config;
}
}