@spinnaker/oracle 2026.2.2 → 2026.3.0

package/src/pipeline/stages/findAmi/OracleFindAmiStageConfig.tsx

@@ -0,0 +1,103 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import { AccountRegionClusterSelector, AccountService, Registry, StageConfigField } from '@spinnaker/core';
+
+const selectionStrategies = [
+  {
+    label: 'Largest',
+    val: 'LARGEST',
+    description: 'When multiple server groups exist, prefer the server group with the most instances',
+  },
+  { label: 'Newest', val: 'NEWEST', description: 'When multiple server groups exist, prefer the newest' },
+  { label: 'Oldest', val: 'OLDEST', description: 'When multiple server groups exist, prefer the oldest' },
+  { label: 'Fail', val: 'FAIL', description: 'When multiple server groups exist, fail' },
+];
+
+export function OracleFindAmiStageConfig(props: IStageConfigProps) {
+  const { application, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'oracle') {
+      changes.cloudProvider = 'oracle';
+    }
+    if (!stage.credentials && application.defaultCredentials?.oracle) {
+      changes.credentials = application.defaultCredentials.oracle;
+    }
+    if (!stage.regions?.length && application.defaultRegions?.oracle) {
+      changes.regions = [application.defaultRegions.oracle];
+    }
+    if (!stage.selectionStrategy) {
+      changes.selectionStrategy = selectionStrategies[0].val;
+    }
+    if (stage.onlyEnabled === undefined) {
+      changes.onlyEnabled = true;
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('oracle').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      <AccountRegionClusterSelector
+        accounts={accounts}
+        application={application}
+        component={stage}
+        onComponentUpdate={stageFieldUpdated}
+      />
+      <StageConfigField label="Server Group Selection">
+        <select
+          className="form-control input-sm"
+          onChange={(event) => updateStageField({ selectionStrategy: event.target.value })}
+          value={stage.selectionStrategy || selectionStrategies[0].val}
+        >
+          {selectionStrategies.map((strategy) => (
+            <option key={strategy.val} title={strategy.description} value={strategy.val}>
+              {strategy.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      <StageConfigField label="Server Group Filters">
+        <label className="checkbox-inline">
+          <input
+            checked={stage.onlyEnabled !== false}
+            onChange={(event) => updateStageField({ onlyEnabled: event.target.checked })}
+            type="checkbox"
+          />
+          Only consider enabled Server Groups
+        </label>
+      </StageConfigField>
+    </div>
+  );
+}
+
+export const oracleFindAmiStage = {
+  key: 'findImage',
+  provides: 'findImage',
+  cloudProvider: 'oracle',
+  component: OracleFindAmiStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'selectionStrategy', fieldLabel: 'Server Group Selection' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials' },
+  ],
+};
+
+export function registerOracleFindAmiStage() {
+  Registry.pipeline.registerStage(oracleFindAmiStage);
+}
+
+registerOracleFindAmiStage();

package/src/pipeline/stages/findImageFromTags/OracleFindImageFromTagsStageConfig.tsx

@@ -0,0 +1,90 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IStageConfigProps } from '@spinnaker/core';
+import {
+  BakeryReader,
+  ChecklistInput,
+  ExecutionDetailsTasks,
+  MapEditor,
+  Registry,
+  StageConfigField,
+} from '@spinnaker/core';
+
+export function OracleFindImageFromTagsStageConfig({ pipeline, stage, updateStageField }: IStageConfigProps) {
+  const [regions, setRegions] = useState<string[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'oracle') {
+      changes.cloudProvider = 'oracle';
+    }
+    if (!stage.packageName) {
+      changes.packageName = '*';
+    }
+    if (!stage.tags) {
+      changes.tags = {};
+    }
+    if (!stage.regions) {
+      changes.regions = [];
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    BakeryReader.getRegions('oracle').then((loadedRegions) => active && setRegions(loadedRegions));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      <StageConfigField label="Regions">
+        <ChecklistInput
+          inline={true}
+          name="regions"
+          onChange={(event: any) => updateStageField({ regions: event.target.value })}
+          showSelectAll={true}
+          stringOptions={regions}
+          value={stage.regions || []}
+        />
+      </StageConfigField>
+      <StageConfigField label="Pattern">
+        <input
+          className="form-control input-sm"
+          onChange={(event) => updateStageField({ packageName: event.target.value })}
+          value={stage.packageName || ''}
+        />
+      </StageConfigField>
+      <StageConfigField label="Tags">
+        <MapEditor
+          allowEmpty={true}
+          model={stage.tags || {}}
+          onChange={(tags) => updateStageField({ tags })}
+          pipeline={pipeline}
+        />
+      </StageConfigField>
+    </div>
+  );
+}
+
+export const oracleFindImageFromTagsStage = {
+  key: 'findImageFromTags',
+  provides: 'findImageFromTags',
+  cloudProvider: 'oracle',
+  component: OracleFindImageFromTagsStageConfig,
+  executionDetailsSections: [ExecutionDetailsTasks],
+  validators: [
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'packageName' },
+  ],
+};
+
+export function registerOracleFindImageFromTagsStage() {
+  Registry.pipeline.registerStage(oracleFindImageFromTagsStage);
+}
+
+registerOracleFindImageFromTagsStage();

package/src/pipeline/stages/resizeAsg/OracleResizeAsgStageConfig.tsx

@@ -0,0 +1,225 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+  StageConstants,
+  TargetSelect,
+} from '@spinnaker/core';
+
+const scaleActions = [
+  { label: 'Scale Up', val: 'scale_up' },
+  { label: 'Scale Down', val: 'scale_down' },
+  { label: 'Scale to Cluster Size', val: 'scale_to_cluster' },
+  { label: 'Scale to Exact Size', val: 'scale_exact' },
+];
+
+const resizeTypes = [
+  { label: 'Percentage', val: 'pct' },
+  { label: 'Incremental', val: 'incr' },
+];
+
+export function OracleResizeAsgStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'oracle') {
+      changes.cloudProvider = 'oracle';
+      changes.cloudProviderType = 'oracle';
+    }
+    if (!stage.credentials && application.defaultCredentials?.oracle) {
+      changes.credentials = application.defaultCredentials.oracle;
+    }
+    if (!stage.regions?.length && application.defaultRegions?.oracle) {
+      changes.regions = [application.defaultRegions.oracle];
+    }
+    if (!stage.target) {
+      changes.target = StageConstants.TARGET_LIST[0].val;
+    }
+    if (!stage.action) {
+      changes.action = stage.resizeType === 'exact' ? 'scale_exact' : scaleActions[0].val;
+    }
+    if (!stage.resizeType) {
+      changes.resizeType = resizeTypes[0].val;
+    }
+    if (!stage.capacity) {
+      changes.capacity = {};
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('oracle').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  const updateResizeType = (action: string, resizeType = stage.resizeType || resizeTypes[0].val) => {
+    if (action === 'scale_exact') {
+      updateStageField({ action, resizeType: 'exact', scaleNum: undefined, scalePct: undefined });
+      return;
+    }
+    const nextResizeType = resizeType === 'incr' ? 'incr' : 'pct';
+    const changes: Record<string, any> = { action, capacity: {}, resizeType: nextResizeType };
+    if (nextResizeType === 'pct') {
+      changes.scaleNum = undefined;
+    } else {
+      changes.scalePct = undefined;
+      changes.scaleNum = stage.scaleNum || 0;
+    }
+    updateStageField(changes);
+  };
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Target">
+        <TargetSelect
+          model={{ target: stage.target }}
+          onChange={(target: string) => updateStageField({ target })}
+          options={StageConstants.TARGET_LIST}
+        />
+      </StageConfigField>
+      <StageConfigField label="Action" helpKey="pipeline.config.resizeAsg.action">
+        <select
+          className="form-control input-sm"
+          onChange={(event) => updateResizeType(event.target.value)}
+          value={stage.action || scaleActions[0].val}
+        >
+          {scaleActions.map((action) => (
+            <option key={action.val} value={action.val}>
+              {action.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      {stage.action !== 'scale_exact' && (
+        <>
+          <StageConfigField label={stage.action === 'scale_to_cluster' ? 'Additional Capacity' : 'Type'}>
+            <select
+              className="form-control input-sm"
+              onChange={(event) => updateResizeType(stage.action, event.target.value)}
+              value={stage.resizeType || resizeTypes[0].val}
+            >
+              {resizeTypes.map((type) => (
+                <option key={type.val} value={type.val}>
+                  {type.label}
+                </option>
+              ))}
+            </select>
+          </StageConfigField>
+          {stage.resizeType === 'pct' && (
+            <StageConfigField label="Resize Percentage">
+              <input
+                className="form-control input-sm"
+                min={0}
+                onChange={(event) => updateStageField({ scalePct: Number(event.target.value) })}
+                type="number"
+                value={stage.scalePct ?? ''}
+              />
+              <div>
+                <em className="subinput-note">
+                  This is the percentage by which the target server group's capacity will be increased
+                </em>
+              </div>
+            </StageConfigField>
+          )}
+          {stage.resizeType === 'incr' && (
+            <StageConfigField label="Resize-by Amount">
+              <input
+                className="form-control input-sm"
+                min={0}
+                onChange={(event) => updateStageField({ scaleNum: Number(event.target.value) })}
+                type="number"
+                value={stage.scaleNum ?? ''}
+              />
+              <div>
+                <em className="subinput-note">
+                  This is the exact amount by which the target server group's capacity will be increased
+                </em>
+              </div>
+            </StageConfigField>
+          )}
+        </>
+      )}
+      {stage.action === 'scale_exact' && (
+        <>
+          <StageConfigField label="">
+            <div className="row small">
+              <div className="col-md-3">Min</div>
+              <div className="col-md-3">Max</div>
+              <div className="col-md-3">Desired</div>
+            </div>
+          </StageConfigField>
+          <StageConfigField label="Match Capacity">
+            <div className="row">
+              {(['min', 'max', 'desired'] as const).map((field) => (
+                <div className="col-md-3" key={field}>
+                  <input
+                    className="form-control input-sm"
+                    onChange={(event) =>
+                      updateStageField({ capacity: { ...stage.capacity, [field]: Number(event.target.value) } })
+                    }
+                    type="number"
+                    value={stage.capacity?.[field] ?? ''}
+                  />
+                </div>
+              ))}
+            </div>
+          </StageConfigField>
+        </>
+      )}
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Oracle"
+          />
+        </StageConfigField>
+      )}
+    </div>
+  );
+}
+
+export const oracleResizeAsgStage = {
+  key: 'resizeServerGroup',
+  provides: 'resizeServerGroup',
+  cloudProvider: 'oracle',
+  component: OracleResizeAsgStageConfig,
+  validators: [
+    {
+      type: 'targetImpedance',
+      message:
+        'This pipeline will attempt to resize a server group without deploying a new version into the same cluster.',
+    },
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'action' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerOracleResizeAsgStage() {
+  Registry.pipeline.registerStage(oracleResizeAsgStage);
+}
+
+registerOracleResizeAsgStage();

package/src/pipeline/stages/scaleDownCluster/OracleScaleDownClusterStageConfig.tsx

@@ -0,0 +1,122 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import { AccountRegionClusterSelector, AccountService, Registry, StageConfigField } from '@spinnaker/core';
+
+function pluralize(str: string, val: number): string {
+  return val === 1 ? str : `${str}s`;
+}
+
+export function OracleScaleDownClusterStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'oracle') {
+      changes.cloudProvider = 'oracle';
+    }
+    if (!stage.credentials && application.defaultCredentials?.oracle) {
+      changes.credentials = application.defaultCredentials.oracle;
+    }
+    if (!stage.regions?.length && application.defaultRegions?.oracle) {
+      changes.regions = [application.defaultRegions.oracle];
+    }
+    if (stage.remainingFullSizeServerGroups === undefined) {
+      changes.remainingFullSizeServerGroups = 1;
+    }
+    if (stage.allowScaleDownActive === undefined) {
+      changes.allowScaleDownActive = false;
+    }
+    if (stage.preferLargerOverNewer === undefined) {
+      changes.preferLargerOverNewer = 'false';
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('oracle').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Scale Down Options">
+        <div className="form-inline">
+          <p>
+            Keep the{' '}
+            <input
+              className="form-control input-sm"
+              min={0}
+              onChange={(event) => updateStageField({ remainingFullSizeServerGroups: Number(event.target.value) })}
+              required
+              style={{ width: 50 }}
+              type="number"
+              value={stage.remainingFullSizeServerGroups ?? ''}
+            />{' '}
+            <select
+              className="form-control input-sm"
+              onChange={(event) => updateStageField({ preferLargerOverNewer: event.target.value })}
+              style={{ width: 100 }}
+              value={stage.preferLargerOverNewer ?? 'false'}
+            >
+              <option value="true">largest</option>
+              <option value="false">newest</option>
+            </select>{' '}
+            {pluralize('server group', stage.remainingFullSizeServerGroups)} at current size.
+          </p>
+          <p>The remaining server groups will be scaled down to zero instances.</p>
+        </div>
+      </StageConfigField>
+      <div className="form-group">
+        <div className="col-md-offset-3 col-md-6 checkbox">
+          <label>
+            <input
+              checked={!!stage.allowScaleDownActive}
+              onChange={(event) => updateStageField({ allowScaleDownActive: event.target.checked })}
+              type="checkbox"
+            />
+            Allow scale down of active server groups
+          </label>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export const oracleScaleDownClusterStage = {
+  key: 'scaleDownCluster',
+  provides: 'scaleDownCluster',
+  cloudProvider: 'oracle',
+  component: OracleScaleDownClusterStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    {
+      type: 'requiredField',
+      fieldName: 'remainingFullSizeServerGroups',
+      fieldLabel: 'Keep [X] full size Server Groups',
+    },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+  strategy: true,
+};
+
+export function registerOracleScaleDownClusterStage() {
+  Registry.pipeline.registerStage(oracleScaleDownClusterStage);
+}
+
+registerOracleScaleDownClusterStage();

package/src/pipeline/stages/shrinkCluster/OracleShrinkClusterStageConfig.tsx

@@ -0,0 +1,136 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+} from '@spinnaker/core';
+
+function pluralize(str: string, val: number): string {
+  return val === 1 ? str : `${str}s`;
+}
+
+export function OracleShrinkClusterStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'oracle') {
+      changes.cloudProvider = 'oracle';
+    }
+    if (!stage.credentials && application.defaultCredentials?.oracle) {
+      changes.credentials = application.defaultCredentials.oracle;
+    }
+    if (!stage.regions?.length && application.defaultRegions?.oracle) {
+      changes.regions = [application.defaultRegions.oracle];
+    }
+    if (stage.shrinkToSize === undefined) {
+      changes.shrinkToSize = 1;
+    }
+    if (stage.allowDeleteActive === undefined) {
+      changes.allowDeleteActive = false;
+    }
+    if (stage.retainLargerOverNewer === undefined) {
+      changes.retainLargerOverNewer = 'false';
+    }
+    if (
+      stage.isNew &&
+      application.attributes.platformHealthOnlyShowOverride &&
+      application.attributes.platformHealthOnly &&
+      stage.interestingHealthProviderNames === undefined
+    ) {
+      changes.interestingHealthProviderNames = ['Oracle'];
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('oracle').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Shrink Options">
+        <div className="form-inline">
+          Shrink to{' '}
+          <input
+            className="form-control input-sm"
+            min={0}
+            onChange={(event) => updateStageField({ shrinkToSize: Number(event.target.value) })}
+            required
+            style={{ width: 50 }}
+            type="number"
+            value={stage.shrinkToSize ?? ''}
+          />{' '}
+          {pluralize('server group', stage.shrinkToSize)}, keeping the{' '}
+          <select
+            className="form-control input-sm"
+            onChange={(event) => updateStageField({ retainLargerOverNewer: event.target.value })}
+            value={stage.retainLargerOverNewer ?? 'false'}
+          >
+            <option value="true">largest</option>
+            <option value="false">newest</option>
+          </select>
+        </div>
+      </StageConfigField>
+      <div className="form-group">
+        <div className="col-md-offset-3 col-md-6 checkbox">
+          <label>
+            <input
+              checked={!!stage.allowDeleteActive}
+              onChange={(event) => updateStageField({ allowDeleteActive: event.target.checked })}
+              type="checkbox"
+            />
+            Allow deletion of active server groups
+          </label>
+        </div>
+      </div>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Oracle"
+          />
+        </StageConfigField>
+      )}
+    </div>
+  );
+}
+
+export const oracleShrinkClusterStage = {
+  key: 'shrinkCluster',
+  provides: 'shrinkCluster',
+  cloudProvider: 'oracle',
+  component: OracleShrinkClusterStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'shrinkToSize', fieldLabel: 'shrink to [X] Server Groups' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerOracleShrinkClusterStage() {
+  Registry.pipeline.registerStage(oracleShrinkClusterStage);
+}
+
+registerOracleShrinkClusterStage();

package/src/securityGroup/details/OracleSecurityGroupDetails.tsx

@@ -0,0 +1,19 @@
+import React from 'react';
+import { CollapsibleSection } from '@spinnaker/core';
+
+export function OracleSecurityGroupDetails({ resolvedSecurityGroup }: any) {
+  return (
+    <CollapsibleSection heading="Security Group Details" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <dt>Name</dt>
+        <dd>{resolvedSecurityGroup.name}</dd>
+        <dt>Account</dt>
+        <dd>{resolvedSecurityGroup.accountId}</dd>
+        <dt>Region</dt>
+        <dd>{resolvedSecurityGroup.region}</dd>
+        <dt>VCN</dt>
+        <dd>{resolvedSecurityGroup.vpcId}</dd>
+      </dl>
+    </CollapsibleSection>
+  );
+}