remove exp show and plots diff retry when git repo has no commits

extension/src/cli/constants.ts

@@ -2,6 +2,8 @@ export const MIN_CLI_VERSION = '2.11.0'
 export const LATEST_TESTED_CLI_VERSION = '2.13.0'
 export const MAX_CLI_VERSION = '3'
 
+export const EMPTY_REPO_ERROR = 'unexpected error - Empty git repo'
+
 export enum Command {
   ADD = 'add',
   CHECKOUT = 'checkout',

extension/src/cli/reader.test.ts

@@ -2,7 +2,8 @@ import { join } from 'path'
 import { EventEmitter } from 'vscode'
 import { Disposable, Disposer } from '@hediet/std/disposable'
 import { CliResult, CliStarted } from '.'
-import { CliReader } from './reader'
+import { EMPTY_REPO_ERROR } from './constants'
+import { CliReader, ExperimentsOutput } from './reader'
 import { createProcess } from '../processExecution'
 import { getFailingMockedProcess, getMockedProcess } from '../test/util/jest'
 import { getProcessEnv } from '../env'
@@ -76,6 +77,37 @@ describe('CliReader', () => {
         executable: 'dvc'
       })
     })
+
+    it('should return the default output if the cli returns an empty repo error', async () => {
+      const cwd = __dirname
+      mockedCreateProcess.mockImplementationOnce(() => {
+        throw new Error(EMPTY_REPO_ERROR)
+      })
+
+      const cliOutput = await cliReader.expShow(cwd)
+      expect(cliOutput).toStrictEqual({ workspace: { baseline: {} } })
+    })
+
+    it('should retry the cli given any other type of error', async () => {
+      const cwd = __dirname
+      const mockOutput: ExperimentsOutput = {
+        workspace: {
+          baseline: {
+            data: { params: { 'params.yaml': { data: { epochs: 100000000 } } } }
+          }
+        }
+      }
+      mockedCreateProcess.mockImplementationOnce(() => {
+        throw new Error('error that should be retried')
+      })
+      mockedCreateProcess.mockReturnValueOnce(
+        getMockedProcess(JSON.stringify(mockOutput))
+      )
+
+      const cliOutput = await cliReader.expShow(cwd)
+      expect(cliOutput).toStrictEqual(mockOutput)
+      expect(mockedCreateProcess).toBeCalledTimes(2)
+    })
   })
 
   describe('diff', () => {

extension/src/cli/reader.ts

@@ -3,6 +3,7 @@ import { Cli, typeCheckCommands } from '.'
 import {
   Args,
   Command,
+  EMPTY_REPO_ERROR,
   ExperimentFlag,
   Flag,
   ListFlag,
@@ -108,6 +109,10 @@ export interface ExperimentsOutput {
   }
 }
 
+const defaultExperimentsOutput: ExperimentsOutput = {
+  workspace: { baseline: {} }
+}
+
 export interface PlotsOutput {
   [path: string]: Plot[]
 }
@@ -132,9 +137,11 @@ export class CliReader extends Cli {
     cwd: string,
     ...flags: ExperimentFlag[]
   ): Promise<ExperimentsOutput> {
-    return this.readProcessJson<ExperimentsOutput>(
+    return this.readProcessJsonWithKnownErrors<ExperimentsOutput>(
       cwd,
       Command.EXPERIMENT,
+      defaultExperimentsOutput,
+      [EMPTY_REPO_ERROR],
       SubCommand.SHOW,
       ...flags
     )
@@ -155,10 +162,12 @@ export class CliReader extends Cli {
   }
 
   public plotsDiff(cwd: string, ...revisions: string[]): Promise<PlotsOutput> {
-    return this.readProcessJson<PlotsOutput>(
+    return this.readProcessJsonWithKnownErrors<PlotsOutput>(
       cwd,
       Command.PLOTS,
-      'diff',
+      {},
+      [EMPTY_REPO_ERROR],
+      Command.DIFF,
       ...revisions,
       Flag.OUTPUT_PATH,
       TEMP_PLOTS_DIR,
@@ -184,11 +193,15 @@ export class CliReader extends Cli {
     cwd: string,
     formatter: typeof trimAndSplit | typeof JSON.parse | typeof trim,
     defaultValue: string,
+    nonRetryErrors: string[],
     ...args: Args
   ): Promise<T> {
     const output =
-      (await retry(() => this.executeProcess(cwd, ...args), args.join(' '))) ||
-      defaultValue
+      (await retry(
+        () => this.executeProcess(cwd, ...args),
+        args.join(' '),
+        nonRetryErrors
+      )) || defaultValue
     if (!formatter) {
       return output as unknown as T
     }
@@ -200,6 +213,25 @@ export class CliReader extends Cli {
       cwd,
       JSON.parse,
       '{}',
+      [],
+      command,
+      ...args,
+      Flag.SHOW_JSON
+    )
+  }
+
+  private readProcessJsonWithKnownErrors<T>(
+    cwd: string,
+    command: Command,
+    defaultValue: T,
+    nonRetryErrors: string[],
+    ...args: Args
+  ) {
+    return this.readProcess<T>(
+      cwd,
+      JSON.parse,
+      JSON.stringify(defaultValue),
+      nonRetryErrors,
       command,
       ...args,
       Flag.SHOW_JSON

extension/src/cli/retry.test.ts

@@ -17,7 +17,7 @@ describe('retry', () => {
 
     const promiseRefresher = jest.fn().mockImplementation(() => promise())
 
-    const output = await retry<string>(promiseRefresher, 'Definitely did not')
+    const output = await retry(promiseRefresher, 'Definitely did not', [])
 
     expect(output).toStrictEqual(returnValue)
 
@@ -45,7 +45,7 @@ describe('retry', () => {
       .fn()
       .mockImplementation(() => unreliablePromise())
 
-    await retry<string>(promiseRefresher, 'Data update')
+    await retry(promiseRefresher, 'Data update', [])
 
     expect(promiseRefresher).toBeCalledTimes(4)
     expect(mockedDelay).toBeCalledTimes(3)

extension/src/cli/retry.ts

@@ -1,18 +1,35 @@
 import { delay } from '../util/time'
 import { Logger } from '../common/logger'
 
-export const retry = async <T>(
-  getNewPromise: () => Promise<T>,
+const isNonRetryError = (
+  errorMessage: string,
+  nonRetryErrors: string[]
+): boolean => {
+  for (const partialErrorMessage of nonRetryErrors) {
+    if (errorMessage.includes(partialErrorMessage)) {
+      return true
+    }
+  }
+  return false
+}
+
+export const retry = async (
+  getNewPromise: () => Promise<string>,
   args: string,
+  nonRetryErrors: string[],
   waitBeforeRetry = 500
-): Promise<T> => {
+): Promise<string> => {
   try {
     return await getNewPromise()
   } catch (error: unknown) {
     const errorMessage = (error as Error).message
     Logger.error(`${args} failed with ${errorMessage} retrying...`)
 
+    if (isNonRetryError(errorMessage, nonRetryErrors)) {
+      return ''
+    }
+
     await delay(waitBeforeRetry)
-    return retry(getNewPromise, args, waitBeforeRetry * 2)
+    return retry(getNewPromise, args, nonRetryErrors, waitBeforeRetry * 2)
   }
 }

extension/src/experiments/data/collect.ts

@@ -3,8 +3,8 @@ import { ExperimentsOutput } from '../../cli/reader'
 export const collectFiles = (data: ExperimentsOutput): string[] => {
   const files = new Set<string>(
     Object.keys({
-      ...data?.workspace.baseline?.data?.params,
-      ...data?.workspace.baseline?.data?.metrics
+      ...data?.workspace?.baseline?.data?.params,
+      ...data?.workspace?.baseline?.data?.metrics
     }).filter(Boolean)
   )
 

extension/src/experiments/index.ts

@@ -277,6 +277,10 @@ export class Experiments extends BaseRepository<TableData> {
   }
 
   public getExperimentCount() {
+    if (!this.columns.hasColumns()) {
+      return 0
+    }
+
     return this.experiments.getExperimentCount()
   }
 

extension/src/experiments/model/tree.ts

@@ -268,7 +268,14 @@ export class ExperimentsTree
 
   private getDescription() {
     const dvcRoots = this.experiments.getDvcRoots()
-    if (!definedAndNonEmpty(dvcRoots)) {
+
+    const total = sum(
+      dvcRoots.map(dvcRoot =>
+        this.experiments.getRepository(dvcRoot).getExperimentCount()
+      )
+    )
+
+    if (!total) {
       return
     }
 
@@ -279,12 +286,6 @@ export class ExperimentsTree
       )
     )
 
-    const total = sum(
-      dvcRoots.map(dvcRoot =>
-        this.experiments.getRepository(dvcRoot).getExperimentCount()
-      )
-    )
-
     return `${selected} of ${total} (max ${MAX_SELECTED_EXPERIMENTS})`
   }