@spinnaker/oracle 2026.2.2 → 2026.3.0

package/src/oracle.provider.spec.ts

@@ -0,0 +1,45 @@
+import { CloudProviderRegistry, Registry } from '@spinnaker/core';
+
+import './index';
+import { OracleImageReader } from './image/image.reader';
+import { OracleLoadBalancerTransformer } from './loadBalancer/loadBalancer.transformer';
+import { registerOraclePipelineStages } from './oracle.provider';
+import { OracleSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { OracleSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
+import { OracleServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { OracleServerGroupConfigurationService } from './serverGroup/configure/serverGroupConfiguration.service';
+import { OracleServerGroupTransformer } from './serverGroup/serverGroup.transformer';
+
+describe('Oracle provider registration', () => {
+  it('registers provider delegates', () => {
+    expect(CloudProviderRegistry.getValue('oracle', 'image.reader')).toBe(OracleImageReader);
+    expect(CloudProviderRegistry.getValue('oracle', 'loadBalancer.transformer')).toBe(OracleLoadBalancerTransformer);
+    expect(CloudProviderRegistry.getValue('oracle', 'serverGroup.transformer')).toBe(OracleServerGroupTransformer);
+    expect(CloudProviderRegistry.getValue('oracle', 'serverGroup.commandBuilder')).toBe(
+      OracleServerGroupCommandBuilder,
+    );
+    expect(CloudProviderRegistry.getValue('oracle', 'serverGroup.configurationService')).toBe(
+      OracleServerGroupConfigurationService,
+    );
+    expect(CloudProviderRegistry.getValue('oracle', 'securityGroup.reader')).toBe(OracleSecurityGroupReader);
+    expect(CloudProviderRegistry.getValue('oracle', 'securityGroup.transformer')).toBe(OracleSecurityGroupTransformer);
+
+    expect(CloudProviderRegistry.getValue('oracle', 'loadBalancer.details')).toBeNull();
+    expect(CloudProviderRegistry.getValue('oracle', 'serverGroup.detailsActions')).toBeDefined();
+    expect(CloudProviderRegistry.getValue('oracle', 'instance.details')).toBeDefined();
+    expect(CloudProviderRegistry.getValue('oracle', 'securityGroup.details')).toBeDefined();
+  });
+
+  it('registers Oracle pipeline stages during package import', () => {
+    Registry.reinitialize();
+    registerOraclePipelineStages();
+
+    const stages = Registry.pipeline.getStageTypes();
+
+    expect(stages.some((stage) => stage.provides === 'findImage' && stage.cloudProvider === 'oracle')).toBe(true);
+    expect(stages.some((stage) => stage.provides === 'resizeServerGroup' && stage.cloudProvider === 'oracle')).toBe(
+      true,
+    );
+    expect(stages.some((stage) => stage.provides === 'bake' && stage.cloudProvider === 'oracle')).toBe(true);
+  });
+});

package/src/oracle.provider.ts

@@ -0,0 +1,85 @@
+import type React from 'react';
+
+import { CloudProviderRegistry, DeploymentStrategyRegistry } from '@spinnaker/core';
+
+import './helpContents/oracleHelpContents';
+import { OracleImageReader } from './image/image.reader';
+import { OracleInstanceDetails } from './instance/details/OracleInstanceDetails';
+import {
+  OracleLoadBalancerDetailsSections,
+  useOracleLoadBalancerDetails,
+} from './loadBalancer/details/OracleLoadBalancerDetails';
+import { OracleLoadBalancerTransformer } from './loadBalancer/loadBalancer.transformer';
+import { registerOracleBakeStage } from './pipeline/stages/bake/OracleBakeStageConfig';
+import { registerOracleDestroyAsgStage } from './pipeline/stages/destroyAsg/OracleDestroyAsgStageConfig';
+import { registerOracleDisableAsgStage } from './pipeline/stages/disableAsg/OracleDisableAsgStageConfig';
+import { registerOracleFindAmiStage } from './pipeline/stages/findAmi/OracleFindAmiStageConfig';
+import { registerOracleFindImageFromTagsStage } from './pipeline/stages/findImageFromTags/OracleFindImageFromTagsStageConfig';
+import { registerOracleResizeAsgStage } from './pipeline/stages/resizeAsg/OracleResizeAsgStageConfig';
+import { registerOracleScaleDownClusterStage } from './pipeline/stages/scaleDownCluster/OracleScaleDownClusterStageConfig';
+import { registerOracleShrinkClusterStage } from './pipeline/stages/shrinkCluster/OracleShrinkClusterStageConfig';
+import { OracleSecurityGroupDetails } from './securityGroup/details/OracleSecurityGroupDetails';
+import { OracleSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { OracleSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
+import { OracleServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { OracleServerGroupConfigurationService } from './serverGroup/configure/serverGroupConfiguration.service';
+import {
+  OracleServerGroupActions,
+  oracleServerGroupDetailsGetter,
+  OracleServerGroupInformationSection,
+  OracleServerGroupLaunchConfigSection,
+  OracleServerGroupSizeSection,
+} from './serverGroup/details/OracleServerGroupDetails';
+import { OracleServerGroupTransformer } from './serverGroup/serverGroup.transformer';
+
+export function registerOracleProvider(): void {
+  CloudProviderRegistry.registerProvider('oracle', {
+    name: 'Oracle',
+    image: {
+      reader: OracleImageReader,
+    },
+    loadBalancer: {
+      transformer: OracleLoadBalancerTransformer,
+      useDetailsHook: useOracleLoadBalancerDetails,
+      detailsActions: function OracleLoadBalancerActions(): React.ReactElement | null {
+        return null;
+      },
+      detailsSections: OracleLoadBalancerDetailsSections,
+    },
+    serverGroup: {
+      transformer: OracleServerGroupTransformer,
+      detailsActions: OracleServerGroupActions,
+      detailsGetter: oracleServerGroupDetailsGetter,
+      detailsSections: [
+        OracleServerGroupInformationSection,
+        OracleServerGroupSizeSection,
+        OracleServerGroupLaunchConfigSection,
+      ],
+      // Oracle does not provide a create or clone modal.
+      commandBuilder: OracleServerGroupCommandBuilder,
+      configurationService: OracleServerGroupConfigurationService,
+    },
+    instance: {
+      details: OracleInstanceDetails,
+    },
+    securityGroup: {
+      reader: OracleSecurityGroupReader,
+      transformer: OracleSecurityGroupTransformer,
+      details: OracleSecurityGroupDetails,
+    },
+  });
+}
+
+export function registerOraclePipelineStages(): void {
+  registerOracleBakeStage();
+  registerOracleDestroyAsgStage();
+  registerOracleDisableAsgStage();
+  registerOracleFindAmiStage();
+  registerOracleFindImageFromTagsStage();
+  registerOracleResizeAsgStage();
+  registerOracleScaleDownClusterStage();
+  registerOracleShrinkClusterStage();
+}
+
+registerOracleProvider();
+DeploymentStrategyRegistry.registerProvider('oracle', []);

package/src/pipeline/stages/bake/OracleBakeStageConfig.tsx

@@ -0,0 +1,325 @@
+import React from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountService,
+  AuthenticationService,
+  BakeExecutionLabel,
+  BakeryReader,
+  ExecutionDetailsTasks,
+  HelpField,
+  Registry,
+  StageConfigField,
+} from '@spinnaker/core';
+
+interface IBaseOsOption {
+  id: string;
+  shortDescription?: string;
+  detailedDescription?: string;
+}
+
+interface IOracleBakeStageState {
+  accounts: IAccount[];
+  baseOsOptions: IBaseOsOption[];
+  extendedAttributeKey: string;
+  extendedAttributeValue: string;
+  loading: boolean;
+}
+
+function baseOsDescription(baseOsOption: IBaseOsOption): string {
+  return baseOsOption.id + (baseOsOption.shortDescription ? ` (${baseOsOption.shortDescription})` : '');
+}
+
+export class OracleBakeStageConfig extends React.Component<IStageConfigProps, IOracleBakeStageState> {
+  private mounted = false;
+
+  public state: IOracleBakeStageState = {
+    accounts: [],
+    baseOsOptions: [],
+    extendedAttributeKey: '',
+    extendedAttributeValue: '',
+    loading: true,
+  };
+
+  public componentDidMount(): void {
+    this.mounted = true;
+    const stage = this.props.stage as any;
+    if (!stage.cloudProvider) {
+      this.props.updateStageField({ cloudProvider: 'oracle', cloudProviderType: 'oracle' });
+    }
+
+    Promise.all([BakeryReader.getBaseOsOptions('oracle'), AccountService.listAccounts('oracle')]).then(
+      ([baseOsOptions, accounts]) => {
+        if (!this.mounted) {
+          return;
+        }
+
+        const changes: Record<string, any> = {};
+        if (!stage.user) {
+          changes.user = AuthenticationService.getAuthenticatedUser()?.name;
+        }
+        if (!stage.upgrade) {
+          changes.upgrade = true;
+        }
+        if (!stage.baseOs && baseOsOptions.baseImages.length > 0) {
+          changes.baseOs = baseOsOptions.baseImages[0].id;
+        }
+        if (Object.keys(changes).length) {
+          this.props.updateStageField(changes);
+        }
+
+        if (stage.accountName) {
+          this.loadRegionForAccount(stage.accountName);
+        }
+
+        this.setState({ accounts, baseOsOptions: baseOsOptions.baseImages, loading: false });
+      },
+    );
+  }
+
+  public componentWillUnmount(): void {
+    this.mounted = false;
+  }
+
+  private loadRegionForAccount(accountName: string): void {
+    AccountService.getRegionsForAccount(accountName).then((regions) => {
+      if (this.mounted && Array.isArray(regions) && regions.length) {
+        this.props.updateStageField({ region: regions[0].name });
+      }
+    });
+  }
+
+  private accountChanged = (accountName: string): void => {
+    this.props.updateStageField({ accountName });
+    this.loadRegionForAccount(accountName);
+  };
+
+  private updateExtendedAttribute(key: string, value: string): void {
+    const stage = this.props.stage as any;
+    this.props.updateStageField({ extendedAttributes: { ...(stage.extendedAttributes || {}), [key]: value } });
+  }
+
+  private removeExtendedAttribute(key: string): void {
+    const stage = this.props.stage as any;
+    const extendedAttributes = { ...(stage.extendedAttributes || {}) };
+    delete extendedAttributes[key];
+    this.props.updateStageField({ extendedAttributes });
+  }
+
+  private addExtendedAttribute = (): void => {
+    const key = this.state.extendedAttributeKey.trim();
+    if (!key) {
+      return;
+    }
+    this.updateExtendedAttribute(key, this.state.extendedAttributeValue);
+    this.setState({ extendedAttributeKey: '', extendedAttributeValue: '' });
+  };
+
+  public render() {
+    if (this.state.loading) {
+      return <div className="horizontal center middle">Loading...</div>;
+    }
+
+    const stage = this.props.stage as any;
+    const extendedAttributes = stage.extendedAttributes || {};
+
+    return (
+      <div className="form-horizontal">
+        <StageConfigField label="Oracle Account" helpKey="oracle.pipeline.config.bake.account_name">
+          <select
+            className="form-control input-sm"
+            onChange={(event) => this.accountChanged(event.target.value)}
+            value={stage.accountName || ''}
+          >
+            <option value="" />
+            {this.state.accounts.map((account) => (
+              <option key={account.name} value={account.name}>
+                {account.name}
+              </option>
+            ))}
+          </select>
+        </StageConfigField>
+        <StageConfigField label="Region" helpKey="oracle.pipeline.config.bake.regions">
+          <input className="form-control input-sm" readOnly={true} value={stage.region || ''} />
+        </StageConfigField>
+        <StageConfigField label="Base Image" helpKey="oracle.pipeline.config.bake.baseOsOption">
+          {this.state.baseOsOptions.map((baseImage) => (
+            <div className="radio" key={baseImage.id}>
+              <label>
+                <input
+                  checked={stage.baseOs === baseImage.id}
+                  onChange={() => this.props.updateStageField({ baseOs: baseImage.id })}
+                  type="radio"
+                />
+                {baseOsDescription(baseImage)} <HelpField content={baseImage.detailedDescription} />
+              </label>
+            </div>
+          ))}
+        </StageConfigField>
+        <StageConfigField label="Image Name" helpKey="oracle.pipeline.config.bake.image_name">
+          <input
+            className="form-control input-sm"
+            onChange={(event) => this.props.updateStageField({ amiName: event.target.value })}
+            value={stage.amiName || ''}
+          />
+        </StageConfigField>
+        <StageConfigField label="Package" helpKey="oracle.pipeline.config.bake.package">
+          <input
+            className="form-control input-sm"
+            onChange={(event) => this.props.updateStageField({ package: event.target.value })}
+            value={stage.package || ''}
+          />
+        </StageConfigField>
+        <StageConfigField label="Rebake" helpKey="execution.forceRebake">
+          <div className="checkbox" style={{ marginBottom: 0 }}>
+            <label>
+              <input
+                checked={!!stage.rebake}
+                onChange={(event) => this.props.updateStageField({ rebake: event.target.checked })}
+                type="checkbox"
+              />
+              Rebake image without regard to the status of any existing bake
+            </label>
+          </div>
+        </StageConfigField>
+        <div className="form-group">
+          <div className="col-md-9 col-md-offset-1">
+            <div className="checkbox">
+              <label>
+                <input
+                  checked={!!stage.showAdvancedOptions}
+                  onChange={(event) => this.props.updateStageField({ showAdvancedOptions: event.target.checked })}
+                  type="checkbox"
+                />
+                <strong>Show Advanced Options</strong>
+              </label>
+            </div>
+          </div>
+        </div>
+        {stage.showAdvancedOptions && (
+          <>
+            <StageConfigField label="Template File Name" helpKey="pipeline.config.bake.templateFileName">
+              <input
+                className="form-control input-sm"
+                onChange={(event) => this.props.updateStageField({ templateFileName: event.target.value })}
+                value={stage.templateFileName || ''}
+              />
+            </StageConfigField>
+            <StageConfigField label="Var File Name" helpKey="pipeline.config.bake.varFileName">
+              <input
+                className="form-control input-sm"
+                onChange={(event) => this.props.updateStageField({ varFileName: event.target.value })}
+                value={stage.varFileName || ''}
+              />
+            </StageConfigField>
+            <StageConfigField label="Extended Attributes" helpKey="pipeline.config.bake.extendedAttributes">
+              <table className="table table-condensed packed">
+                <thead>
+                  <tr>
+                    <th style={{ width: '40%' }}>Key</th>
+                    <th style={{ width: '60%' }}>Value</th>
+                    <th className="text-right">Actions</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {Object.keys(extendedAttributes).map((key) => (
+                    <tr key={key}>
+                      <td>
+                        <strong className="small">{key}</strong>
+                      </td>
+                      <td>
+                        <input
+                          className="form-control input-sm"
+                          onChange={(event) => this.updateExtendedAttribute(key, event.target.value)}
+                          value={extendedAttributes[key]}
+                        />
+                      </td>
+                      <td className="text-right">
+                        <a
+                          className="small"
+                          href=""
+                          onClick={(event) => {
+                            event.preventDefault();
+                            this.removeExtendedAttribute(key);
+                          }}
+                        >
+                          Remove
+                        </a>
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+                <tfoot>
+                  <tr>
+                    <td>
+                      <input
+                        className="form-control input-sm"
+                        onChange={(event) => this.setState({ extendedAttributeKey: event.target.value })}
+                        placeholder="Key"
+                        value={this.state.extendedAttributeKey}
+                      />
+                    </td>
+                    <td>
+                      <input
+                        className="form-control input-sm"
+                        onChange={(event) => this.setState({ extendedAttributeValue: event.target.value })}
+                        placeholder="Value"
+                        value={this.state.extendedAttributeValue}
+                      />
+                    </td>
+                    <td className="text-right">
+                      <button
+                        className="btn btn-block btn-sm add-new"
+                        onClick={this.addExtendedAttribute}
+                        type="button"
+                      >
+                        <span className="glyphicon glyphicon-plus-sign" /> Add Extended Attribute
+                      </button>
+                    </td>
+                  </tr>
+                </tfoot>
+              </table>
+            </StageConfigField>
+            <StageConfigField label="Upgrade" helpKey="oracle.pipeline.config.bake.upgrade">
+              <label className="checkbox-inline">
+                <input
+                  checked={!!stage.upgrade}
+                  onChange={(event) => this.props.updateStageField({ upgrade: event.target.checked })}
+                  type="checkbox"
+                />
+                Perform a package manager upgrade before proceeding with the package installation
+              </label>
+            </StageConfigField>
+          </>
+        )}
+      </div>
+    );
+  }
+}
+
+export const oracleBakeStage = {
+  key: 'bake',
+  provides: 'bake',
+  cloudProvider: 'oracle',
+  label: 'Bake',
+  description: 'Bakes an image',
+  component: OracleBakeStageConfig,
+  executionDetailsSections: [ExecutionDetailsTasks],
+  executionLabelComponent: BakeExecutionLabel,
+  supportsCustomTimeout: true,
+  validators: [
+    { type: 'requiredField', fieldName: 'accountName' },
+    { type: 'requiredField', fieldName: 'region' },
+    { type: 'requiredField', fieldName: 'baseOs' },
+    { type: 'requiredField', fieldName: 'upgrade' },
+    { type: 'requiredField', fieldName: 'cloudProviderType' },
+    { type: 'requiredField', fieldName: 'amiName', fieldLabel: 'Image Name' },
+  ],
+  restartable: true,
+};
+
+export function registerOracleBakeStage() {
+  Registry.pipeline.registerStage(oracleBakeStage);
+}
+
+registerOracleBakeStage();

package/src/pipeline/stages/destroyAsg/OracleDestroyAsgStageConfig.tsx

@@ -0,0 +1,87 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  Registry,
+  StageConfigField,
+  StageConstants,
+  TargetSelect,
+} from '@spinnaker/core';
+
+export function OracleDestroyAsgStageConfig(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.target) {
+      changes.target = StageConstants.TARGET_LIST[0].val;
+    }
+    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="Target">
+        <TargetSelect
+          model={{ target: stage.target }}
+          onChange={(target: string) => updateStageField({ target })}
+          options={StageConstants.TARGET_LIST}
+        />
+      </StageConfigField>
+    </div>
+  );
+}
+
+export const oracleDestroyAsgStage = {
+  key: 'destroyServerGroup',
+  provides: 'destroyServerGroup',
+  cloudProvider: 'oracle',
+  component: OracleDestroyAsgStageConfig,
+  validators: [
+    {
+      type: 'targetImpedance',
+      message:
+        'This pipeline will attempt to destroy a server group without deploying a new version into the same cluster.',
+    },
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerOracleDestroyAsgStage() {
+  Registry.pipeline.registerStage(oracleDestroyAsgStage);
+}
+
+registerOracleDestroyAsgStage();

package/src/pipeline/stages/disableAsg/OracleDisableAsgStageConfig.tsx

@@ -0,0 +1,105 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+  StageConstants,
+  TargetSelect,
+} from '@spinnaker/core';
+
+export function OracleDisableAsgStageConfig(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.target) {
+      changes.target = StageConstants.TARGET_LIST[0].val;
+    }
+    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="Target">
+        <TargetSelect
+          model={{ target: stage.target }}
+          onChange={(target: string) => updateStageField({ target })}
+          options={StageConstants.TARGET_LIST}
+        />
+      </StageConfigField>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Oracle"
+          />
+        </StageConfigField>
+      )}
+    </div>
+  );
+}
+
+export const oracleDisableAsgStage = {
+  key: 'disableServerGroup',
+  provides: 'disableServerGroup',
+  cloudProvider: 'oracle',
+  component: OracleDisableAsgStageConfig,
+  validators: [
+    {
+      type: 'targetImpedance',
+      message:
+        'This pipeline will attempt to disable a server group without deploying a new version into the same cluster.',
+    },
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerOracleDisableAsgStage() {
+  Registry.pipeline.registerStage(oracleDisableAsgStage);
+}
+
+registerOracleDisableAsgStage();