mitch/tmnt-168-create-test-network-scenariosyml

Author: just-mitch

.github/.gitignore

@@ -1 +1,2 @@
-.secrets
+.secrets
+.act-tool-cache

.github/local_workflow.sh

@@ -32,10 +32,13 @@ args=("$@")
 
 SA_KEY_JSON=$(cat "$GOOGLE_APPLICATION_CREDENTIALS")
 
+mkdir -p $REPO_ROOT/.github/.act-tool-cache
+
 act workflow_dispatch -j $workflow_name \
+  --env RUNNER_TOOL_CACHE=/work/toolcache \
   -s GITHUB_TOKEN="$(gh auth token)" \
   -s GCP_SA_KEY="$SA_KEY_JSON" \
   -s KUBECONFIG_B64="$(cat $HOME/.kube/config | base64 -w0)" \
-  --container-options "--user $(id -u):$(id -g)" \
+  --container-options "-v $REPO_ROOT/.github/.act-tool-cache:/work/toolcache --user $(id -u):$(id -g)" \
   --bind \
   --directory $REPO_ROOT "${args[@]}"

.github/workflows/deploy-eth-devnet.yml

@@ -149,6 +149,7 @@ jobs:
       beacon_url: ${{ steps.get-eth-devnet-results.outputs.beacon_url }}
       chain_id: ${{ steps.get-eth-devnet-results.outputs.chain_id }}
     env:
+      # HOME: "/home/mitch"
       TF_STATE_BUCKET: aztec-terraform
       REGION: us-west1-a
       # Common Terraform variables as environment variables

.github/workflows/test-network-scenarios.yml

@@ -0,0 +1,44 @@
+on:
+  workflow_call:
+    inputs:
+      cluster:
+        description: The cluster to deploy to, e.g. aztec-gke-private or kind
+        required: true
+        type: string
+      namespace:
+        description: The namespace to deploy to
+        required: true
+        type: string
+      ref:
+        description: The ref to checkout
+        required: true
+        type: string
+
+jobs:
+  test_network_scenarios:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Test network scenarios
+        run: |
+          echo "Testing network scenarios"
+
+      - name: Check if directory exists
+        id: check_dir
+        shell: bash
+        run: |
+          if [ -d ".git" ]; then
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Checkout code
+        if: ${{ steps.check_dir.outputs.exists != 'true' }}
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          ref: ${{ inputs.ref }}
+
+      - name: Build
+        shell: bash
+        run: |
+          ./bootstrap.sh

spartan/terraform/deploy-aztec-infra/main.tf

@@ -188,6 +188,4 @@ resource "google_compute_address" "rpc_ingress" {
   provider     = google
   name         = "${var.NAMESPACE}-${var.RELEASE_PREFIX}-rpc-ingress"
   address_type = "EXTERNAL"
-
-
 }

spartan/terraform/deploy-aztec-infra/values/rpc.yaml

@@ -15,3 +15,4 @@ node:
   startCmd:
     - --node
     - --archiver
+    - --pxe

yarn-project/end-to-end/src/spartan/smoke.test.ts

@@ -5,7 +5,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { ChildProcess } from 'child_process';
 import { foundry } from 'viem/chains';
 
-import { isK8sConfig, setupEnvironment, startPortForward } from './utils.js';
+import { setupEnvironment, startPortForwardForPXE } from './utils.js';
 
 const config = setupEnvironment(process.env);
 
@@ -15,19 +15,12 @@ describe('smoke test', () => {
   let pxe: PXE;
   const forwardProcesses: ChildProcess[] = [];
   beforeAll(async () => {
-    let PXE_URL: string;
-    if (isK8sConfig(config)) {
-      const { process, port } = await startPortForward({
-        resource: `svc/${config.INSTANCE_NAME}-aztec-network-pxe`,
-        namespace: config.NAMESPACE,
-        containerPort: config.CONTAINER_PXE_PORT,
-      });
-      forwardProcesses.push(process);
-      PXE_URL = `http://127.0.0.1:${port}`;
-    } else {
-      PXE_URL = config.PXE_URL;
-    }
-    pxe = await createCompatibleClient(PXE_URL, debugLogger);
+    debugLogger.info('Starting port forward for PXE');
+    const { process, port } = await startPortForwardForPXE(config.NAMESPACE);
+    forwardProcesses.push(process);
+    const pxeUrl = `http://127.0.0.1:${port}`;
+
+    pxe = await createCompatibleClient(pxeUrl, debugLogger);
   });
 
   afterAll(() => {

yarn-project/end-to-end/src/spartan/utils.ts

@@ -2,91 +2,34 @@ import { createLogger, sleep } from '@aztec/aztec.js';
 import type { RollupCheatCodes } from '@aztec/aztec/testing';
 import type { Logger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
-import type { SequencerConfig } from '@aztec/sequencer-client';
-import { createAztecNodeAdminClient } from '@aztec/stdlib/interfaces/client';
+import { type AztecNodeAdminConfig, createAztecNodeAdminClient } from '@aztec/stdlib/interfaces/client';
 
 import { ChildProcess, exec, execSync, spawn } from 'child_process';
 import path from 'path';
 import { promisify } from 'util';
 import { z } from 'zod';
 
-import { AlertChecker, type AlertConfig } from '../quality_of_service/alert_checker.js';
+export const PXE_SERVICE_NAME = 'services/aztec-infra-rpc-aztec-node';
 
 const execAsync = promisify(exec);
 
 const logger = createLogger('e2e:k8s-utils');
 
-const ethereumHostsSchema = z.string().refine(
-  str =>
-    str.split(',').every(url => {
-      try {
-        new URL(url.trim());
-        return true;
-      } catch {
-        return false;
-      }
-    }),
-  'ETHEREUM_HOSTS must be a comma-separated list of valid URLs',
-);
-
-const k8sLocalConfigSchema = z.object({
-  ETHEREUM_SLOT_DURATION: z.coerce.number().min(1, 'ETHEREUM_SLOT_DURATION env variable must be set'),
-  AZTEC_SLOT_DURATION: z.coerce.number().min(1, 'AZTEC_SLOT_DURATION env variable must be set'),
-  AZTEC_EPOCH_DURATION: z.coerce.number().min(1, 'AZTEC_EPOCH_DURATION env variable must be set'),
-  AZTEC_PROOF_SUBMISSION_WINDOW: z.coerce.number().min(1, 'AZTEC_PROOF_SUBMISSION_WINDOW env variable must be set'),
-  AZTEC_REAL_PROOFS: z.string().default('false'),
-  INSTANCE_NAME: z.string().min(1, 'INSTANCE_NAME env variable must be set'),
+const testConfigSchema = z.object({
   NAMESPACE: z.string().min(1, 'NAMESPACE env variable must be set'),
-  CONTAINER_NODE_PORT: z.coerce.number().default(8080),
-  CONTAINER_NODE_ADMIN_PORT: z.coerce.number().default(8880),
-  CONTAINER_SEQUENCER_PORT: z.coerce.number().default(8080),
-  CONTAINER_PROVER_NODE_PORT: z.coerce.number().default(8080),
-  CONTAINER_PXE_PORT: z.coerce.number().default(8080),
-  CONTAINER_ETHEREUM_PORT: z.coerce.number().default(8545),
-  CONTAINER_METRICS_PORT: z.coerce.number().default(80),
-  GRAFANA_PASSWORD: z.string().optional(),
-  METRICS_API_PATH: z.string().default('/api/datasources/proxy/uid/spartan-metrics-prometheus/api/v1'),
-  SPARTAN_DIR: z.string().min(1, 'SPARTAN_DIR env variable must be set'),
-  ETHEREUM_HOSTS: ethereumHostsSchema.optional(),
   L1_ACCOUNT_MNEMONIC: z.string().default('test test test test test test test test test test test junk'),
-  SEPOLIA_RUN: z.string().default('false'),
-  K8S: z.literal('local'),
-});
-
-const k8sGCloudConfigSchema = k8sLocalConfigSchema.extend({
-  K8S: z.literal('gcloud'),
-  CLUSTER_NAME: z.string().min(1, 'CLUSTER_NAME env variable must be set'),
-  REGION: z.string().min(1, 'REGION env variable must be set'),
-  PROJECT_ID: z.string().min(1, 'PROJECT_ID env variable must be set'),
+  K8S_CLUSTER: z.string().min(1, 'K8S_CLUSTER env variable must be set'),
+  REGION: z.string().optional(),
+  PROJECT_ID: z.string().optional(),
 });
 
-const directConfigSchema = z.object({
-  PXE_URL: z.string().url('PXE_URL must be a valid URL'),
-  NODE_URL: z.string().url('NODE_URL must be a valid URL'),
-  NODE_ADMIN_URL: z.string().url('NODE_ADMIN_URL must be a valid URL'),
-  ETHEREUM_HOSTS: ethereumHostsSchema,
-  K8S: z.literal('false'),
-});
+export type TestConfig = z.infer<typeof testConfigSchema>;
 
-const envSchema = z.discriminatedUnion('K8S', [k8sLocalConfigSchema, k8sGCloudConfigSchema, directConfigSchema]);
-
-export type K8sLocalConfig = z.infer<typeof k8sLocalConfigSchema>;
-export type K8sGCloudConfig = z.infer<typeof k8sGCloudConfigSchema>;
-export type DirectConfig = z.infer<typeof directConfigSchema>;
-export type EnvConfig = z.infer<typeof envSchema>;
-
-export function isK8sConfig(config: EnvConfig): config is K8sLocalConfig | K8sGCloudConfig {
-  return config.K8S === 'local' || config.K8S === 'gcloud';
-}
+export function setupEnvironment(env: unknown): TestConfig {
+  const config = testConfigSchema.parse(env);
 
-export function isGCloudConfig(config: EnvConfig): config is K8sGCloudConfig {
-  return config.K8S === 'gcloud';
-}
-
-export function setupEnvironment(env: unknown): EnvConfig {
-  const config = envSchema.parse(env);
-  if (isGCloudConfig(config)) {
-    const command = `gcloud container clusters get-credentials ${config.CLUSTER_NAME} --region=${config.REGION} --project=${config.PROJECT_ID}`;
+  if (config.K8S_CLUSTER !== 'kind') {
+    const command = `gcloud container clusters get-credentials ${config.K8S_CLUSTER} --region=${config.REGION} --project=${config.PROJECT_ID}`;
     execSync(command);
   }
   return config;
@@ -212,6 +155,14 @@ export async function startPortForward({
   return { process, port };
 }
 
+export async function startPortForwardForPXE(namespace: string) {
+  return startPortForward({
+    resource: PXE_SERVICE_NAME,
+    namespace,
+    containerPort: 8080,
+  });
+}
+
 export async function deleteResourceByName({
   resource,
   namespace,
@@ -550,25 +501,7 @@ export async function enableValidatorDynamicBootNode(
   logger.info(`Validator dynamic boot node enabled`);
 }
 
-export async function runAlertCheck(config: EnvConfig, alerts: AlertConfig[], logger: Logger) {
-  if (isK8sConfig(config)) {
-    const { process, port } = await startPortForward({
-      resource: `svc/metrics-grafana`,
-      namespace: 'metrics',
-      containerPort: config.CONTAINER_METRICS_PORT,
-    });
-    const alertChecker = new AlertChecker(logger, {
-      grafanaEndpoint: `http://localhost:${port}${config.METRICS_API_PATH}`,
-      grafanaCredentials: `admin:${config.GRAFANA_PASSWORD}`,
-    });
-    await alertChecker.runAlertCheck(alerts);
-    process.kill();
-  } else {
-    logger.info('Not running alert check in non-k8s environment');
-  }
-}
-
-export async function updateSequencerConfig(url: string, config: Partial<SequencerConfig>) {
+export async function updateSequencerConfig(url: string, config: Partial<AztecNodeAdminConfig>) {
   const node = createAztecNodeAdminClient(url);
   // Retry incase the port forward is not ready yet
   await retry(() => node.setConfig(config), 'Update sequencer config', makeBackoff([1, 3, 6]), logger);
@@ -583,7 +516,7 @@ export async function getSequencers(namespace: string) {
 async function updateK8sSequencersConfig(args: {
   containerPort: number;
   namespace: string;
-  config: Partial<SequencerConfig>;
+  config: Partial<AztecNodeAdminConfig>;
 }) {
   const { containerPort, namespace, config } = args;
   const sequencers = await getSequencers(namespace);
@@ -600,17 +533,17 @@ async function updateK8sSequencersConfig(args: {
   }
 }
 
-export async function updateSequencersConfig(env: EnvConfig, config: Partial<SequencerConfig>) {
-  if (isK8sConfig(env)) {
-    await updateK8sSequencersConfig({
-      containerPort: env.CONTAINER_NODE_ADMIN_PORT,
-      namespace: env.NAMESPACE,
-      config,
-    });
-  } else {
-    await updateSequencerConfig(env.NODE_ADMIN_URL, config);
-  }
-}
+// export async function updateSequencersConfig(env: EnvConfig, config: Partial<AztecNodeAdminConfig>) {
+//   if (isK8sConfig(env)) {
+//     await updateK8sSequencersConfig({
+//       containerPort: env.CONTAINER_NODE_ADMIN_PORT,
+//       namespace: env.NAMESPACE,
+//       config,
+//     });
+//   } else {
+//     await updateSequencerConfig(env.NODE_ADMIN_URL, config);
+//   }
+// }
 
 /**
  * Rolls the Aztec pods in the given namespace.