@spinnaker/kubernetes 0.0.0-main-2

package/src/pipelines/stages/patchManifest/PatchManifestOptionsForm.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+import type { Option } from 'react-select';
+import Select from 'react-select';
+
+import { CheckboxInput, StageConfigField } from '@spinnaker/core';
+
+export interface IPatchManifestOptionsFormProps {
+  record: boolean;
+  onRecordChange: (record: boolean) => void;
+  strategy: string;
+  onStrategyChange: (strategy: string) => void;
+}
+
+export const PatchManifestOptionsForm: React.FunctionComponent<IPatchManifestOptionsFormProps> = (
+  props: IPatchManifestOptionsFormProps,
+) => {
+  return (
+    <div className="form-horizontal">
+      <StageConfigField label="Record Patch Annotation" helpKey="kubernetes.manifest.patch.record">
+        <CheckboxInput
+          checked={props.record}
+          onChange={(e: React.ChangeEvent<HTMLInputElement>) => props.onRecordChange(e.target.checked)}
+        />
+      </StageConfigField>
+      <StageConfigField label="Merge Strategy" helpKey="kubernetes.manifest.patch.mergeStrategy" fieldColumns={3}>
+        <Select
+          clearable={false}
+          value={props.strategy}
+          options={['strategic', 'json', 'merge'].map((k) => ({ value: k, label: k }))}
+          onChange={(e: Option<string>) => props.onStrategyChange(e.value)}
+        />
+      </StageConfigField>
+    </div>
+  );
+};

package/src/pipelines/stages/patchManifest/PatchManifestStageConfig.tsx

@@ -0,0 +1,57 @@
+import { defaults } from 'lodash';
+import React from 'react';
+
+import type { IStage, IStageConfigProps } from '@spinnaker/core';
+import { FormikStageConfig } from '@spinnaker/core';
+
+import { PatchManifestStageForm } from './PatchManifestStageForm';
+import { ManifestSource } from '../../../manifest/ManifestSource';
+
+export class PatchManifestStageConfig extends React.Component<IStageConfigProps> {
+  private readonly stage: IStage;
+
+  public constructor(props: IStageConfigProps) {
+    super(props);
+    defaults(props.stage, {
+      app: props.application.name,
+      source: ManifestSource.TEXT,
+      options: {
+        record: true,
+        mergeStrategy: 'strategic',
+      },
+      cloudProvider: 'kubernetes',
+    });
+
+    // There was a bug introduced in Spinnaker 1.15 where we were incorrectly
+    // storing the merge strategy on a field called 'strategy' instead of on
+    // 'mergeStrategy'.  In order to auto-fix pipelines affected by that bug,
+    // delete any value in 'strategy'. If 'mergeStrategy' is empty, set it to
+    // the value we deleted from 'strategy'.
+    defaults(props.stage.options, {
+      mergeStrategy: props.stage.options.strategy,
+    });
+    delete props.stage.options.strategy;
+
+    // There was a bug introduced in Spinnaker 1.15 where we were incorrectly
+    // always storing the patchBody as an object. In order to auto-fix pipelines
+    // affected by that bug, massage any configured patchBody value into a list.
+    if (props.stage.patchBody && !Array.isArray(props.stage.patchBody)) {
+      props.stage.patchBody = [props.stage.patchBody];
+    }
+
+    // Intentionally initializing the stage config only once in the constructor
+    // The stage config is then completely owned within FormikStageConfig's Formik state
+    this.stage = props.stage;
+  }
+
+  public render() {
+    return (
+      <FormikStageConfig
+        {...this.props}
+        stage={this.stage}
+        onChange={this.props.updateStage}
+        render={(props) => <PatchManifestStageForm {...props} stageFieldUpdated={this.props.stageFieldUpdated} />}
+      />
+    );
+  }
+}

package/src/pipelines/stages/patchManifest/PatchManifestStageForm.tsx

@@ -0,0 +1,157 @@
+import { capitalize, get, isEmpty, map } from 'lodash';
+import React from 'react';
+import type { Option } from 'react-select';
+
+import type { IArtifact, IExpectedArtifact, IFormikStageConfigInjectedProps } from '@spinnaker/core';
+import {
+  ArtifactTypePatterns,
+  RadioButtonInput,
+  StageArtifactSelectorDelegate,
+  StageConfigField,
+  yamlDocumentsToString,
+  YamlEditor,
+} from '@spinnaker/core';
+
+import { PatchManifestOptionsForm } from './PatchManifestOptionsForm';
+import { ManifestBindArtifactsSelector } from '../deployManifest/ManifestBindArtifactsSelector';
+import type { IManifestBindArtifact } from '../deployManifest/ManifestBindArtifactsSelector';
+import { ManifestSource } from '../../../manifest/ManifestSource';
+import { SelectorMode } from '../../../manifest/selector/IManifestSelector';
+import { ManifestSelector } from '../../../manifest/selector/ManifestSelector';
+
+interface IPatchManifestStageConfigFormProps {
+  stageFieldUpdated: () => void;
+}
+
+interface IPatchManifestStageConfigFormState {
+  rawManifest: string;
+}
+
+export class PatchManifestStageForm extends React.Component<
+  IPatchManifestStageConfigFormProps & IFormikStageConfigInjectedProps,
+  IPatchManifestStageConfigFormState
+> {
+  private readonly excludedManifestArtifactTypes = [
+    ArtifactTypePatterns.DOCKER_IMAGE,
+    ArtifactTypePatterns.KUBERNETES,
+    ArtifactTypePatterns.FRONT50_PIPELINE_TEMPLATE,
+    ArtifactTypePatterns.EMBEDDED_BASE64,
+    ArtifactTypePatterns.MAVEN_FILE,
+  ];
+
+  public constructor(props: IPatchManifestStageConfigFormProps & IFormikStageConfigInjectedProps) {
+    super(props);
+    const patchBody: any[] = get(props.formik.values, 'patchBody');
+    const isTextManifest: boolean = get(props.formik.values, 'source') === ManifestSource.TEXT;
+    this.state = {
+      rawManifest: !isEmpty(patchBody) && isTextManifest ? yamlDocumentsToString(patchBody) : '',
+    };
+  }
+
+  private onManifestArtifactSelected = (expectedArtifactId: string): void => {
+    this.props.formik.setFieldValue('manifestArtifactId', expectedArtifactId);
+    this.props.formik.setFieldValue('manifestArtifact', null);
+  };
+
+  private onManifestArtifactEdited = (artifact: IArtifact) => {
+    this.props.formik.setFieldValue('manifestArtifactId', null);
+    this.props.formik.setFieldValue('manifestArtifact', artifact);
+  };
+
+  private getRequiredArtifacts = (): IManifestBindArtifact[] => {
+    const { requiredArtifactIds, requiredArtifacts } = this.props.formik.values;
+    return (requiredArtifactIds || [])
+      .map((id: string) => ({ expectedArtifactId: id }))
+      .concat(requiredArtifacts || []);
+  };
+
+  private onRequiredArtifactsChanged = (bindings: IManifestBindArtifact[]): void => {
+    this.props.formik.setFieldValue(
+      'requiredArtifactIds',
+      bindings.filter((b) => b.expectedArtifactId).map((b) => b.expectedArtifactId),
+    );
+    this.props.formik.setFieldValue(
+      'requiredArtifacts',
+      bindings.filter((b) => b.artifact),
+    );
+  };
+
+  private handleRawManifestChange = (rawManifest: string, manifests: any): void => {
+    this.setState({
+      rawManifest,
+    });
+    this.props.formik.setFieldValue('patchBody', manifests);
+  };
+
+  private onManifestSelectorChange = (): void => {
+    this.props.stageFieldUpdated();
+  };
+
+  private getSourceOptions = (): Array<Option<string>> => {
+    return map([ManifestSource.TEXT, ManifestSource.ARTIFACT], (option) => ({
+      label: capitalize(option),
+      value: option,
+    }));
+  };
+
+  public render() {
+    const stage = this.props.formik.values;
+    return (
+      <div className="container-fluid form-horizontal">
+        <h4>Resource to Patch</h4>
+        <ManifestSelector
+          application={this.props.application}
+          modes={[SelectorMode.Static, SelectorMode.Dynamic]}
+          onChange={this.onManifestSelectorChange}
+          selector={stage as any}
+        />
+        <hr />
+        <h4>Patch Content</h4>
+        <StageConfigField label="Manifest Source" helpKey="kubernetes.manifest.source">
+          <RadioButtonInput
+            options={this.getSourceOptions()}
+            onChange={(e: any) => this.props.formik.setFieldValue('source', e.target.value)}
+            value={stage.source}
+          />
+        </StageConfigField>
+        {stage.source === ManifestSource.TEXT && (
+          <StageConfigField label="Manifest">
+            <YamlEditor onChange={this.handleRawManifestChange} value={this.state.rawManifest} />
+          </StageConfigField>
+        )}
+        {stage.source === ManifestSource.ARTIFACT && (
+          <>
+            <StageArtifactSelectorDelegate
+              artifact={stage.manifestArtifact}
+              excludedArtifactTypePatterns={this.excludedManifestArtifactTypes}
+              expectedArtifactId={stage.manifestArtifactId}
+              helpKey="kubernetes.manifest.expectedArtifact"
+              label="Manifest Artifact"
+              onArtifactEdited={this.onManifestArtifactEdited}
+              onExpectedArtifactSelected={(artifact: IExpectedArtifact) => this.onManifestArtifactSelected(artifact.id)}
+              pipeline={this.props.pipeline}
+              stage={stage}
+            />
+          </>
+        )}
+        <StageConfigField label="Required Artifacts to Bind" helpKey="kubernetes.manifest.requiredArtifactsToBind">
+          <ManifestBindArtifactsSelector
+            bindings={this.getRequiredArtifacts()}
+            onChangeBindings={this.onRequiredArtifactsChanged}
+            pipeline={this.props.pipeline}
+            stage={stage}
+          />
+        </StageConfigField>
+
+        <hr />
+        <h4>Patch Options</h4>
+        <PatchManifestOptionsForm
+          strategy={!!stage.options && stage.options.mergeStrategy}
+          onStrategyChange={(strategy: string) => this.props.formik.setFieldValue('options.mergeStrategy', strategy)}
+          record={!!stage.options && stage.options.record}
+          onRecordChange={(record: boolean) => this.props.formik.setFieldValue('options.record', record)}
+        />
+      </div>
+    );
+  }
+}

package/src/pipelines/stages/patchManifest/patchManifestStage.ts

@@ -0,0 +1,30 @@
+import {
+  ArtifactReferenceService,
+  ExecutionArtifactTab,
+  ExecutionDetailsTasks,
+  ExpectedArtifactService,
+  Registry,
+} from '@spinnaker/core';
+
+import { PatchManifestStageConfig } from './PatchManifestStageConfig';
+import { DeployStatus } from '../deployManifest/manifestStatus/DeployStatus';
+import { manifestSelectorValidators } from '../validators/manifestSelectorValidators';
+
+export class PatchStatus extends DeployStatus {
+  public static title = 'PatchStatus';
+}
+
+const STAGE_NAME = 'Patch (Manifest)';
+Registry.pipeline.registerStage({
+  label: STAGE_NAME,
+  description: 'Patch a Kubernetes object in place.',
+  key: 'patchManifest',
+  cloudProvider: 'kubernetes',
+  component: PatchManifestStageConfig,
+  executionDetailsSections: [PatchStatus, ExecutionDetailsTasks, ExecutionArtifactTab],
+  producesArtifacts: true,
+  supportsCustomTimeout: true,
+  validators: manifestSelectorValidators(STAGE_NAME),
+  artifactExtractor: ExpectedArtifactService.accumulateArtifacts(['manifestArtifactId', 'requiredArtifactIds']),
+  artifactRemover: ArtifactReferenceService.removeArtifactFromFields(['manifestArtifactId', 'requiredArtifactIds']),
+});

package/src/pipelines/stages/rolloutRestartManifest/RolloutRestartManifestStageConfig.tsx

@@ -0,0 +1,46 @@
+import { defaults } from 'lodash';
+import React from 'react';
+
+import type { Application, IStage, IStageConfigProps } from '@spinnaker/core';
+
+import type { IManifestSelector } from '../../../manifest/selector/IManifestSelector';
+import { SelectorMode } from '../../../manifest/selector/IManifestSelector';
+import { ManifestSelector } from '../../../manifest/selector/ManifestSelector';
+
+export interface IKubernetesManifestStageConfigProps extends IStageConfigProps {
+  application: Application;
+  stage: IManifestSelector & IStage;
+  stageFieldUpdated: () => void;
+}
+
+export class RolloutRestartManifestStageConfig extends React.Component<IKubernetesManifestStageConfigProps> {
+  public componentDidMount = (): void => {
+    defaults(this.props.stage, {
+      app: this.props.application.name,
+      cloudProvider: 'kubernetes',
+    });
+    this.props.stageFieldUpdated();
+  };
+
+  private onChange = (stage: IManifestSelector): void => {
+    Object.assign(this.props.stage, stage);
+    this.props.stageFieldUpdated();
+  };
+
+  public render() {
+    const selector = { ...this.props.stage };
+    return (
+      <div className="form-horizontal">
+        <h4>Manifest</h4>
+        <div className="horizontal-rule" />
+        <ManifestSelector
+          application={this.props.application}
+          selector={selector}
+          modes={[SelectorMode.Static, SelectorMode.Dynamic, SelectorMode.Label]}
+          onChange={this.onChange}
+          includeSpinnakerKinds={null}
+        />
+      </div>
+    );
+  }
+}

package/src/pipelines/stages/rolloutRestartManifest/rolloutRestartManifestStage.ts

@@ -0,0 +1,20 @@
+import { ExecutionDetailsTasks, Registry } from '@spinnaker/core';
+
+import { RolloutRestartManifestStageConfig } from './RolloutRestartManifestStageConfig';
+import { DeployStatus } from '../deployManifest/manifestStatus/DeployStatus';
+import { manifestSelectorValidators } from '../validators/manifestSelectorValidators';
+
+export class RolloutRestartStatus extends DeployStatus {
+  public static title = 'RolloutRestartStatus';
+}
+
+const STAGE_NAME = 'Rollout Restart (Manifest)';
+Registry.pipeline.registerStage({
+  label: STAGE_NAME,
+  description: 'Perform a rolling restart of a manifest.',
+  key: 'rollingRestartManifest',
+  cloudProvider: 'kubernetes',
+  component: RolloutRestartManifestStageConfig,
+  executionDetailsSections: [RolloutRestartStatus, ExecutionDetailsTasks],
+  validators: manifestSelectorValidators(STAGE_NAME),
+});

package/src/pipelines/stages/runJob/KubernetesV2RunJobStageConfig.tsx

@@ -0,0 +1,242 @@
+import { capitalize, map } from 'lodash';
+import React from 'react';
+import type { Option } from 'react-select';
+import Select from 'react-select';
+
+import type { IAccount, IArtifact, IExpectedArtifact, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountService,
+  ArtifactTypePatterns,
+  RadioButtonInput,
+  StageArtifactSelector,
+  StageArtifactSelectorDelegate,
+  StageConfigField,
+  yamlDocumentsToString,
+  YamlEditor,
+} from '@spinnaker/core';
+
+import { ManifestBindArtifactsSelector } from '../deployManifest/ManifestBindArtifactsSelector';
+import type { IManifestBindArtifact } from '../deployManifest/ManifestBindArtifactsSelector';
+import { ManifestSource } from '../../../manifest/ManifestSource';
+import { ManifestBasicSettings } from '../../../manifest/wizard/BasicSettings';
+
+export interface IKubernetesRunJobStageConfigState {
+  credentials: IAccount[];
+  rawManifest?: string;
+}
+
+export class KubernetesV2RunJobStageConfig extends React.Component<IStageConfigProps> {
+  public state: IKubernetesRunJobStageConfigState = {
+    credentials: [],
+  };
+
+  private readonly excludedManifestArtifactTypes = [
+    ArtifactTypePatterns.DOCKER_IMAGE,
+    ArtifactTypePatterns.KUBERNETES,
+    ArtifactTypePatterns.FRONT50_PIPELINE_TEMPLATE,
+    ArtifactTypePatterns.MAVEN_FILE,
+  ];
+
+  constructor(props: IStageConfigProps) {
+    super(props);
+    const { stage, application } = this.props;
+    if (!stage.application) {
+      stage.application = application.name;
+    }
+    if (!stage.source) {
+      stage.source = ManifestSource.TEXT;
+    }
+  }
+
+  public outputOptions = [
+    { label: 'None', value: 'none' },
+    { label: 'Logs', value: 'propertyFile' },
+    { label: 'Artifact', value: 'artifact' },
+  ];
+
+  public accountChanged = (account: string) => {
+    this.props.updateStageField({
+      credentials: account,
+      account: account,
+    });
+  };
+
+  public handleRawManifestChange = (rawManifest: string, manifests: any) => {
+    if (manifests) {
+      this.props.updateStageField({ manifest: manifests[0] });
+    }
+    this.setState({ rawManifest });
+  };
+
+  public initRawManifest() {
+    const { stage } = this.props;
+    if (stage.manifest) {
+      this.setState({ rawManifest: yamlDocumentsToString([stage.manifest]) });
+    }
+  }
+
+  public componentDidMount() {
+    this.props.updateStageField({ cloudProvider: 'kubernetes' });
+    AccountService.getAllAccountDetailsForProvider('kubernetes').then((accounts: any) => {
+      this.setState({ credentials: accounts });
+    });
+    this.initRawManifest();
+  }
+
+  private sourceChanged = (event: any) => {
+    this.props.updateStageField({ consumeArtifactSource: event.value });
+    if (event.value === 'none') {
+      this.props.updateStageField({ propertyFile: null });
+    }
+  };
+
+  private onArtifactSelected = (artifact: IExpectedArtifact) => {
+    this.props.updateStageField({ consumeArtifactId: artifact.id });
+  };
+
+  private onArtifactEdited = (artifact: IArtifact) => {
+    this.props.updateStageField({
+      consumeArtifact: artifact,
+      consumeArtifactId: artifact.id,
+      consumeArtifactAccount: artifact.artifactAccount,
+    });
+  };
+
+  private onManifestArtifactSelected = (expectedArtifactId: string): void => {
+    this.props.updateStageField({
+      manifestArtifactId: expectedArtifactId,
+      manifestArtifact: null,
+    });
+  };
+
+  private onManifestArtifactEdited = (artifact: IArtifact) => {
+    this.props.updateStageField({
+      manifestArtifactId: null,
+      manifestArtifact: artifact,
+    });
+  };
+
+  private updatePropertyFile = (event: any) => {
+    this.props.updateStageField({ propertyFile: event.target.value });
+  };
+
+  public logSourceForm() {
+    const { stage } = this.props;
+    return (
+      <StageConfigField label="Container Name" helpKey="kubernetes.runJob.captureSource.containerName">
+        <input
+          className="form-control input-sm"
+          type="text"
+          value={stage.propertyFile}
+          onChange={this.updatePropertyFile}
+        />
+      </StageConfigField>
+    );
+  }
+
+  public artifactForm() {
+    const { stage, pipeline } = this.props;
+    return (
+      <StageConfigField label="Artifact">
+        <StageArtifactSelector
+          pipeline={pipeline}
+          stage={stage}
+          artifact={stage.consumeArtifact}
+          excludedArtifactTypePatterns={[]}
+          expectedArtifactId={stage.consumeArtifactId}
+          onExpectedArtifactSelected={this.onArtifactSelected}
+          onArtifactEdited={this.onArtifactEdited}
+        />
+      </StageConfigField>
+    );
+  }
+
+  private getSourceOptions = (): Array<Option<string>> => {
+    return map([ManifestSource.TEXT, ManifestSource.ARTIFACT], (option) => ({
+      label: capitalize(option),
+      value: option,
+    }));
+  };
+
+  private getRequiredArtifacts = (): IManifestBindArtifact[] => {
+    const { requiredArtifactIds, requiredArtifacts } = this.props.stage;
+    return (requiredArtifactIds || [])
+      .map((id: string) => ({ expectedArtifactId: id }))
+      .concat(requiredArtifacts || []);
+  };
+
+  private onRequiredArtifactsChanged = (bindings: IManifestBindArtifact[]): void => {
+    this.props.updateStageField({
+      requiredArtifactIds: bindings.filter((b) => b.expectedArtifactId).map((b) => b.expectedArtifactId),
+    });
+    this.props.updateStageField({ requiredArtifacts: bindings.filter((b) => b.artifact) });
+  };
+
+  public render() {
+    const { stage } = this.props;
+
+    let outputSource = <div />;
+    if (stage.consumeArtifactSource === 'propertyFile') {
+      outputSource = this.logSourceForm();
+    } else if (stage.consumeArtifactSource === 'artifact') {
+      outputSource = this.artifactForm();
+    }
+
+    return (
+      <div className="container-fluid form-horizontal">
+        <h4>Basic Settings</h4>
+        <ManifestBasicSettings
+          selectedAccount={stage.account || ''}
+          accounts={this.state.credentials}
+          onAccountSelect={(selectedAccount: string) => this.accountChanged(selectedAccount)}
+        />
+        <h4>Manifest Configuration</h4>
+        <StageConfigField label="Manifest Source" helpKey="kubernetes.manifest.source">
+          <RadioButtonInput
+            options={this.getSourceOptions()}
+            onChange={(e: any) => this.props.updateStageField({ source: e.target.value })}
+            value={stage.source}
+          />
+        </StageConfigField>
+        {stage.source === ManifestSource.TEXT && (
+          <YamlEditor value={this.state.rawManifest} onChange={this.handleRawManifestChange} />
+        )}
+        {stage.source === ManifestSource.ARTIFACT && (
+          <>
+            <StageArtifactSelectorDelegate
+              artifact={stage.manifestArtifact}
+              excludedArtifactTypePatterns={this.excludedManifestArtifactTypes}
+              expectedArtifactId={stage.manifestArtifactId}
+              helpKey="kubernetes.manifest.expectedArtifact"
+              label="Manifest Artifact"
+              onArtifactEdited={this.onManifestArtifactEdited}
+              onExpectedArtifactSelected={(artifact: IExpectedArtifact) => this.onManifestArtifactSelected(artifact.id)}
+              pipeline={this.props.pipeline}
+              stage={stage}
+            />
+          </>
+        )}
+        <StageConfigField label="Required Artifacts to Bind" helpKey="kubernetes.manifest.requiredArtifactsToBind">
+          <ManifestBindArtifactsSelector
+            bindings={this.getRequiredArtifacts()}
+            onChangeBindings={this.onRequiredArtifactsChanged}
+            pipeline={this.props.pipeline}
+            stage={stage}
+          />
+        </StageConfigField>
+        <h4>Output</h4>
+        <StageConfigField label="Capture Output From" helpKey="kubernetes.runJob.captureSource">
+          <div>
+            <Select
+              clearable={false}
+              options={this.outputOptions}
+              value={stage.consumeArtifactSource}
+              onChange={this.sourceChanged}
+            />
+          </div>
+        </StageConfigField>
+        {outputSource}
+      </div>
+    );
+  }
+}

package/src/pipelines/stages/runJob/RunJobExecutionDetails.tsx

@@ -0,0 +1,67 @@
+import { get, isEmpty, sortBy } from 'lodash';
+import React from 'react';
+
+import type { IExecutionDetailsSectionProps, IJobOwnedPodStatus } from '@spinnaker/core';
+import {
+  AccountTag,
+  DefaultPodNameProvider,
+  ExecutionDetailsSection,
+  JobStageExecutionLogs,
+  StageFailureMessage,
+} from '@spinnaker/core';
+
+export class RunJobExecutionDetails extends React.Component<IExecutionDetailsSectionProps, any> {
+  public static title = 'runJobConfig';
+
+  private createdPodNames(podsStatuses: IJobOwnedPodStatus[]): string[] {
+    const sorted = sortBy(podsStatuses, (p: IJobOwnedPodStatus) => p.status.startTime);
+    return sorted.map((p: IJobOwnedPodStatus) => p.name);
+  }
+
+  public render() {
+    const { stage, name, current } = this.props;
+    const { context } = stage;
+    const namespace = get(stage, ['context', 'jobStatus', 'location'], '');
+    const deployedName = namespace ? get<string[]>(context, ['deploy.jobs', namespace])[0] : '';
+    const externalLink = get<string>(stage, ['context', 'execution', 'logs']);
+    const pods = get(stage.context, 'jobStatus.pods', []);
+    const podNames = !isEmpty(pods)
+      ? this.createdPodNames(pods)
+      : [get(stage, ['context', 'jobStatus', 'mostRecentPodName'], '')];
+    const podNamesProviders = podNames.map((p) => new DefaultPodNameProvider(p));
+
+    return (
+      <ExecutionDetailsSection name={name} current={current}>
+        <StageFailureMessage stage={stage} message={stage.failureMessage} />
+        <div className="row">
+          <div className="col-md-9">
+            <dl className="dl-narrow dl-horizontal">
+              <dt>Account</dt>
+              <dd>
+                <AccountTag account={context.account} />
+              </dd>
+              {namespace && (
+                <>
+                  <dt>Namespace</dt>
+                  <dd>{stage.context.jobStatus.location}</dd>
+                  <dt>Logs</dt>
+                  <dd>
+                    <JobStageExecutionLogs
+                      deployedName={deployedName}
+                      account={this.props.stage.context.account}
+                      location={namespace}
+                      application={this.props.application}
+                      externalLink={externalLink}
+                      podNamesProviders={podNamesProviders}
+                    />
+                  </dd>
+                </>
+              )}
+              {!namespace && <div className="well">Collecting additional details...</div>}
+            </dl>
+          </div>
+        </div>
+      </ExecutionDetailsSection>
+    );
+  }
+}