Wait for master (#215)

* Add initial implementation of blocking target branch build functionality

* Remove raw error logging to prevent auth header leakage

* Cache the blocking build pipeline API calls

* Merge blocking build changes
- Updated admin workflow to enable feature toggling
- Minor UI changes
- Added unit tests

* [chore] Addressed review comments

---------

Co-authored-by: Michael Blaszczyk <[email protected]>
Co-authored-by: Grace <[email protected]>

Author: GraceDmello

config.example.js

@@ -52,7 +52,29 @@ module.exports = {
      */
   },
   mergeSettings: {
-    skipBuildOnDependentsAwaitingMerge: false,
+    skipBuildOnDependentsAwaitingMerge: true,
+    mergeBlocking: {
+      enabled: false,
+      builds: [
+        {
+          targetBranch: 'master',
+          pipelineFilterFn: (pipelines) => {
+            return (
+              pipelines
+                .filter(
+                  (pipeline) =>
+                    pipeline.state.name === 'IN_PROGRESS' || pipeline.state.name === 'PENDING',
+                )
+                // Filter to only default builds run on 'push'.
+                // Allow manual trigger of default builds but exclude custom builds that are triggered manually
+                .filter(
+                  (job) => job.trigger.name !== 'SCHEDULE' && job.target.selector.type !== 'custom',
+                )
+            );
+          },
+        },
+      ],
+    },
   },
   eventListeners: [
     {

package.json

@@ -106,9 +106,11 @@
     "express": "^4.16.2",
     "express-session": "^1.17.1",
     "express-winston": "^3.0.1",
+    "mem": "^8",
     "micromatch": "^4.0.2",
     "mime": "^3.0.0",
     "p-limit": "^3.1.0",
+    "p-retry": "^4",
     "passport": "^0.4.1",
     "passport-http": "^0.3.0",
     "passport-oauth2": "^1.5.0",

src/bitbucket/BitbucketClient.ts

@@ -156,4 +156,49 @@ export class BitbucketClient {
   getUser(aaid: string): Promise<ISessionUser> {
     return this.bitbucket.getUser(aaid);
   }
+
+  async isBlockingBuildRunning(targetBranch: string): Promise<{
+    running: boolean;
+    pipelines?: BB.Pipeline[];
+  }> {
+    const notRunning = {
+      running: false,
+    };
+    const mergeBlockingConfig = this.config.mergeSettings?.mergeBlocking;
+    if (!mergeBlockingConfig?.enabled) {
+      Logger.error('Attempting to check merge blocking build with disabled config', {
+        targetBranch,
+      });
+      return notRunning;
+    }
+
+    const blockingBuildConfig = mergeBlockingConfig.builds.find(
+      (buildConfig) => buildConfig.targetBranch === targetBranch,
+    );
+    if (!blockingBuildConfig) {
+      Logger.info('No blocking build configured for target branch', {
+        targetBranch,
+      });
+      return notRunning;
+    }
+
+    const pipelinesResult = await this.pipelines.getPipelines({
+      // Fetching last 30 builds should be more than sufficient for finding the latest in-progress build
+      pagelen: 30,
+      // get the most recent builds first
+      sort: '-created_on',
+      'target.ref_name': blockingBuildConfig.targetBranch,
+      'target.ref_type': 'BRANCH',
+    });
+
+    const blockingBuild = blockingBuildConfig.pipelineFilterFn(pipelinesResult.values);
+    if (blockingBuild.length === 0) {
+      return notRunning;
+    } else {
+      return {
+        running: true,
+        pipelines: blockingBuild,
+      };
+    }
+  }
 }

src/bitbucket/BitbucketPipelinesAPI.ts

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { fromMethodAndPathAndBody, fromMethodAndUrl } from 'atlassian-jwt';
+import pRetry from 'p-retry';
 
 import { Logger } from '../lib/Logger';
 import { RepoConfig } from '../types';
@@ -147,6 +148,43 @@ export class BitbucketPipelinesAPI {
     return true;
   };
 
+  public getPipelines = async (queryParams: BB.QueryParams = {}, numRetries = 3) => {
+    const endpoint = `${this.apiBaseUrl}/pipelines/?${+new Date()}`;
+    const paramsWithAuth = await bitbucketAuthenticator.getAuthConfig(
+      fromMethodAndUrl('get', endpoint),
+      {
+        params: queryParams,
+      },
+    );
+    async function fetchPipelines() {
+      const response = await axios.get<BB.PaginatedResponse<BB.Pipeline>>(endpoint, paramsWithAuth);
+      return response?.data;
+    }
+
+    const data = await pRetry(fetchPipelines, {
+      onFailedAttempt: (error) => {
+        const anyError: any = error;
+        Logger.error('Error fetching pipelines', {
+          namespace: 'bitbucket:pipelines:getPipelines',
+          attemptNumber: error.attemptNumber,
+          retriesLeft: error.retriesLeft,
+          queryParams,
+          errorString: String(error),
+          errorStack: String(error.stack),
+          error: anyError.response ? [anyError.response.status, anyError.response.data] : null,
+        });
+      },
+      retries: numRetries,
+    });
+
+    Logger.info('Successfully fetched pipelines', {
+      namespace: 'bitbucket:pipelines:getPipelines',
+      queryParams,
+    });
+
+    return data;
+  };
+
   getLandBuild = async (buildId: Number): Promise<BB.Pipeline> => {
     const endpoint = `${this.apiBaseUrl}/pipelines/${buildId}`;
     const { data } = await axios.get<BB.Pipeline>(

src/bitbucket/__mocks__/BitbucketPipelinesAPI.ts

@@ -0,0 +1,15 @@
+const MockedApi: any = jest.genMockFromModule('../BitbucketPipelinesAPI');
+
+export const BitbucketPipelinesAPI = jest.fn().mockImplementation((...args) => {
+  const api = new MockedApi.BitbucketPipelinesAPI(...args);
+
+  // Properties are not auto mocked by jest
+  // TODO: Convert class to use standard class methods so they are auto mocked
+  api.processStatusWebhook = jest.fn();
+  api.createLandBuild = jest.fn();
+  api.stopLandBuild = jest.fn();
+  api.getPipelines = jest.fn();
+  api.getLandBuild = jest.fn();
+
+  return api;
+});

src/bitbucket/__tests__/BitbucketClient.test.ts

@@ -0,0 +1,65 @@
+import { BitbucketClient } from '../BitbucketClient';
+
+jest.mock('../../lib/Config');
+jest.mock('../BitbucketPipelinesAPI');
+jest.mock('../BitbucketAPI');
+
+const mockConfig = {
+  repoConfig: { repoName: 'repo', repoOwner: 'owner' },
+  mergeSettings: {
+    mergeBlocking: {
+      enabled: true,
+      builds: [
+        {
+          targetBranch: 'master',
+          pipelineFilterFn: (pipelines: any[]) =>
+            pipelines.filter(({ state }) => state === 'IN_PROGRESS'),
+        },
+      ],
+    },
+  },
+};
+
+describe('BitbucketClient', () => {
+  let client: BitbucketClient;
+  beforeEach(() => {
+    client = new BitbucketClient(mockConfig as any);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('isBlockingBuildRunning', () => {
+    test('should return notRunning if targetBranch is not configured', async () => {
+      const { running } = await client.isBlockingBuildRunning('develop');
+      expect(running).toBe(false);
+    });
+
+    test('should return notRunning if blocking build is not running', async () => {
+      jest.spyOn((client as any).pipelines, 'getPipelines').mockResolvedValueOnce({
+        values: [
+          {
+            state: 'COMPLETED',
+          },
+        ],
+      } as any);
+
+      const { running } = await client.isBlockingBuildRunning('master');
+      expect(running).toBe(false);
+    });
+
+    test('should return running if blocking build is running', async () => {
+      jest.spyOn((client as any).pipelines, 'getPipelines').mockResolvedValueOnce({
+        values: [
+          {
+            state: 'IN_PROGRESS',
+          },
+        ],
+      } as any);
+
+      const { running } = await client.isBlockingBuildRunning('master');
+      expect(running).toBe(true);
+    });
+  });
+});

src/bitbucket/__tests__/BitbucketPipelinesAPI.test.ts

@@ -1,6 +1,7 @@
 import axios from 'axios';
 import { BitbucketPipelinesAPI } from '../BitbucketPipelinesAPI';
 import { bitbucketAuthenticator } from '../BitbucketAuthenticator';
+import { Logger } from '../../lib/Logger';
 
 jest.mock('axios');
 const mockedAxios = axios as unknown as jest.Mocked<typeof axios>;
@@ -34,4 +35,43 @@ describe('BitbucketPipelinesAPI', () => {
       {},
     );
   });
+
+  describe('getPipelines', () => {
+    let loggerSpy: jest.SpyInstance;
+    beforeEach(() => {
+      loggerSpy = jest.spyOn(Logger, 'error');
+    });
+    test('should return successful response without retries', async () => {
+      mockedAxios.get.mockResolvedValueOnce({ data: 'data' });
+      const response = await bitbucketPipelineAPI.getPipelines({
+        pagelen: 30,
+      });
+      expect(response).toBe('data');
+    });
+
+    test('should return successful response with retries', async () => {
+      mockedAxios.get
+        .mockRejectedValueOnce(new Error('error'))
+        .mockResolvedValueOnce({ data: 'data' });
+      const response = await bitbucketPipelineAPI.getPipelines({
+        pagelen: 30,
+      });
+      expect(loggerSpy).toBeCalledTimes(1);
+      expect(response).toBe('data');
+    });
+
+    test('should fail after all retries', async () => {
+      mockedAxios.get
+        .mockRejectedValueOnce(new Error('error'))
+        .mockRejectedValueOnce(new Error('error'));
+      const response = await bitbucketPipelineAPI.getPipelines(
+        {
+          pagelen: 30,
+        },
+        2,
+      );
+      expect(loggerSpy).toBeCalledTimes(2);
+      expect(response).toBeUndefined();
+    });
+  });
 });

src/bitbucket/types.d.ts

@@ -151,7 +151,94 @@ declare namespace BB {
     url: string;
   };
 
-  type Pipeline = {
-    state: { result: { name: BuildState } };
+  interface PipelineTarget {
+    type: 'pipeline_commit_target' | 'pipeline_ref_target' | 'pipeline_pullrequest_target';
+    selector:
+      | { type: 'default' }
+      | {
+          type: 'custom';
+          pattern: string;
+        }
+      | {
+          type: 'branches';
+          pattern: string;
+        }
+      | {
+          type: 'pull-requests';
+          pattern: string;
+        };
+    commit: {
+      type: 'commit';
+      hash: string;
+    };
+    ref_type?: string;
+    ref_name?: string;
+  }
+
+  type PendingState = {
+    name: 'PENDING';
+  };
+
+  type InprogressState = {
+    name: 'INPROGRESS';
+  };
+
+  type CompletedState = {
+    name: 'COMPLETED';
+    result: {
+      name: 'SUCCESSFUL' | 'FAILED' | 'STOPPED';
+    };
+  };
+
+  interface PipelineBase {
+    uuid: string;
+    repository: { [key: string]: any };
+    state: PendingState | InprogressState | CompletedState;
+    build_number: string;
+    creator: { [key: string]: any };
+    created_on: string;
+    completed_on?: string;
+    target: PipelineTarget;
+    trigger: any;
+    run_number: number;
+    duration_in_seconds: number;
+    build_seconds_used: number;
+    first_successful: boolean;
+    expired: boolean;
+    links: SelfLink & StepLink;
+    has_variables: boolean;
+  }
+
+  interface InprogressPipeline extends PipelineBase {
+    state: InprogressState;
+  }
+
+  interface CompletedPipeline extends PipelineBase {
+    state: CompletedState;
+    completed_on: string;
+  }
+
+  interface PendingPipeline extends PipelineBase {
+    state: PendingState;
+  }
+
+  type Pipeline = InprogressPipeline | CompletedPipeline | PendingPipeline;
+
+  type PaginatedResponse<T> = {
+    size: number;
+    page: number;
+    pagelen: number;
+    // URI
+    next?: string;
+    // URI
+    previous?: string;
+    values: T[];
+  };
+
+  type QueryParams = {
+    pagelen?: number;
+    sort?: string;
+    'target.ref_name'?: string;
+    'target.ref_type'?: 'BRANCH';
   };
 }

src/db/__mocks__/index.ts

@@ -34,4 +34,5 @@ export const PauseState = MockedDb.PauseState;
 export const BannerMessageState = MockedDb.BannerMessageState;
 export const ConcurrentBuildState = MockedDb.ConcurrentBuildState;
 export const PriorityBranch = MockedDb.PriorityBranch;
+export const AdminSettings = MockedDb.AdminSettings;
 export const initializeSequelize = MockedDb.initializeSequelize;