feat: implement cancelAllPipelines for CI providers

src/api/azure/services/azure-pipeline.service.ts

@@ -168,6 +168,41 @@ export class AzurePipelineService {
     }
   }
 
+  public async cancelBuild(buildId: number): Promise<void> {
+    try {
+      await retry(
+        async () => {
+          await this.client.patch(
+            `${this.project}/_apis/build/builds/${buildId}?${this.getApiVersionParam()}`,
+            { status: 'cancelling' }
+          );
+        },
+        {
+          retries: 3,
+          minTimeout: 1000,
+          maxTimeout: 5000,
+          onRetry: (error: Error, attempt: number) => {
+            console.log(`[Azure] Retry ${attempt}/3 - Cancelling build ${buildId}: ${error.message}`);
+          },
+        }
+      );
+
+      console.log(`[Azure] Successfully cancelled build ${buildId}`);
+    } catch (error: any) {
+      // Handle specific error cases
+      if (error.response?.status === 404) {
+        throw new Error(`Build ${buildId} not found`);
+      }
+      if (error.response?.status === 403) {
+        throw new Error(`Insufficient permissions to cancel build ${buildId}`);
+      }
+      if (error.response?.status === 400) {
+        throw new Error(`Build ${buildId} cannot be cancelled (already completed or not cancellable)`);
+      }
+      throw new Error(`Failed to cancel build ${buildId}: ${error.message}`);
+    }
+  }
+
   public async getAllPipelines(): Promise<AzurePipelineDefinition[]> {
     try {
       const pipelines = await this.client.get<{ value: AzurePipelineDefinition[] }>(

src/api/github/services/github-actions.service.ts

@@ -590,4 +590,74 @@ export class GithubActionsService {
       throw new GithubApiError(`Error finding workflow run for commit ${sha.substring(0, 7)}`, error.status, error);
     }
   }
+
+  /**
+   * Cancel a workflow run
+   * 
+   * @param owner Repository owner
+   * @param repo Repository name
+   * @param runId Workflow run ID to cancel
+   * @returns Promise resolving when the workflow run is cancelled
+   * @throws GithubNotFoundError if the workflow run is not found
+   * @throws GithubApiError for other API errors
+   */
+  async cancelWorkflowRun(
+    owner: string,
+    repo: string,
+    runId: number
+  ): Promise<void> {
+    try {
+      await retry(
+        async () => {
+          await this.octokit.actions.cancelWorkflowRun({
+            owner,
+            repo,
+            run_id: runId,
+          });
+        },
+        {
+          retries: this.maxRetries,
+          minTimeout: this.minTimeout,
+          maxTimeout: this.maxTimeout,
+          factor: this.factor,
+          onRetry: (error: Error, attempt: number) => {
+            console.log(
+              `[GitHub Actions] Retry ${attempt}/${this.maxRetries} - Cancelling workflow run ${runId}: ${error.message}`
+            );
+          },
+        }
+      );
+
+      console.log(`[GitHub Actions] Successfully cancelled workflow run ${runId}`);
+    } catch (error: any) {
+      // Handle specific error cases
+      if (error.status === 404) {
+        throw new GithubNotFoundError(
+          'workflow run',
+          `${runId} in repository ${owner}/${repo}`
+        );
+      }
+
+      if (error.status === 403) {
+        throw new GithubApiError(
+          `Insufficient permissions to cancel workflow run ${runId}`,
+          error.status
+        );
+      }
+
+      if (error.status === 409) {
+        throw new GithubApiError(
+          `Workflow run ${runId} cannot be cancelled (already completed or not cancellable)`,
+          error.status
+        );
+      }
+
+      // Re-throw with more context
+      throw new GithubApiError(
+        `Failed to cancel workflow run ${runId}: ${error.message}`,
+        error.status || 500,
+        error
+      );
+    }
+  }
 }

src/api/jenkins/services/jenkins-build.service.ts

@@ -165,6 +165,25 @@ export class JenkinsBuildService {
     }
   }
 
+  /**
+   * Stop/abort a running build
+   */
+  async stopBuild(jobName: string, buildNumber: number, folderName?: string): Promise<void> {
+    try {
+      const path = JenkinsPathBuilder.buildBuildPath(
+        jobName,
+        buildNumber,
+        folderName,
+        'stop'
+      );
+
+      await this.httpClient.post(path, null);
+    } catch (error) {
+      // If build is not found or already stopped, throw specific error
+      throw new JenkinsBuildNotFoundError(jobName, buildNumber, folderName);
+    }
+  }
+
   /**
    * Wait for a build to complete with timeout
    */

src/api/ocp/kubeClient.ts

@@ -265,6 +265,37 @@ export class KubeClient {
     }
   }
 
+  /**
+   * Generic method to patch a resource with proper error handling
+   *
+   * @template T The resource type to return
+   * @param {K8sApiOptions} options - API options for the request (must include name)
+   * @param {any} patchData - The patch data to apply
+   * @returns {Promise<T>} The patched resource of type T
+   */
+  public async patchResource<T>(options: K8sApiOptions, patchData: any): Promise<T> {
+    try {
+      if (!options.name) {
+        throw new Error('Resource name is required for patchResource');
+      }
+
+      const response = await this.customApi.patchNamespacedCustomObject({
+        group: options.group,
+        version: options.version,
+        namespace: options.namespace,
+        plural: options.plural,
+        name: options.name,
+        body: patchData,
+      });
+      return response as T;
+    } catch (error) {
+      console.error(
+        `Error patching resource '${options.name}' in namespace '${options.namespace}': ${error}`
+      );
+      throw new Error(`Failed to patch resource '${options.name}': ${error}`);
+    }
+  }
+
   /**
    * Retrieves logs from a pod or specific containers within a pod
    * @param podName The name of the pod

src/api/tekton/services/tekton-pipelinerun.service.ts

@@ -191,6 +191,36 @@ export class TektonPipelineRunService {
     }
   }
 
+  /**
+   * Cancel a running PipelineRun by patching its spec
+   */
+  public async cancelPipelineRun(namespace: string, name: string): Promise<void> {
+    try {
+      const options = this.kubeClient.createApiOptions(
+        this.API_GROUP,
+        this.API_VERSION,
+        this.PIPELINE_RUNS_PLURAL,
+        namespace,
+        { name }
+      );
+
+      // Patch the PipelineRun to set status to cancelled
+      const patchData = {
+        spec: {
+          status: 'PipelineRunCancelled'
+        }
+      };
+
+      await this.kubeClient.patchResource(options, patchData);
+
+      console.log(`Successfully cancelled PipelineRun: ${name} in namespace: ${namespace}`);
+    } catch (error: unknown) {
+      const errorMessage = (error as Error).message;
+      console.error(`Failed to cancel PipelineRun ${name}: ${errorMessage}`);
+      throw new Error(`Failed to cancel PipelineRun ${name}: ${errorMessage}`);
+    }
+  }
+
   private findPipelineRunByEventType(
     pipelineRuns: PipelineRunKind[],
     eventType: string,

src/api/tekton/tekton.client.ts

@@ -45,6 +45,10 @@ export class TektonClient {
     return this.pipelineRunService.getPipelineRunLogs(namespace, pipelineRunName);
   }
 
+  public async cancelPipelineRun(namespace: string, name: string): Promise<void> {
+    return this.pipelineRunService.cancelPipelineRun(namespace, name);
+  }
+
   public get pipelineRuns(): TektonPipelineRunService {
     return this.pipelineRunService;
   }

src/rhtap/core/integration/ci/baseCI.ts

@@ -1,6 +1,14 @@
 import { PullRequest } from '../git/models';
 import { KubeClient } from './../../../../../src/api/ocp/kubeClient';
-import { CI, CIType, EventType, Pipeline, PipelineStatus } from './ciInterface';
+import {
+  CI,
+  CIType,
+  EventType,
+  Pipeline,
+  PipelineStatus,
+  CancelPipelineOptions,
+  CancelResult,
+} from './ciInterface';
 import retry from 'async-retry';
 
 /**
@@ -118,7 +126,16 @@ export abstract class BaseCI implements CI {
 
   public abstract waitForAllPipelineRunsToFinish(): Promise<void>;
 
-  public abstract cancelAllInitialPipelines(): Promise<void>;
+  /**
+   * Abstract method for cancelling all pipelines
+   * Must be implemented by each provider
+   *
+   * @param options Optional configuration for filtering and behavior
+   * @returns Promise resolving to detailed cancellation results
+   */
+  public abstract cancelAllPipelines(
+    options?: CancelPipelineOptions
+  ): Promise<CancelResult>;
 
   public abstract getWebhookUrl(): Promise<string>;