Skip to content

Commit

Permalink
Merge pull request #894 from paritytech/refacto/native-resources
Browse files Browse the repository at this point in the history
Refacto/native resources
  • Loading branch information
l0r1s authored Apr 5, 2023
2 parents b7e15b7 + df00db5 commit c3f8e99
Show file tree
Hide file tree
Showing 5 changed files with 251 additions and 132 deletions.
Original file line number Diff line number Diff line change
@@ -1,153 +1,28 @@
import { getRandomPort, makeDir } from "@zombienet/utils";
import { genCmd, genCumulusCollatorCmd } from "../../cmdGenerator";
import { getRandomPort } from "@zombienet/utils";
import { getUniqueName } from "../../configGenerator";
import {
P2P_PORT,
PROMETHEUS_PORT,
RPC_HTTP_PORT,
RPC_WS_PORT,
} from "../../constants";
import { Network } from "../../network";
import { Node, envVars } from "../../types";
import { Node } from "../../types";
import { getClient } from "../client";

interface processEnvironment {
[key: string]: string;
}
import { BootNodeResource, NodeResource } from "./resources";

export async function genBootnodeDef(
namespace: string,
nodeSetup: Node,
): Promise<any> {
const client = getClient();
const name = nodeSetup.name;
const { rpcPort, wsPort, prometheusPort, p2pPort } = nodeSetup;
const ports = await getPorts(rpcPort, wsPort, prometheusPort, p2pPort);

const cfgPath = `${client.tmpDir}/${name}/cfg`;
await makeDir(cfgPath, true);

const dataPath = `${client.tmpDir}/${name}/data`;
await makeDir(dataPath, true);
const bootNodeResource = new BootNodeResource(client, namespace, nodeSetup);

const command = await genCmd(nodeSetup, cfgPath, dataPath, false);
return {
metadata: {
name: "bootnode",
namespace: namespace,
labels: {
name: namespace,
instance: "bootnode",
"zombie-role": "bootnode",
app: "zombienet",
"zombie-ns": namespace,
},
},
spec: {
cfgPath: `${client.tmpDir}/${nodeSetup.name}/cfg`,
ports,
command,
env: nodeSetup.env.reduce((memo, item: envVars) => {
memo[item.name] = item.value;
return memo;
}, {} as processEnvironment),
},
};
return bootNodeResource.generateSpec();
}

export async function genNodeDef(
namespace: string,
nodeSetup: Node,
): Promise<any> {
const client = getClient();
const name = nodeSetup.name;
const { rpcPort, wsPort, prometheusPort, p2pPort } = nodeSetup;
const ports = await getPorts(rpcPort, wsPort, prometheusPort, p2pPort);
const cfgPath = `${client.tmpDir}/${name}/cfg`;
await makeDir(cfgPath, true);

const dataPath = `${client.tmpDir}/${name}/data`;
await makeDir(dataPath, true);

const relayDataPath = `${client.tmpDir}/${name}/relay-data`;
await makeDir(relayDataPath, true);

let computedCommand;
if (nodeSetup.zombieRole === "cumulus-collator") {
computedCommand = await genCumulusCollatorCmd(
nodeSetup,
cfgPath,
dataPath,
relayDataPath,
false,
);
} else {
computedCommand = await genCmd(nodeSetup, cfgPath, dataPath, false);
}

return {
metadata: {
name: nodeSetup.name,
namespace: namespace,
labels: {
"zombie-role": nodeSetup.zombieRole
? nodeSetup.zombieRole
: nodeSetup.validator
? "authority"
: "full-node",
app: "zombienet",
"zombie-ns": namespace,
name: namespace,
instance: nodeSetup.name,
},
},
spec: {
cfgPath,
dataPath,
ports,
command: computedCommand,
env: nodeSetup.env.reduce((memo, item: envVars) => {
memo[item.name] = item.value;
return memo;
}, {} as processEnvironment),
},
};
}

async function getPorts(
rpc?: number,
ws?: number,
prometheus?: number,
p2p?: number,
) {
const ports = [
{
containerPort: PROMETHEUS_PORT,
name: "prometheus",
flag: "--prometheus-port",
hostPort: prometheus || (await getRandomPort()),
},
{
containerPort: RPC_HTTP_PORT,
name: "rpc",
flag: "--rpc-port",
hostPort: rpc || (await getRandomPort()),
},
{
containerPort: RPC_WS_PORT,
name: "ws",
flag: "--ws-port",
hostPort: ws || (await getRandomPort()),
},
{
containerPort: P2P_PORT,
name: "p2p",
flag: "--port",
hostPort: p2p || (await getRandomPort()),
},
];
const nodeResource = new NodeResource(client, namespace, nodeSetup);

return ports;
return nodeResource.generateSpec();
}

export function replaceNetworkRef(podDef: any, network: Network) {
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,52 @@
import { makeDir } from "@zombienet/utils";
import { genCmd } from "../../../cmdGenerator";
import { NodeResource } from "./node.resource";
import { NodeSpec, Port, ProcessEnvironment, ZombieRole } from "./types";

export class BootNodeResource extends NodeResource {
protected async createDirectories() {
try {
await makeDir(this.configPath, true);
await makeDir(this.dataPath, true);
} catch {
throw new Error(
`Error generating directories for ${this.nodeSetupConfig.name} resource`,
);
}
}

protected generateCommand() {
return genCmd(this.nodeSetupConfig, this.configPath, this.dataPath, false);
}

protected getZombieRole(): ZombieRole {
return "bootnode";
}

protected generateNodeSpec(
ports: Port[],
command: string[],
zombieRole: ZombieRole,
env: ProcessEnvironment,
): NodeSpec {
return {
metadata: {
name: "bootnode",
namespace: this.namespace,
labels: {
name: this.namespace,
instance: "bootnode",
"zombie-role": zombieRole,
app: "zombienet",
"zombie-ns": this.namespace,
},
},
spec: {
cfgPath: this.configPath,
ports,
command,
env,
},
};
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,2 @@
export { BootNodeResource } from "./bootnode.resource";
export { NodeResource } from "./node.resource";
Original file line number Diff line number Diff line change
@@ -0,0 +1,153 @@
import { getRandomPort, makeDir } from "@zombienet/utils";
import { genCmd, genCumulusCollatorCmd } from "../../../cmdGenerator";
import {
P2P_PORT,
PROMETHEUS_PORT,
RPC_HTTP_PORT,
RPC_WS_PORT,
} from "../../../constants";
import { Node, envVars } from "../../../types";
import { Client } from "../../client";
import {
NodeSpec,
Port,
PortProperty,
ProcessEnvironment,
ZombieRole,
} from "./types";

export class NodeResource {
protected readonly configPath: string;
protected readonly dataPath: string;
private readonly relayDataPath: string;

constructor(
client: Client,
protected readonly namespace: string,
protected readonly nodeSetupConfig: Node,
) {
const nodeRootPath = `${client.tmpDir}/${this.nodeSetupConfig.name}`;
this.configPath = `${nodeRootPath}/cfg`;
this.dataPath = `${nodeRootPath}/data`;
this.relayDataPath = `${nodeRootPath}/relay-data`;
}

public async generateSpec() {
await this.createDirectories();
const ports = await this.generatePorts();
const command = await this.generateCommand();
const zombieRole = this.getZombieRole();
const env = this.getEnv();
const nodeManifest = this.generateNodeSpec(ports, command, zombieRole, env);

return nodeManifest;
}

protected async createDirectories() {
try {
await makeDir(this.configPath, true);
await makeDir(this.dataPath, true);
await makeDir(this.relayDataPath, true);
} catch {
throw new Error(
`Error generating directories for ${this.nodeSetupConfig.name} resource`,
);
}
}

private async portFromNodeSetupConfigOrDefault(portProperty: PortProperty) {
if (this.nodeSetupConfig[portProperty]) {
return this.nodeSetupConfig[portProperty];
}

return getRandomPort();
}

private async generatePorts(): Promise<Port[]> {
return [
{
containerPort: PROMETHEUS_PORT,
name: "prometheus",
flag: "--prometheus-port",
hostPort: await this.portFromNodeSetupConfigOrDefault("prometheusPort"),
},
{
containerPort: RPC_HTTP_PORT,
name: "rpc",
flag: "--rpc-port",
hostPort: await this.portFromNodeSetupConfigOrDefault("rpcPort"),
},
{
containerPort: RPC_WS_PORT,
name: "rpc-ws",
flag: "--ws-port",
hostPort: await this.portFromNodeSetupConfigOrDefault("wsPort"),
},
{
containerPort: P2P_PORT,
name: "p2p",
flag: "--port",
hostPort: await this.portFromNodeSetupConfigOrDefault("p2pPort"),
},
];
}

protected generateCommand() {
if (this.nodeSetupConfig.zombieRole === "cumulus-collator") {
return genCumulusCollatorCmd(
this.nodeSetupConfig,
this.configPath,
this.dataPath,
this.relayDataPath,
false,
);
}

return genCmd(this.nodeSetupConfig, this.configPath, this.dataPath, false);
}

protected getZombieRole(): ZombieRole {
const { zombieRole, validator } = this.nodeSetupConfig;

if (zombieRole) return zombieRole;

return validator ? "authority" : "full-node";
}

protected getEnv() {
const { env } = this.nodeSetupConfig;

return env.reduce((memo, item: envVars) => {
memo[item.name] = item.value;
return memo;
}, {} as ProcessEnvironment);
}

protected generateNodeSpec(
ports: Port[],
command: string[],
zombieRole: ZombieRole,
env: ProcessEnvironment,
): NodeSpec {
return {
metadata: {
name: this.nodeSetupConfig.name,
namespace: this.namespace,
labels: {
"zombie-role": zombieRole,
app: "zombienet",
"zombie-ns": this.namespace,
name: this.namespace,
instance: this.nodeSetupConfig.name,
},
},
spec: {
cfgPath: this.configPath,
dataPath: this.dataPath,
ports,
command,
env,
},
};
}
}
Loading

0 comments on commit c3f8e99

Please sign in to comment.