New command to check status of broker operation.

Author: dishantlangayan

package-lock.json

@@ -11,7 +11,9 @@
     "@oclif/core": "^4",
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-plugins": "^5",
+    "@types/cli-progress": "^3.11.6",
     "axios": "^1.9.0",
+    "cli-progress": "^3.12.0",
     "table": "^6.9.0"
   },
   "devDependencies": {

package.json

@@ -0,0 +1,127 @@
+import { Flags } from '@oclif/core'
+import cliProgress from 'cli-progress'
+
+import { ScCommand } from '../../../sc-command.js'
+import { EventBrokerListApiResponse, OperationData, OperationResponse } from '../../../types/broker.js'
+import { ScConnection } from '../../../util/sc-connection.js'
+import { camelCaseToTitleCase, renderKeyValueTable, sleep } from '../../../util/internal.js'
+
+export default class MissionctrlBrokerOpstatus extends ScCommand<typeof MissionctrlBrokerOpstatus> {
+  static override args = {}
+  static override description = `Get the status of an operation that being performed on an event broker service. 
+  To get the operation, you provide identifier of the operation and the identifier of the event broker service.
+
+  Token Permissions: [ mission_control:access or services:get or services:get:self or services:view or services:view:self ]`
+  static override examples = [
+    '<%= config.bin %> <%= command.id %>',
+  ]
+  static override flags = {
+    'broker-id': Flags.string({
+      char: 'b',
+      description: 'Id of the event broker service.',
+      exactlyOne: ['broker-id', 'name'],
+    }),
+    name: Flags.string({
+      char: 'n',
+      description: 'Name of the event broker service.',
+      exactlyOne: ['broker-id', 'name'],
+    }),
+    'operation-id': Flags.string({
+      char: 'o',
+      description: 'The identifier of the operation being performed on the event broker service.'
+    }),
+    'show-progress': Flags.boolean({
+      char: 'p',
+      description: 'Displays a status bar of the in-progress operation. The command will wait for completion of each step of the operation.'
+    }),
+    'wait-ms': Flags.integer({
+      char: 'w',
+      description: 'The milliseconds to wait between API call in when showing progress. Default is 5000 ms.'
+    }),
+  }
+
+  public async run(): Promise<OperationData> {
+    const { flags } = await this.parse(MissionctrlBrokerOpstatus)
+
+    const name = flags.name ?? ''
+    let brokerId = flags['broker-id'] ?? ''
+    const operationId = flags['operation-id'] ?? ''
+    const showProgress = flags['show-progress'] ?? false
+    const waitMs = flags['wait-ms'] ?? 5000
+
+    const conn = new ScConnection()
+
+    // API url
+    let apiUrl: string = `/missionControl/eventBrokerServices`
+
+    // If broker name provided, retrieve the broker service id first
+    // then retrieve the operation status using the id
+    if (name) {
+      // API call to get broker by name
+      apiUrl += `?customAttributes=name=="${name}"`
+      const resp = await conn.get<EventBrokerListApiResponse>(apiUrl)
+      // TODO FUTURE: show status of multiple brokers operations that match the name 
+      if (resp.data.length > 1) {
+        this.error(`Multiple broker services found with: ${name}. Exactly one broker service must match the provided name.`)
+      } else {
+        brokerId = resp.data[0]?.id
+      }
+    }
+
+    // API call to retrieve status of the broker operation
+    apiUrl = `/missionControl/eventBrokerServices/${brokerId}/operations/${operationId}`
+    if (showProgress) {
+      apiUrl += '?expand=progressLogs'
+    }
+    let resp = await conn.get<OperationResponse>(apiUrl)
+    this.print(resp.data)
+
+    // Display progress bar for each step included in the progress logs
+    // Enable progress bar if set
+    if (showProgress && resp.data.progressLogs && resp.data.progressLogs.length > 0) {
+      let progressLogs = resp.data.progressLogs
+      let numSteps = progressLogs.length
+
+      // Create a new progress bar instance and use shades_classic theme
+      const progressBar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
+
+      // start the progress bar with a total value of size of the steps and start value of 0
+      progressBar.start(numSteps, 0);
+
+      // Update the progress with the steps completed
+      let completedNumSteps = 0
+      while (completedNumSteps < numSteps) {
+        // Wait before making the next API call
+        await sleep(waitMs)
+        // Make another API call to get the lastest progress
+        resp = await conn.get<OperationResponse>(apiUrl)
+        if (resp.data.progressLogs) {
+          progressLogs = resp.data.progressLogs
+          for (const progressLog of progressLogs) {
+            if (progressLog.step === 'success') {
+              completedNumSteps++
+            }
+          }
+          // Update progress bar
+          progressBar.update(completedNumSteps)
+        } else {
+          break
+        }
+      }
+
+      // stop the progress bar
+      progressBar.stop()
+    }
+
+    return resp.data
+  }
+
+  private print(environment: OperationData): void {
+    const tableRows = [
+      ['Key', 'Value'],
+      ...Object.entries(environment).map(([key, value]) => [camelCaseToTitleCase(key), value]),
+    ]
+    this.log()
+    this.log(renderKeyValueTable(tableRows))
+  }
+}

src/commands/missionctrl/broker/opstatus.ts

@@ -61,4 +61,32 @@ export interface EventBrokerServiceDetail {
   ownedBy?: string
   serviceClassId?: string
   type?: string
+}
+
+/**
+ * For Broker Operation Status
+ */
+export interface OperationResponse {
+  data: OperationData;
+}
+
+export interface OperationData {
+  completedTime: string; // ISO timestamp
+  createdBy: string;
+  createdTime: string; // ISO timestamp
+  id: string;
+  operationType: string;
+  progressLogs?: ProgressLog[];
+  resourceId: string;
+  resourceType: string;
+  status: string;
+  type: "operation";
+}
+
+export interface ProgressLog {
+  message: string;
+  status: string;
+  step: string;
+  stepId: string;
+  timestamp: string; // ISO timestamp
 }

src/types/broker.ts

@@ -47,4 +47,13 @@ export function renderKeyValueTable<T>(
     }
     const tableStr = table(data, tableConfig)
     return tableStr
+}
+
+/**
+ * Sleep function.
+ * @param ms Num of milliseconds to wait
+ * @returns 
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
 }

src/util/internal.ts

@@ -0,0 +1,42 @@
+import { runCommand } from '@oclif/test'
+import { expect } from 'chai'
+import * as sinon from 'sinon'
+
+import { camelCaseToTitleCase, renderKeyValueTable } from '../../../../src/util/internal.js'
+import { ScConnection } from '../../../../src/util/sc-connection.js'
+import { createTestOperationResponse, setEnvVariables } from '../../../util/test-utils.js'
+
+describe('missionctrl:broker:opstatus', () => {
+  setEnvVariables()
+  const brokerName: string = 'MyTestBroker'
+  const brokerId: string = 'MyTestBrokerId'
+  const operationId: string = 'MyOperationId'
+  let scConnStub: sinon.SinonStub
+
+  beforeEach(() => {
+    scConnStub = sinon.stub(ScConnection.prototype, 'get')
+  })
+
+  afterEach(() => {
+    scConnStub.restore()
+  })
+
+  it('runs missionctrl:broker:opstatus cmd', async () => {
+    const { stdout } = await runCommand('missionctrl:broker:opstatus')
+    expect(stdout).to.contain('')
+  })
+
+  it(`runs missionctrl:broker:opstatus -b ${brokerId}`, async () => {
+    // Arrange
+    let opsResponse = createTestOperationResponse(brokerId, 5, operationId, 'in-progress')
+    scConnStub.returns(Promise.resolve(opsResponse))
+
+    const tableRows = [
+      ['Key', 'Value'],
+      ...Object.entries(opsResponse.data).map(([key, value]) => [camelCaseToTitleCase(key), value]),
+    ]
+
+    const { stdout } = await runCommand(`missionctrl:broker:opstatus -b ${brokerId}`)
+    expect(stdout).to.contain(renderKeyValueTable(tableRows))
+  })
+})

test/commands/missionctrl/broker/opstatus.test.ts

@@ -1,3 +1,5 @@
+import { ProgressLog, OperationResponse } from "../../src/types/broker"
+
 export function setEnvVariables(): void {
   process.env.SC_ACCESS_TOKEN = 'TEST'
 }
@@ -32,4 +34,37 @@ export function aBroker(brokerId: string, brokerName: string,) {
     status: '',
     type: '',
   }
+}
+
+export function createTestOperationResponse(brokerId: string, numSteps: number, operationId: string, status: string): OperationResponse {
+  const opsResp: OperationResponse = {
+    data: {
+      completedTime: '2025-08-02T16:29:34Z',
+      createdBy: '67tr8tku4l',
+      createdTime: '2025-08-02T16:26:40Z',
+      id: operationId,
+      operationType: 'createService',
+      progressLogs: createTestProgressLogs(numSteps, status),
+      resourceId: brokerId,
+      resourceType: 'service',
+      status: status,
+      type: "operation"
+    }
+  }
+  return opsResp
+}
+
+export function createTestProgressLogs(numSteps: number, status: string): ProgressLog[] {
+  let progressLogs: ProgressLog[] = []
+  for (let i = 0; i < numSteps; i++) {
+    const progressLog: ProgressLog = {
+      message: 'This is a decription for the step',
+      status,
+      step: `This is step number ${i}`,
+      stepId: `${i}`,
+      timestamp: '025-08-02T16:26:41.272Z',
+    }
+    progressLogs.push(progressLog)
+  }
+  return progressLogs
 }