@controlplane/schema 1.0.4 → 1.0.5

package/build/src/interfaces/workload.d.ts

@@ -1,9 +1,9 @@
 import { Port } from './port';
 import { EnvVar } from './env';
 import { VolumeSpec } from './volumeSpec';
+import { Regex, Kind, Tags, Links } from './base';
 import { DefaultOptions, LocalOptions } from './workloadOptions';
 import { EnvoyFilters } from './envoy';
-import { Kind, Tags, Links } from './base';
 export type Memory = string;
 export type Cpu = string;
 export interface HealthCheckSpec {
@@ -36,15 +36,28 @@ export interface RolloutOptions {
     maxUnavailableReplicas?: string;
     maxSurgeReplicas?: string;
     scalingPolicy?: 'OrderedReady' | 'Parallel';
+    terminationGracePeriodSeconds?: number;
+}
+export interface RolloutOptionsStateful {
+    minReadySeconds?: number;
+    maxSurgeReplicas?: string;
+    scalingPolicy?: 'OrderedReady' | 'Parallel';
+    terminationGracePeriodSeconds?: number;
+    maxUnavailableReplicas?: string;
 }
 export interface SecurityOptions {
     filesystemGroupId?: number;
 }
 export interface GpuResource {
-    nvidia: {
+    nvidia?: {
         model?: any;
         quantity?: number;
     };
+    custom?: {
+        resource: string;
+        runtimeClass?: string;
+        quantity?: number;
+    };
 }
 export interface ContainerSpec {
     name?: string;
@@ -115,10 +128,15 @@ export interface ContainerSpec {
     minMemory?: string;
     env?: EnvVar[];
     gpu?: {
-        nvidia: {
+        nvidia?: {
             model?: any;
             quantity?: number;
         };
+        custom?: {
+            resource: string;
+            runtimeClass?: string;
+            quantity?: number;
+        };
     };
     inheritEnv?: boolean;
     command?: string;
@@ -146,6 +164,10 @@ export interface HealthCheckStatus {
     successes?: number;
     lastChecked?: Date;
 }
+export interface LoadBalancerStatus {
+    origin?: string;
+    url?: string;
+}
 export interface ResolvedImage {
     digest?: string;
     manifests?: {
@@ -161,6 +183,7 @@ export interface ResolvedImages {
     resolvedForVersion?: number;
     resolvedAt?: Date;
     errorMessages?: string[];
+    nextRetryAt?: Date;
     images?: ResolvedImage[];
 }
 export interface WorkloadStatus {
@@ -171,17 +194,28 @@ export interface WorkloadStatus {
     healthCheck?: HealthCheckStatus;
     currentReplicaCount?: number;
     resolvedImages?: ResolvedImages;
+    loadBalancer?: LoadBalancerStatus[];
     [x: string]: any;
 }
+export interface HeaderFilter {
+    key: string;
+    allowedValues?: Regex[];
+    blockedValues?: Regex[];
+}
 export interface FirewallSpec {
     external?: {
         inboundAllowCIDR?: string[];
+        inboundBlockedCIDR?: string[];
         outboundAllowHostname?: string[];
         outboundAllowPort?: ({
             protocol: 'http' | 'https' | 'tcp';
             number: number;
         })[];
         outboundAllowCIDR?: string[];
+        outboundBlockedCIDR?: string[];
+        http?: {
+            inboundHeaderFilter?: HeaderFilter[];
+        };
     };
     internal?: {
         inboundAllowType?: 'none' | 'same-gvc' | 'same-org' | 'workload-list';
@@ -196,19 +230,57 @@ export interface JobSpec {
     restartPolicy?: 'OnFailure' | 'Never';
     activeDeadlineSeconds?: number;
 }
+export interface LoadBalancerPort {
+    externalPort: number;
+    protocol: 'TCP' | 'UDP';
+    scheme?: 'http' | 'tcp' | 'https' | 'ws' | 'wss';
+    containerPort?: number;
+}
+export interface LoadBalancerSpec {
+    direct?: {
+        enabled: boolean;
+        ports?: LoadBalancerPort[];
+        ipSet?: string;
+    };
+    geoLocation?: {
+        enabled?: boolean;
+        headers?: {
+            asn?: string;
+            city?: string;
+            country?: string;
+            region?: string;
+        };
+    };
+    replicaDirect?: boolean;
+}
+export interface Extras {
+    affinity?: any;
+    tolerations?: any[];
+    topologySpreadConstraints?: any[];
+}
+export interface RequestRetryPolicy {
+    attempts?: number;
+    retryOn?: string[];
+}
+export type WorkloadType = 'serverless' | 'standard' | 'cron' | 'stateful';
 export interface WorkloadSpec {
-    type?: 'serverless' | 'standard' | 'cron' | 'stateful';
+    type?: WorkloadType;
     identityLink?: string;
-    containers?: ContainerSpec[];
+    containers: ContainerSpec[];
     firewallConfig?: {
         external?: {
             inboundAllowCIDR?: string[];
+            inboundBlockedCIDR?: string[];
             outboundAllowHostname?: string[];
             outboundAllowPort?: ({
                 protocol: 'http' | 'https' | 'tcp';
                 number: number;
             })[];
             outboundAllowCIDR?: string[];
+            outboundBlockedCIDR?: string[];
+            http?: {
+                inboundHeaderFilter?: HeaderFilter[];
+            };
         };
         internal?: {
             inboundAllowType?: 'none' | 'same-gvc' | 'same-org' | 'workload-list';
@@ -228,15 +300,36 @@ export interface WorkloadSpec {
         envoy?: EnvoyFilters;
     };
     supportDynamicTags?: boolean;
-    rolloutOptions?: {
-        minReadySeconds?: number;
-        maxUnavailableReplicas?: string;
-        maxSurgeReplicas?: string;
-        scalingPolicy?: 'OrderedReady' | 'Parallel';
-    };
+    rolloutOptions?: any;
     securityOptions?: {
         filesystemGroupId?: number;
     };
+    loadBalancer?: {
+        direct?: {
+            enabled: boolean;
+            ports?: LoadBalancerPort[];
+            ipSet?: string;
+        };
+        geoLocation?: {
+            enabled?: boolean;
+            headers?: {
+                asn?: string;
+                city?: string;
+                country?: string;
+                region?: string;
+            };
+        };
+        replicaDirect?: boolean;
+    };
+    extras?: {
+        affinity?: any;
+        tolerations?: any[];
+        topologySpreadConstraints?: any[];
+    };
+    requestRetryPolicy?: {
+        attempts?: number;
+        retryOn?: string[];
+    };
 }
 export interface Workload {
     id?: string;
@@ -248,13 +341,93 @@ export interface Workload {
     lastModified?: Date;
     links?: Links;
     name?: string;
-    gvc?: any;
-    spec?: WorkloadSpec;
+    gvc?: string;
+    spec: {
+        type?: WorkloadType;
+        identityLink?: string;
+        containers: ContainerSpec[];
+        firewallConfig?: {
+            external?: {
+                inboundAllowCIDR?: string[];
+                inboundBlockedCIDR?: string[];
+                outboundAllowHostname?: string[];
+                outboundAllowPort?: ({
+                    protocol: 'http' | 'https' | 'tcp';
+                    number: number;
+                })[];
+                outboundAllowCIDR?: string[];
+                outboundBlockedCIDR?: string[];
+                http?: {
+                    inboundHeaderFilter?: HeaderFilter[];
+                };
+            };
+            internal?: {
+                inboundAllowType?: 'none' | 'same-gvc' | 'same-org' | 'workload-list';
+                inboundAllowWorkload?: string[];
+            };
+        };
+        defaultOptions?: DefaultOptions;
+        localOptions?: LocalOptions;
+        job?: {
+            schedule: ScheduleType;
+            concurrencyPolicy?: 'Forbid' | 'Replace';
+            historyLimit?: number;
+            restartPolicy?: 'OnFailure' | 'Never';
+            activeDeadlineSeconds?: number;
+        };
+        sidecar?: {
+            envoy?: EnvoyFilters;
+        };
+        supportDynamicTags?: boolean;
+        rolloutOptions?: any;
+        securityOptions?: {
+            filesystemGroupId?: number;
+        };
+        loadBalancer?: {
+            direct?: {
+                enabled: boolean;
+                ports?: LoadBalancerPort[];
+                ipSet?: string;
+            };
+            geoLocation?: {
+                enabled?: boolean;
+                headers?: {
+                    asn?: string;
+                    city?: string;
+                    country?: string;
+                    region?: string;
+                };
+            };
+            replicaDirect?: boolean;
+        };
+        extras?: {
+            affinity?: any;
+            tolerations?: any[];
+            topologySpreadConstraints?: any[];
+        };
+        requestRetryPolicy?: {
+            attempts?: number;
+            retryOn?: string[];
+        };
+    };
     status?: WorkloadStatus;
 }
+export interface PodZoneMap {
+    [x: string]: string;
+}
 export interface WorkloadConfig {
     scheduling?: {
         fingerprint?: string;
         version?: number;
     };
+    thinProvision?: number;
+    podZoneMap?: {
+        [x: string]: string;
+    };
+    locationPodZoneMap?: {
+        [x: string]: PodZoneMap;
+    };
+    subsets?: {
+        enabled?: boolean;
+    };
 }

package/build/src/interfaces/workloadOptions.d.ts

@@ -1,18 +1,78 @@
-export interface Options {
+export interface KedaTrigger {
+    type: string;
+    metadata?: {
+        [x: string]: string;
+    };
+    name?: string;
+    useCachedMetrics?: boolean;
+    metricType?: 'AverageValue' | 'Value' | 'Utilization';
+}
+export interface DefaultOptions {
     autoscaling?: {
-        metric?: 'concurrency' | 'cpu' | 'rps' | 'latency' | 'disabled';
-        metricPercentile?: any;
+        metric?: 'concurrency' | 'cpu' | 'memory' | 'rps' | 'latency' | 'keda' | 'disabled';
+        multi?: {
+            metric?: any;
+            target?: number;
+        }[];
+        metricPercentile?: 'p50' | 'p75' | 'p99';
         target?: number;
         maxScale?: number;
         minScale?: number;
         scaleToZeroDelay?: number;
         maxConcurrency?: number;
+        keda?: {
+            triggers?: KedaTrigger[];
+            advanced?: {
+                scalingModifiers?: {
+                    target?: string;
+                    activationTarget?: string;
+                    metricType?: 'AverageValue' | 'Value' | 'Utilization';
+                    formula?: string;
+                };
+            };
+        };
     };
     timeoutSeconds?: number;
     capacityAI?: boolean;
     spot?: boolean;
     debug?: boolean;
     suspend?: boolean;
+    multiZone?: {
+        enabled?: boolean;
+    };
 }
-export type DefaultOptions = any;
-export type LocalOptions = any[];
+export type LocalOptions = ({
+    autoscaling?: {
+        metric?: 'concurrency' | 'cpu' | 'memory' | 'rps' | 'latency' | 'keda' | 'disabled';
+        multi?: {
+            metric?: any;
+            target?: number;
+        }[];
+        metricPercentile?: 'p50' | 'p75' | 'p99';
+        target?: number;
+        maxScale?: number;
+        minScale?: number;
+        scaleToZeroDelay?: number;
+        maxConcurrency?: number;
+        keda?: {
+            triggers?: KedaTrigger[];
+            advanced?: {
+                scalingModifiers?: {
+                    target?: string;
+                    activationTarget?: string;
+                    metricType?: 'AverageValue' | 'Value' | 'Utilization';
+                    formula?: string;
+                };
+            };
+        };
+    };
+    timeoutSeconds?: number;
+    capacityAI?: boolean;
+    spot?: boolean;
+    debug?: boolean;
+    suspend?: boolean;
+    multiZone?: {
+        enabled?: boolean;
+    };
+    location: string;
+})[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@controlplane/schema",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Control Plane Corporation Schema",
   "scripts": {
     "build": "tsc",