@spinnaker/tencentcloud 0.0.0-main-2

package/src/domain/ITencentcloudLoadBalancer.ts

@@ -0,0 +1,326 @@
+import type {
+  IInstance,
+  IInstanceCounts,
+  ILoadBalancer,
+  ILoadBalancerDeleteCommand,
+  ILoadBalancerUpsertCommand,
+  ISubnet,
+} from '@spinnaker/core';
+
+import type { ITencentcloudHealthCheck } from './ITencentcloudHealth';
+import type { ITencentcloudLoadBalancerSourceData } from './ITencentcloudLoadBalancerSourceData';
+import type { ITencentcloudServerGroup } from './ITencentcloudServerGroup';
+
+export type ClassicListenerProtocol = 'HTTP' | 'HTTPS' | 'TCP' | 'SSL';
+export type ALBListenerProtocol = 'HTTP' | 'HTTPS' | 'TCP' | 'UDP';
+export type IListenerActionType = 'forward' | 'authenticate-oidc' | 'redirect';
+export type NLBListenerProtocol = 'TCP';
+
+export interface IAuthenticateOidcActionConfig {
+  authorizationEndpoint: string;
+  authenticationRequestExtraParams?: any;
+  clientId: string;
+  clientSecret?: string;
+  idpLogoutUrl?: string;
+  issuer: string;
+  scope: string;
+  sessionCookieName: string;
+  sessionTimeout?: number;
+  tokenEndpoint: string;
+  userInfoEndpoint: string;
+}
+
+export interface ITencentcloudLoadBalancer extends ILoadBalancer {
+  loadBalancerType: any;
+  provider: any;
+  type: any;
+  instances: any[];
+  accountId?: string;
+  createTime?: string;
+  availabilityZones?: string[];
+  credentials?: string;
+  listeners?: any[];
+  detachedInstances?: IInstance[];
+  elb?: ITencentcloudLoadBalancerSourceData;
+  isInternal?: boolean;
+  loadBalacnerVips: string[];
+  regionZones: string[];
+  serverGroups: ITencentcloudServerGroup[];
+  subnets?: string[];
+  subnetDetails?: ISubnet[];
+  subnetType?: string;
+  subnetId?: string;
+  id?: string;
+  loadBalancerId?: string;
+}
+
+export interface IClassicListener {
+  internalProtocol: ClassicListenerProtocol;
+  internalPort: number;
+  externalProtocol: ClassicListenerProtocol;
+  externalPort: number;
+  sslCertificateType?: string;
+}
+
+export interface ITencentcloudClassicLoadBalancer extends ITencentcloudLoadBalancer {
+  region: any;
+  cloudProvider: any;
+  account: string;
+  name: any;
+  securityGroups: string[];
+  vpcId: string;
+  healthCheckPath: string;
+  healthCheckPort: number;
+  healthCheckProtocol: string;
+  healthTimeout: number;
+  healthInterval: number;
+  healthyThreshold: number;
+  listeners: IClassicListener[];
+  unhealthyThreshold: number;
+  idleTimeout?: number;
+}
+
+export interface ITencentcloudApplicationLoadBalancer extends ITencentcloudLoadBalancer {
+  loadBalancerType: string;
+  region: any;
+  cloudProvider: any;
+  account: string;
+  name: any;
+  securityGroups: any[];
+  vpcId: string;
+  listeners: IALBListener[];
+  application?: string;
+  targetGroups: ITargetGroup[];
+  ipAddressType?: string; // returned from clouddriver
+  deletionProtection: boolean;
+  idleTimeout: number;
+}
+
+export interface ITencentcloudNetworkLoadBalancer extends ITencentcloudLoadBalancer {
+  listeners: INLBListener[];
+  targetGroups: ITargetGroup[];
+  ipAddressType?: string; // returned from clouddriver
+  deletionProtection: boolean;
+  idleTimeout: number;
+}
+
+export interface IRedirectActionConfig {
+  host?: string;
+  path?: string;
+  port?: string;
+  protocol?: 'HTTP' | 'HTTPS' | '#{protocol}';
+  query?: string;
+  statusCode: 'HTTP_301' | 'HTTP_302';
+  [k: string]: any;
+}
+
+export interface IListenerAction {
+  authenticateOidcConfig?: IAuthenticateOidcActionConfig;
+  order?: number;
+  redirectActionConfig?: IRedirectActionConfig; // writes
+  redirectConfig?: IRedirectActionConfig; // reads
+  targetGroupName?: string;
+  type: IListenerActionType;
+  port?: number;
+}
+
+export interface IALBListenerCertificate {
+  sslMode?: string;
+  certId?: string;
+  certCaId?: string;
+  certificateArn: string;
+  type: string;
+  name: string;
+}
+
+export interface IALBListener {
+  certificates: IALBListenerCertificate[];
+  port: number;
+  protocol: string;
+  rules: IListenerRule[];
+  sslPolicy?: string;
+  listenerId?: string;
+  listenerName?: string;
+}
+
+export interface INLBListener {
+  certificates: IALBListenerCertificate[];
+  defaultActions: IListenerAction[];
+  port: number;
+  protocol: string;
+  rules: IListenerRule[];
+  sslPolicy?: string;
+}
+
+export interface IListenerRule {
+  domain: string;
+  url: string;
+  locationId?: string;
+  healthCheck?: ITencentcloudHealthCheck;
+  default?: boolean;
+  priority?: number | 'default';
+  [key: string]: any;
+}
+
+export type ListenerRuleConditionField = 'path-pattern' | 'host-header';
+
+export interface IListenerRuleCondition {
+  field: ListenerRuleConditionField;
+  values: string[];
+}
+
+export interface ITargetGroupAttributes {
+  deregistrationDelay: number;
+  stickinessEnabled: boolean;
+  stickinessType: string;
+  stickinessDuration: number;
+}
+
+export interface ITargetGroup {
+  account: string; // returned from clouddriver
+  attributes?: ITargetGroupAttributes;
+  cloudProvider: string; // returned from clouddriver
+  detachedInstances?: IInstance[];
+  healthCheckProtocol?: string;
+  healthCheckPort?: number;
+  healthCheckPath?: string;
+  healthTimeout?: number;
+  healthInterval?: number;
+  healthyThreshold?: number;
+  unhealthyThreshold?: number;
+  instanceCounts?: IInstanceCounts;
+  instances?: IInstance[];
+  loadBalancerNames?: string[]; // returned from clouddriver
+  name: string;
+  port?: number;
+  protocol?: string;
+  provider?: string;
+  region: string; // returned from clouddriver
+  serverGroups?: ITencentcloudServerGroup[];
+  targetType?: string;
+  type: string; // returned from clouddriver
+  vpcId?: string;
+  vpcName?: string;
+}
+
+export interface IListenerDescription {
+  defaultActions?: IListenerAction[];
+  isNew?: boolean;
+  certificates?: IALBListenerCertificate[];
+  certificate?: IALBListenerCertificate;
+  protocol: ALBListenerProtocol | NLBListenerProtocol;
+  port: number;
+  sslPolicy?: string;
+  rules?: IListenerRule[];
+  healthCheck?: ITencentcloudHealthCheck;
+  listenerName?: string;
+}
+
+export interface IALBTargetGroupDescription {
+  name: string;
+  protocol: 'HTTP' | 'HTTPS';
+  port: number;
+  targetType: 'instance' | 'ip';
+  attributes: {
+    // Defaults to 300
+    deregistrationDelay?: number;
+    // Defaults to false
+    stickinessEnabled?: boolean;
+    // Defaults to 'lb_cookie'. The only option for now, but they promise there will be more...
+    stickinessType?: 'lb_cookie';
+    // Defaults to 86400
+    stickinessDuration?: number;
+  };
+  // Defaults to 10
+  healthCheckInterval?: number;
+  // Defaults to '200-299'
+  healthCheckMatcher?: string;
+  healthCheckPath: string;
+  healthCheckPort: string;
+  healthCheckProtocol: 'HTTP' | 'HTTPS';
+  // Defaults to 10
+  healthyThreshold?: number;
+  // Defaults to 5
+  healthCheckTimeout?: number;
+  // Defaults to 2
+  unhealthyThreshold?: number;
+}
+
+export interface INLBTargetGroupDescription {
+  name: string;
+  protocol: 'TCP';
+  port: number;
+  targetType: 'instance' | 'ip';
+  attributes: {
+    // Defaults to 300
+    deregistrationDelay?: number;
+  };
+  // Defaults to 10
+  healthCheckInterval?: number;
+  healthCheckPort: string;
+  healthCheckProtocol: 'TCP' | 'HTTP' | 'HTTPS';
+  healthCheckPath: string;
+  // Defaults to 10
+  healthyThreshold?: number;
+  // Defaults to 5
+  healthCheckTimeout?: number;
+  // Defaults to 10
+  unhealthyThreshold?: number;
+}
+
+export interface ITencentcloudLoadBalancerUpsertCommand extends ILoadBalancerUpsertCommand {
+  securityGroupsRemoved?: string;
+  Firewalls?: string;
+  availabilityZones: { [region: string]: string[] };
+  isInternal: boolean;
+  // listeners will be overriden and re-typed by extending types (application, classic)
+  listeners: any[];
+  // If loadBalancerType is not provided, will default to 'classic' for bwc
+  loadBalancerType?: 'classic' | 'application' | 'network';
+  regionZones: string[];
+  securityGroups: string[];
+  subnetType: string;
+  usePreferredZones?: boolean;
+  vpcId: string;
+  application: string;
+}
+
+export interface ITencentcloudLoadBalancerDeleteCommand extends ILoadBalancerDeleteCommand {
+  loadBalancerId: string;
+  region: string;
+  account: string;
+  application: string;
+}
+
+export interface IClassicListenerDescription extends IClassicListener {
+  sslCertificateId?: string;
+  sslCertificateName?: string;
+}
+
+export interface ITencentcloudClassicLoadBalancerUpsertCommand extends ITencentcloudLoadBalancerUpsertCommand {
+  healthCheck: string;
+  healthCheckPath: string;
+  healthCheckProtocol: string;
+  healthCheckPort: number;
+  healthInterval?: number;
+  healthTimeout?: number;
+  healthyThreshold?: number;
+  listeners: IClassicListenerDescription[];
+  unhealthyThreshold?: number;
+  idleTimeout?: number;
+}
+
+export interface ITencentcloudApplicationLoadBalancerUpsertCommand extends ITencentcloudLoadBalancerUpsertCommand {
+  deletionProtection?: boolean;
+  idleTimeout?: number;
+  listener?: IListenerDescription[];
+  listeners: IListenerDescription[];
+  targetGroups?: IALBTargetGroupDescription[];
+  subnetId: string;
+}
+
+export interface ITencentcloudNetworkLoadBalancerUpsertCommand extends ITencentcloudLoadBalancerUpsertCommand {
+  deletionProtection: boolean;
+  listeners: IListenerDescription[];
+  targetGroups: INLBTargetGroupDescription[];
+}

package/src/domain/ITencentcloudLoadBalancerSourceData.ts

@@ -0,0 +1,189 @@
+import type { ILoadBalancerSourceData } from '@spinnaker/core';
+
+import type { IListenerAction, NLBListenerProtocol } from './ITencentcloudLoadBalancer';
+
+import type { IListenerRule } from './ITencentcloudLoadBalancer';
+
+export interface ITencentcloudContainerServerGroupSourceData {
+  detachedInstances: string[];
+  isDisabled: boolean;
+  name: string;
+  region: string;
+}
+
+export interface ITencentcloudLoadBalancerServerGroupSourceData extends ITencentcloudContainerServerGroupSourceData {
+  instances: ITencentcloudLoadBalancerInstanceSourceData[];
+}
+
+export interface ITencentcloudTargetGroupServerGroupSourceData extends ITencentcloudContainerServerGroupSourceData {
+  instances: ITencentcloudTargetGroupInstanceSourceData[];
+}
+
+export interface ITencentcloudInstanceHealthSourceData {
+  type: string;
+  state: 'InService' | 'OutOfService' | 'Unknown';
+  reasonCode: 'ELB' | 'Instance' | 'N/A';
+  description: string;
+}
+
+export interface ITencentcloudTargetHealthSourceData {
+  description: string;
+  reason: string;
+  state: 'initial' | 'healthy' | 'unhealthy' | 'unused' | 'draining';
+}
+
+export interface IClassicListenerSourceData {
+  instancePort: number;
+  instanceProtocol: string;
+  loadBalancerPort: number;
+  protocol: string;
+}
+
+export interface ITencentcloudLoadBalancerSourceData extends ILoadBalancerSourceData {
+  id?: string;
+  account: string;
+  availabilityZones: string[];
+  cloudProvider: string;
+  createdTime: number;
+  dnsname: string;
+  loadBalancerName: string;
+  loadBalancerType?: string;
+  name: string;
+  region: string;
+  scheme: 'internal' | 'internet-facing';
+  securityGroups: string[];
+  serverGroups: ITencentcloudLoadBalancerServerGroupSourceData[];
+  subnets: string[];
+  type: string;
+  vpcId: string;
+  // Some of the backend in clouddriver returns a vpcid (lowecase) only,
+  // and was cached with some of that. Until caches roll off and we are
+  // sure clouddriver is cleaed up, leave this dirtiness in here
+  vpcid?: string;
+}
+
+export interface ITencentcloudLoadBalancerInstanceSourceData {
+  id: string;
+  zone: string;
+  health: ITencentcloudInstanceHealthSourceData;
+}
+
+export interface ITencentcloudTargetGroupInstanceSourceData {
+  id: string;
+  zone: string;
+  health: ITencentcloudTargetHealthSourceData;
+}
+
+export interface ITencentcloudTargetGroupSourceData {
+  account: string;
+  attributes: {
+    'deregistration_delay.timeout_seconds': number;
+    'stickiness.enabled': boolean;
+    'stickiness.lb_cookie.duration_seconds': number;
+    'stickiness.type': 'lb_cookie';
+    'lambda.multi_value_headers.enabled': boolean;
+  };
+  cloudProvider: string;
+  healthCheckIntervalSeconds: number;
+  healthCheckPath: string;
+  healthCheckPort: string;
+  healthCheckProtocol: string;
+  healthCheckTimeoutSeconds: number;
+  healthyThresholdCount: number;
+  instances: string[];
+  loadBalancerNames: string[];
+  matcher: {
+    httpCode: string;
+  };
+  name: string;
+  port: number;
+  protocol: string;
+  region: string;
+  serverGroups: ITencentcloudTargetGroupServerGroupSourceData[];
+  targetGroupArn: string;
+  targetGroupName: string;
+  targetType: string;
+  type: string;
+  unhealthyThresholdCount: number;
+  vpcId: string;
+}
+
+export interface IApplicationLoadBalancerCertificateSourceData {
+  certificateArn: string;
+}
+
+export interface IApplicationLoadBalancerListenerSourceData {
+  certificates?: IApplicationLoadBalancerCertificateSourceData[];
+  defaultActions: IListenerAction[];
+  listenerArn: string;
+  loadBalancerName: string;
+  port: number;
+  protocol: 'HTTP' | 'HTTPS';
+  rules: IListenerRule[];
+  sslPolicy?: string;
+}
+
+export interface IApplicationLoadBalancerSourceData extends ITencentcloudLoadBalancerSourceData {
+  ipAddressType: 'ipv4' | 'dualstack';
+  listeners: IApplicationLoadBalancerListenerSourceData[];
+  loadBalancerArn: string;
+  loadBalancerType: 'application';
+  state: {
+    code: 'active' | 'provisioning' | 'failed';
+    reason?: string;
+  };
+  targetGroups: ITencentcloudTargetGroupSourceData[];
+}
+
+export interface INetworkLoadBalancerListenerSourceData {
+  certificates?: IApplicationLoadBalancerCertificateSourceData[];
+  defaultActions: Array<{
+    targetGroupName: string;
+    type: 'forward';
+  }>;
+  listenerArn: string;
+  loadBalancerName: string;
+  port: number;
+  protocol: NLBListenerProtocol;
+  rules: IListenerRule[];
+  sslPolicy?: string;
+}
+
+export interface INetworkLoadBalancerSourceData extends ITencentcloudLoadBalancerSourceData {
+  ipAddressType: 'ipv4' | 'dualstack';
+  listeners: INetworkLoadBalancerListenerSourceData[];
+  loadBalancerArn: string;
+  loadBalancerType: 'network';
+  state: {
+    code: 'active' | 'provisioning' | 'failed';
+    reason?: string;
+  };
+  targetGroups: ITencentcloudTargetGroupSourceData[];
+}
+
+export interface IClassicLoadBalancerSourceData extends ITencentcloudLoadBalancerSourceData {
+  healthCheck: {
+    healthyThreshold: number;
+    interval: number;
+    target: string;
+    timeout: number;
+    unhealthyThreshold: number;
+  };
+  instances: string[];
+  listenerDescriptions: Array<{ listener: IClassicListenerSourceData; policyNames: string[] }>;
+  policies: {
+    appCookieStickinessPolicies: Array<{
+      CookieName: string;
+      PolicyName: string;
+    }>;
+    lbcookieStickinessPolicies: Array<{
+      CookieExpirationPeriod: string;
+      PolicyName: string;
+    }>;
+    otherPolicies: any[];
+  };
+  sourceSecurityGroup: {
+    groupName: string;
+    ownerAlias: string;
+  };
+}

package/src/domain/ITencentcloudScalingPolicy.ts

@@ -0,0 +1,23 @@
+import type { IScalingPolicy, IScalingPolicyAlarm, IStepAdjustment } from './IScalingPolicy';
+
+export interface IScalingAdjustmentView extends IStepAdjustment {
+  operator: string;
+  absAdjustment: number;
+}
+
+export interface IScalingPolicyAlarmView extends IScalingPolicyAlarm {
+  name?: string;
+  description?: string;
+  comparator?: '<' | '>' | '≤' | '≥';
+}
+
+export interface IScalingPolicyView extends IScalingPolicy, IScalingAdjustmentView {
+  alarms: IScalingPolicyAlarmView[];
+  stepAdjustments: IStepAdjustmentView[];
+  operator: string;
+}
+
+export interface IStepAdjustmentView extends IScalingAdjustmentView, IStepAdjustment {
+  metricIntervalLowerBound: number;
+  metricIntervalUpperBound: number;
+}

package/src/domain/ITencentcloudServerGroup.ts

@@ -0,0 +1,46 @@
+import type { IAccountDetails, IAsg, IServerGroup } from '@spinnaker/core';
+
+import type { IScalingPolicyView, ISuspendedProcess } from '.';
+import type { IScalingPolicy } from './IScalingPolicy';
+
+export interface ITencentcloudAsg extends IAsg {
+  availabilityZones: string[];
+  defaultCooldown: number;
+  terminationPolicies: string[];
+  enabledMetrics: Array<{ metric: string }>;
+  vpczoneIdentifier?: string;
+  suspendedProcesses?: ISuspendedProcess[];
+  zoneSet?: string[];
+  terminationPolicySet: string[];
+  vpcId: string;
+  subnetIdSet: string[];
+  instanceCount?: string;
+}
+
+export interface ITencentcloudServerGroup extends IServerGroup {
+  [x: string]: any;
+  vpcName?: any;
+  image?: any;
+  scalingPolicies?: IScalingPolicy[];
+  targetGroups?: string[];
+  asg?: ITencentcloudAsg;
+  accountName?: string;
+  instanceCount?: number;
+}
+
+export interface IScheduledAction {
+  scheduledActionId?: string;
+  scheduledActionName?: string;
+  startTime?: string;
+  endTime?: string;
+  recurrence: number;
+  minSize: number;
+  maxSize: number;
+  desiredCapacity: number;
+}
+
+export interface ITencentcloudServerGroupView extends ITencentcloudServerGroup {
+  accountDetails?: IAccountDetails;
+  scalingPolicies: IScalingPolicyView[];
+  scheduledActions?: IScheduledAction[];
+}

package/src/domain/index.ts

@@ -0,0 +1,11 @@
+export * from './ITencentcloudCertificate';
+export * from './ITencentcloudInstance';
+export * from './ITencentcloudLoadBalancer';
+export * from './ITencentcloudLoadBalancerSourceData';
+export * from './ITencentcloudHealth';
+export * from './ITencentcloudScalingPolicy';
+export * from './ITencentcloudServerGroup';
+export * from './IKeyPair';
+export * from './IScalingPolicy';
+export * from './IScalingProcess';
+export * from './ITargetTrackingPolicy';

package/src/help/tencentcloud.help.ts

@@ -0,0 +1,5 @@
+import { HelpContentsRegistry } from '@spinnaker/core';
+
+const helpContents: { [key: string]: string } = {};
+
+Object.keys(helpContents).forEach((key) => HelpContentsRegistry.register(key, helpContents[key]));

package/src/image/image.reader.ts

@@ -0,0 +1,53 @@
+import { $q } from 'ngimport';
+
+import { REST } from '@spinnaker/core';
+export interface ITencentcloudSnapshot {
+  diskSize: string;
+  diskType: string;
+  diskUsage: 'SYSTEM_DISK' | 'DATA_DISK';
+  snapshotId: string;
+}
+export interface ITencentcloudImage {
+  accounts: string[];
+  images: {
+    [region: string]: string[];
+  };
+  imgIds: {
+    [region: string]: string[];
+  };
+  attributes: {
+    createdTime?: string;
+    creationDate?: string;
+    snapshotSet?: ITencentcloudSnapshot[];
+    osPlatform: string;
+  };
+  imageName: string;
+  tags: {
+    [tag: string]: string;
+  };
+  tagsByImageId: {
+    [imageId: string]: ITencentcloudImage['tags'];
+  };
+}
+
+export class TencentcloudImageReader {
+  public findImages(params: { q: string; region?: string }): PromiseLike<ITencentcloudImage[]> {
+    if (!params.q || params.q.length < 3) {
+      return $q.when([{ message: 'Please enter at least 3 characters...', disabled: true }]) as any;
+    }
+
+    return REST('/images/find')
+      .query({ ...params, provider: 'tencentcloud' })
+      .get()
+      .catch(() => [] as ITencentcloudImage[]);
+  }
+
+  public getImage(name: string, region: string, credentials: string): PromiseLike<ITencentcloudImage> {
+    return REST('/images')
+      .path(credentials, region, name)
+      .query({ provider: 'tencentcloud' })
+      .get()
+      .then((results: any[]) => (results && results.length ? results[0] : null))
+      .catch(() => null as ITencentcloudImage);
+  }
+}

package/src/image/index.ts

@@ -0,0 +1 @@
+export * from './image.reader';

package/src/index.ts

@@ -0,0 +1,2 @@
+export { TENCENTCLOUD_MODULE } from './tencentcloud.module';
+export * from './tencentcloud.settings';

package/src/keyPairs/KeyPairsReader.ts

@@ -0,0 +1,11 @@
+import { REST } from '@spinnaker/core';
+import type { IKeyPair } from '../domain';
+
+export class KeyPairsReader {
+  public static listKeyPairs(): PromiseLike<IKeyPair[]> {
+    return REST('/keyPairs')
+      .useCache()
+      .get()
+      .then((keyPairs: IKeyPair[]) => keyPairs.sort((a, b) => a.keyName.localeCompare(b.keyName)));
+  }
+}

package/src/keyPairs/index.ts

@@ -0,0 +1 @@
+export * from './KeyPairsReader';