Make Copilot Workspace output compile

Author: dandavison

Diff for: updates_and_signals/safe_message_handlers/src/activities.ts

@@ -1,33 +1,34 @@
-import { proxyActivities } from '@temporalio/workflow';
-import { ActivityInput as AllocateNodesToJobInput } from './interfaces';
+export interface AllocateNodesToJobInput {
+  nodes: string[];
+  jobName: string;
+}
 
-// Activities with TypeScript syntax and Temporal TypeScript SDK specifics
-const { allocateNodesToJob, deallocateNodesForJob, findBadNodes } = proxyActivities<{
-  allocateNodesToJob(input: AllocateNodesToJobInput): Promise<void>;
-  deallocateNodesForJob(input: DeallocateNodesForJobInput): Promise<void>;
-  findBadNodes(input: FindBadNodesInput): Promise<string[]>;
-}>({
-  startToCloseTimeout: '1 minute',
-});
+export interface DeallocateNodesForJobInput {
+  nodes: string[];
+  jobName: string;
+}
+
+export interface FindBadNodesInput {
+  nodesToCheck: string[];
+}
 
 export async function allocateNodesToJob(input: AllocateNodesToJobInput): Promise<void> {
   console.log(`Assigning nodes ${input.nodes} to job ${input.jobName}`);
-  await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async operation
+  await new Promise((resolve) => setTimeout(resolve, 100)); // Simulate async operation
 }
 
 export async function deallocateNodesForJob(input: DeallocateNodesForJobInput): Promise<void> {
   console.log(`Deallocating nodes ${input.nodes} from job ${input.jobName}`);
-  await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async operation
+  await new Promise((resolve) => setTimeout(resolve, 100)); // Simulate async operation
 }
 
 export async function findBadNodes(input: FindBadNodesInput): Promise<string[]> {
-  await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async operation
-  const badNodes = input.nodesToCheck.filter(n => parseInt(n) % 5 === 0);
+  await new Promise((resolve) => setTimeout(resolve, 100)); // Simulate async operation
+  const badNodes = input.nodesToCheck.filter((n) => parseInt(n) % 5 === 0);
   if (badNodes.length) {
     console.log(`Found bad nodes: ${badNodes}`);
   } else {
-    console.log("No new bad nodes found.");
+    console.log('No new bad nodes found.');
   }
   return badNodes;
 }
-

Diff for: updates_and_signals/safe_message_handlers/src/client.ts

@@ -0,0 +1,45 @@
+import { Connection, Client, WorkflowHandle } from '@temporalio/client';
+import * as workflow from './workflows';
+
+async function doClusterLifecycle(wf: WorkflowHandle, delaySeconds?: number): Promise<void> {
+  await wf.signal(workflow.startClusterSignal);
+
+  const allocationUpdates: Promise<any>[] = [];
+  for (let i = 0; i < 6; i++) {
+    allocationUpdates.push(
+      wf.executeUpdate(workflow.allocateNodesToJobUpdate, { args: [{ numNodes: 2, jobName: `task-${i}` }] })
+    );
+  }
+  await Promise.all(allocationUpdates);
+
+  if (delaySeconds) {
+    await new Promise((resolve) => setTimeout(resolve, delaySeconds * 1000));
+  }
+
+  const deletionUpdates: Promise<any>[] = [];
+  for (let i = 0; i < 6; i++) {
+    deletionUpdates.push(wf.executeUpdate(workflow.deleteJobUpdate, { args: [{ jobName: `task-${i}` }] }));
+  }
+  await Promise.all(deletionUpdates);
+
+  await wf.signal(workflow.shutdownClusterSignal);
+}
+async function main() {
+  const connection = await Connection.connect({ address: 'localhost:7233' });
+  const client = new Client({ connection });
+
+  // Define the workflow handle
+  const wfHandle = await client.workflow.start(workflow.clusterManagerWorkflow, {
+    args: [{ testContinueAsNew: true }],
+    taskQueue: 'tq',
+    workflowId: 'cluster-management-workflow',
+  });
+
+  // Start the cluster lifecycle
+  await doClusterLifecycle(wfHandle);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

Diff for: updates_and_signals/safe_message_handlers/src/starter.ts

@@ -3,8 +3,7 @@ import path from 'path';
 
 async function run() {
   const worker = await Worker.create({
-    workflowsPath: path.join(__dirname, './workflows'),
-    activitiesPath: path.join(__dirname, './activities'),
+    workflowsPath: path.join(__dirname, './workflows.ts'),
     taskQueue: 'safe-message-handlers-task-queue',
   });
 

Diff for: updates_and_signals/safe_message_handlers/src/worker.ts

@@ -0,0 +1,124 @@
+// This file contains the TypeScript port of the Python workflow for managing cluster updates and signals
+
+import {
+  proxyActivities,
+  defineSignal,
+  defineUpdate,
+  defineQuery,
+  setHandler,
+  condition,
+  sleep,
+} from '@temporalio/workflow';
+import type * as activities from './activities';
+
+interface ClusterManagerState {
+  clusterStarted: boolean;
+  clusterShutdown: boolean;
+  nodes: { [key: string]: string | null };
+  jobsAdded: Set<string>;
+  maxAssignedNodes: number;
+}
+
+interface ClusterManagerInput {
+  state?: ClusterManagerState;
+  testContinueAsNew: boolean;
+}
+
+interface ClusterManagerResult {
+  maxAssignedNodes: number;
+  numCurrentlyAssignedNodes: number;
+  numBadNodes: number;
+}
+
+export interface AllocateNodesToJobInput {
+  numNodes: number;
+  jobName: string;
+}
+
+interface DeleteJobInput {
+  jobName: string;
+}
+
+export interface ClusterManagerWorkflowInput {
+  testContinueAsNew: boolean;
+}
+
+export interface ClusterManagerWorkflowResult {
+  maxAssignedNodes: number;
+  numCurrentlyAssignedNodes: number;
+  numBadNodes: number;
+}
+
+// Message-handling API
+export const startClusterSignal = defineSignal('startCluster');
+export const shutdownClusterSignal = defineSignal('shutdownCluster');
+export const allocateNodesToJobUpdate = defineUpdate<string[], [AllocateNodesToJobInput]>('allocateNodesToJob');
+export const deleteJobUpdate = defineUpdate<void, [DeleteJobInput]>('deleteJob');
+const getClusterStatusQuery = defineQuery<{}>('getClusterStatus');
+
+// Activities
+const { allocateNodesToJob, deallocateNodesForJob, findBadNodes } = proxyActivities<typeof activities>({
+  startToCloseTimeout: '1 minute',
+});
+
+export async function clusterManagerWorkflow(input: ClusterManagerWorkflowInput) {
+  let state = {
+    clusterStarted: false,
+    clusterShutdown: false,
+    nodes: {} as Record<string, string | null>,
+    jobsAdded: new Set<string>(),
+    maxAssignedNodes: 0,
+  };
+
+  // Signal handlers
+  setHandler(startClusterSignal, () => {
+    state.clusterStarted = true;
+    for (let i = 0; i < 25; i++) {
+      state.nodes[i.toString()] = null;
+    }
+  });
+
+  setHandler(shutdownClusterSignal, () => {
+    state.clusterShutdown = true;
+  });
+
+  setHandler(allocateNodesToJobUpdate, async (input: AllocateNodesToJobInput): Promise<string[]> => {
+    if (!state.clusterStarted || state.clusterShutdown) {
+      throw new Error('Cluster is not in a valid state for node allocation');
+    }
+    // Allocate nodes to job logic
+    return [];
+  });
+
+  setHandler(deleteJobUpdate, async (input: DeleteJobInput) => {
+    if (!state.clusterStarted || state.clusterShutdown) {
+      throw new Error('Cluster is not in a valid state for node deallocation');
+    }
+    // Deallocate nodes from job logic
+  });
+
+  // Query handler
+  setHandler(getClusterStatusQuery, () => {
+    return {
+      clusterStarted: state.clusterStarted,
+      clusterShutdown: state.clusterShutdown,
+      numNodes: Object.keys(state.nodes).length,
+      numAssignedNodes: Object.values(state.nodes).filter((n) => n !== null).length,
+    };
+  });
+
+  // Main workflow logic
+  await condition(() => state.clusterStarted, 'Waiting for cluster to start');
+  // Perform operations while cluster is active
+  while (!state.clusterShutdown) {
+    // Example: perform periodic health checks
+    await sleep(60000); // Sleep for 60 seconds
+  }
+
+  // Return workflow result
+  return {
+    maxAssignedNodes: state.maxAssignedNodes,
+    numCurrentlyAssignedNodes: Object.values(state.nodes).filter((n) => n !== null).length,
+    numBadNodes: Object.values(state.nodes).filter((n) => n === 'BAD').length,
+  };
+}