diff --git a/.changelog/36.txt b/.changelog/36.txt new file mode 100644 index 0000000..3a5f02c --- /dev/null +++ b/.changelog/36.txt @@ -0,0 +1,3 @@ +```release-note:improvement +k8s: Update protobuf files for k8s v1.29.2 +``` diff --git a/src/components/protos/k8s.io/api/batch/v1/generated_pb.ts b/src/components/protos/k8s.io/api/batch/v1/generated_pb.ts index a1bd6bf..9d28976 100644 --- a/src/components/protos/k8s.io/api/batch/v1/generated_pb.ts +++ b/src/components/protos/k8s.io/api/batch/v1/generated_pb.ts @@ -588,6 +588,38 @@ export class JobSpec extends Message { */ backoffLimit?: number; + /** + * Specifies the limit for the number of retries within an + * index before marking this index as failed. When enabled the number of + * failures per index is kept in the pod's + * batch.kubernetes.io/job-index-failure-count annotation. It can only + * be set when Job's completionMode=Indexed, and the Pod's restart + * policy is Never. The field is immutable. + * This field is beta-level. It can be used when the `JobBackoffLimitPerIndex` + * feature gate is enabled (enabled by default). + * +optional + * + * @generated from field: optional int32 backoffLimitPerIndex = 12; + */ + backoffLimitPerIndex?: number; + + /** + * Specifies the maximal number of failed indexes before marking the Job as + * failed, when backoffLimitPerIndex is set. Once the number of failed + * indexes exceeds this number the entire Job is marked as Failed and its + * execution is terminated. When left as null the job continues execution of + * all of its indexes and is marked with the `Complete` Job condition. + * It can only be specified when backoffLimitPerIndex is set. + * It can be null or up to completions. It is required and must be + * less than or equal to 10^4 when is completions greater than 10^5. + * This field is beta-level. It can be used when the `JobBackoffLimitPerIndex` + * feature gate is enabled (enabled by default). + * +optional + * + * @generated from field: optional int32 maxFailedIndexes = 13; + */ + maxFailedIndexes?: number; + /** * A label query over pods that should match the pod count. * Normally, the system sets this field for you. @@ -682,6 +714,24 @@ export class JobSpec extends Message { */ suspend?: boolean; + /** + * podReplacementPolicy specifies when to create replacement Pods. + * Possible values are: + * - TerminatingOrFailed means that we recreate pods + * when they are terminating (has a metadata.deletionTimestamp) or failed. + * - Failed means to wait until a previously created Pod is fully terminated (has phase + * Failed or Succeeded) before creating a replacement Pod. + * + * When using podFailurePolicy, Failed is the the only allowed value. + * TerminatingOrFailed and Failed are allowed values when podFailurePolicy is not in use. + * This is an beta field. To use this, enable the JobPodReplacementPolicy feature toggle. + * This is on by default. + * +optional + * + * @generated from field: optional string podReplacementPolicy = 14; + */ + podReplacementPolicy?: string; + constructor(data?: PartialMessage) { super(); proto2.util.initPartial(data, this); @@ -695,12 +745,15 @@ export class JobSpec extends Message { { no: 3, name: "activeDeadlineSeconds", kind: "scalar", T: 3 /* ScalarType.INT64 */, opt: true }, { no: 11, name: "podFailurePolicy", kind: "message", T: PodFailurePolicy, opt: true }, { no: 7, name: "backoffLimit", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, + { no: 12, name: "backoffLimitPerIndex", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, + { no: 13, name: "maxFailedIndexes", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, { no: 4, name: "selector", kind: "message", T: LabelSelector, opt: true }, { no: 5, name: "manualSelector", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, { no: 6, name: "template", kind: "message", T: PodTemplateSpec, opt: true }, { no: 8, name: "ttlSecondsAfterFinished", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, { no: 9, name: "completionMode", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 10, name: "suspend", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, + { no: 14, name: "podReplacementPolicy", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): JobSpec { @@ -789,6 +842,18 @@ export class JobStatus extends Message { */ failed?: number; + /** + * The number of pods which are terminating (in phase Pending or Running + * and have a deletionTimestamp). + * + * This field is beta-level. The job controller populates the field when + * the feature gate JobPodReplacementPolicy is enabled (enabled by default). + * +optional + * + * @generated from field: optional int32 terminating = 11; + */ + terminating?: number; + /** * completedIndexes holds the completed indexes when .spec.completionMode = * "Indexed" in a text format. The indexes are represented as decimal integers @@ -803,6 +868,23 @@ export class JobStatus extends Message { */ completedIndexes?: string; + /** + * FailedIndexes holds the failed indexes when backoffLimitPerIndex=true. + * The indexes are represented in the text format analogous as for the + * `completedIndexes` field, ie. they are kept as decimal integers + * separated by commas. The numbers are listed in increasing order. Three or + * more consecutive numbers are compressed and represented by the first and + * last element of the series, separated by a hyphen. + * For example, if the failed indexes are 1, 3, 4, 5 and 7, they are + * represented as "1,3-5,7". + * This field is beta-level. It can be used when the `JobBackoffLimitPerIndex` + * feature gate is enabled (enabled by default). + * +optional + * + * @generated from field: optional string failedIndexes = 10; + */ + failedIndexes?: string; + /** * uncountedTerminatedPods holds the UIDs of Pods that have terminated but * the job controller hasn't yet accounted for in the status counters. @@ -826,9 +908,6 @@ export class JobStatus extends Message { /** * The number of pods which have a Ready condition. - * - * This field is beta-level. The job controller populates the field when - * the feature gate JobReadyPods is enabled (enabled by default). * +optional * * @generated from field: optional int32 ready = 9; @@ -849,7 +928,9 @@ export class JobStatus extends Message { { no: 4, name: "active", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, { no: 5, name: "succeeded", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, { no: 6, name: "failed", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, + { no: 11, name: "terminating", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, { no: 7, name: "completedIndexes", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 10, name: "failedIndexes", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 8, name: "uncountedTerminatedPods", kind: "message", T: UncountedTerminatedPods, opt: true }, { no: 9, name: "ready", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true }, ]); @@ -1118,6 +1199,10 @@ export class PodFailurePolicyRule extends Message { * * - FailJob: indicates that the pod's job is marked as Failed and all * running pods are terminated. + * - FailIndex: indicates that the pod's index is marked as Failed and will + * not be restarted. + * This value is beta-level. It can be used when the + * `JobBackoffLimitPerIndex` feature gate is enabled (enabled by default). * - Ignore: indicates that the counter towards the .backoffLimit is not * incremented and a replacement pod is created. * - Count: indicates that the pod is handled in the default way - the diff --git a/src/components/protos/k8s.io/api/core/v1/generated_pb.ts b/src/components/protos/k8s.io/api/core/v1/generated_pb.ts index 086e647..8fdb479 100644 --- a/src/components/protos/k8s.io/api/core/v1/generated_pb.ts +++ b/src/components/protos/k8s.io/api/core/v1/generated_pb.ts @@ -631,10 +631,8 @@ export class CSIPersistentVolumeSource extends Message { * * The template will be used to create a new ResourceClaim, which will * be bound to this pod. When this pod is deleted, the ResourceClaim - * will also be deleted. The name of the ResourceClaim will be -, where is the - * PodResourceClaim.Name. Pod validation will reject the pod if the - * concatenated name is not valid for a ResourceClaim (e.g. too long). - * - * An existing ResourceClaim with that name that is not owned by the - * pod will not be used for the pod to avoid using an unrelated - * resource by mistake. Scheduling and pod startup are then blocked - * until the unrelated ResourceClaim is removed. + * will also be deleted. The pod name and resource name, along with a + * generated component, will be used to form a unique name for the + * ResourceClaim, which will be recorded in pod.status.resourceClaimStatuses. * * This field is immutable and no changes will be made to the * corresponding ResourceClaim by the control plane after creating the @@ -1271,6 +1263,95 @@ export class ClientIPConfig extends Message { } } +/** + * ClusterTrustBundleProjection describes how to select a set of + * ClusterTrustBundle objects and project their contents into the pod + * filesystem. + * + * @generated from message k8s.io.api.core.v1.ClusterTrustBundleProjection + */ +export class ClusterTrustBundleProjection extends Message { + /** + * Select a single ClusterTrustBundle by object name. Mutually-exclusive + * with signerName and labelSelector. + * +optional + * + * @generated from field: optional string name = 1; + */ + name?: string; + + /** + * Select all ClusterTrustBundles that match this signer name. + * Mutually-exclusive with name. The contents of all selected + * ClusterTrustBundles will be unified and deduplicated. + * +optional + * + * @generated from field: optional string signerName = 2; + */ + signerName?: string; + + /** + * Select all ClusterTrustBundles that match this label selector. Only has + * effect if signerName is set. Mutually-exclusive with name. If unset, + * interpreted as "match nothing". If set but empty, interpreted as "match + * everything". + * +optional + * + * @generated from field: optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector labelSelector = 3; + */ + labelSelector?: LabelSelector; + + /** + * If true, don't block pod startup if the referenced ClusterTrustBundle(s) + * aren't available. If using name, then the named ClusterTrustBundle is + * allowed not to exist. If using signerName, then the combination of + * signerName and labelSelector is allowed to match zero + * ClusterTrustBundles. + * +optional + * + * @generated from field: optional bool optional = 5; + */ + optional?: boolean; + + /** + * Relative path from the volume root to write the bundle. + * + * @generated from field: optional string path = 4; + */ + path?: string; + + constructor(data?: PartialMessage) { + super(); + proto2.util.initPartial(data, this); + } + + static readonly runtime: typeof proto2 = proto2; + static readonly typeName = "k8s.io.api.core.v1.ClusterTrustBundleProjection"; + static readonly fields: FieldList = proto2.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 2, name: "signerName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 3, name: "labelSelector", kind: "message", T: LabelSelector, opt: true }, + { no: 5, name: "optional", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true }, + { no: 4, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ClusterTrustBundleProjection { + return new ClusterTrustBundleProjection().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ClusterTrustBundleProjection { + return new ClusterTrustBundleProjection().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ClusterTrustBundleProjection { + return new ClusterTrustBundleProjection().fromJsonString(jsonString, options); + } + + static equals(a: ClusterTrustBundleProjection | PlainMessage | undefined, b: ClusterTrustBundleProjection | PlainMessage | undefined): boolean { + return proto2.util.equals(ClusterTrustBundleProjection, a, b); + } +} + /** * Information about the condition of a component. * @@ -2058,6 +2139,29 @@ export class Container extends Message { */ resizePolicy: ContainerResizePolicy[] = []; + /** + * RestartPolicy defines the restart behavior of individual containers in a pod. + * This field may only be set for init containers, and the only allowed value is "Always". + * For non-init containers or when this field is not specified, + * the restart behavior is defined by the Pod's restart policy and the container type. + * Setting the RestartPolicy as "Always" for the init container will have the following effect: + * this init container will be continually restarted on + * exit until all regular containers have terminated. Once all regular + * containers have completed, all init containers with restartPolicy "Always" + * will be shut down. This lifecycle differs from normal init containers and + * is often referred to as a "sidecar" container. Although this init + * container still starts in the init container sequence, it does not wait + * for the container to complete before proceeding to the next init + * container. Instead, the next init container starts immediately after this + * init container is started, or after any startupProbe has successfully + * completed. + * +featureGate=SidecarContainers + * +optional + * + * @generated from field: optional string restartPolicy = 24; + */ + restartPolicy?: string; + /** * Pod volumes to mount into the container's filesystem. * Cannot be updated. @@ -2225,6 +2329,7 @@ export class Container extends Message { { no: 7, name: "env", kind: "message", T: EnvVar, repeated: true }, { no: 8, name: "resources", kind: "message", T: ResourceRequirements, opt: true }, { no: 23, name: "resizePolicy", kind: "message", T: ContainerResizePolicy, repeated: true }, + { no: 24, name: "restartPolicy", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 9, name: "volumeMounts", kind: "message", T: VolumeMount, repeated: true }, { no: 21, name: "volumeDevices", kind: "message", T: VolumeDevice, repeated: true }, { no: 10, name: "livenessProbe", kind: "message", T: Probe, opt: true }, @@ -3248,7 +3353,9 @@ export class EndpointPort extends Message { * RFC-6335 and https://www.iana.org/assignments/service-names). * * * Kubernetes-defined prefixed names: - * * 'kubernetes.io/h2c' - HTTP/2 over cleartext as described in https://www.rfc-editor.org/rfc/rfc7540 + * * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior- + * * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455 + * * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455 * * * Other protocols should use implementation-defined prefixed names such as * mycompany.com/my-custom-protocol. @@ -3870,6 +3977,18 @@ export class EphemeralContainerCommon extends Message */ resizePolicy: ContainerResizePolicy[] = []; + /** + * Restart policy for the container to manage the restart behavior of each + * container within a pod. + * This may only be set for init containers. You cannot set this field on + * ephemeral containers. + * +featureGate=SidecarContainers + * +optional + * + * @generated from field: optional string restartPolicy = 24; + */ + restartPolicy?: string; + /** * Pod volumes to mount into the container's filesystem. Subpath mounts are not allowed for ephemeral containers. * Cannot be updated. @@ -4023,6 +4142,7 @@ export class EphemeralContainerCommon extends Message { no: 7, name: "env", kind: "message", T: EnvVar, repeated: true }, { no: 8, name: "resources", kind: "message", T: ResourceRequirements, opt: true }, { no: 23, name: "resizePolicy", kind: "message", T: ContainerResizePolicy, repeated: true }, + { no: 24, name: "restartPolicy", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 9, name: "volumeMounts", kind: "message", T: VolumeMount, repeated: true }, { no: 21, name: "volumeDevices", kind: "message", T: VolumeDevice, repeated: true }, { no: 10, name: "livenessProbe", kind: "message", T: Probe, opt: true }, @@ -5320,6 +5440,47 @@ export class HostAlias extends Message { } } +/** + * HostIP represents a single IP address allocated to the host. + * + * @generated from message k8s.io.api.core.v1.HostIP + */ +export class HostIP extends Message { + /** + * IP is the IP address assigned to the host + * + * @generated from field: optional string ip = 1; + */ + ip?: string; + + constructor(data?: PartialMessage) { + super(); + proto2.util.initPartial(data, this); + } + + static readonly runtime: typeof proto2 = proto2; + static readonly typeName = "k8s.io.api.core.v1.HostIP"; + static readonly fields: FieldList = proto2.util.newFieldList(() => [ + { no: 1, name: "ip", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): HostIP { + return new HostIP().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): HostIP { + return new HostIP().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): HostIP { + return new HostIP().fromJsonString(jsonString, options); + } + + static equals(a: HostIP | PlainMessage | undefined, b: HostIP | PlainMessage | undefined): boolean { + return proto2.util.equals(HostIP, a, b); + } +} + /** * Represents a host path mapped into a pod. * Host path volumes do not support ownership management or SELinux relabeling. @@ -5820,6 +5981,15 @@ export class LifecycleHandler extends Message { */ tcpSocket?: TCPSocketAction; + /** + * Sleep represents the duration that the container should sleep before being terminated. + * +featureGate=PodLifecycleSleepAction + * +optional + * + * @generated from field: optional k8s.io.api.core.v1.SleepAction sleep = 4; + */ + sleep?: SleepAction; + constructor(data?: PartialMessage) { super(); proto2.util.initPartial(data, this); @@ -5831,6 +6001,7 @@ export class LifecycleHandler extends Message { { no: 1, name: "exec", kind: "message", T: ExecAction, opt: true }, { no: 2, name: "httpGet", kind: "message", T: HTTPGetAction, opt: true }, { no: 3, name: "tcpSocket", kind: "message", T: TCPSocketAction, opt: true }, + { no: 4, name: "sleep", kind: "message", T: SleepAction, opt: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): LifecycleHandler { @@ -6158,6 +6329,19 @@ export class LoadBalancerIngress extends Message { */ hostname?: string; + /** + * IPMode specifies how the load-balancer IP behaves, and may only be specified when the ip field is specified. + * Setting this to "VIP" indicates that traffic is delivered to the node with + * the destination set to the load-balancer's IP and port. + * Setting this to "Proxy" indicates that traffic is delivered to the node or pod with + * the destination set to the node's IP and node port or the pod's IP and port. + * Service implementations may use this information to adjust traffic routing. + * +optional + * + * @generated from field: optional string ipMode = 3; + */ + ipMode?: string; + /** * Ports is a list of records of service ports * If used, every port defined in the service should have an entry in it @@ -6178,6 +6362,7 @@ export class LoadBalancerIngress extends Message { static readonly fields: FieldList = proto2.util.newFieldList(() => [ { no: 1, name: "ip", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 2, name: "hostname", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 3, name: "ipMode", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 4, name: "ports", kind: "message", T: PortStatus, repeated: true }, ]); @@ -6341,6 +6526,64 @@ export class LocalVolumeSource extends Message { } } +/** + * ModifyVolumeStatus represents the status object of ControllerModifyVolume operation + * + * @generated from message k8s.io.api.core.v1.ModifyVolumeStatus + */ +export class ModifyVolumeStatus extends Message { + /** + * targetVolumeAttributesClassName is the name of the VolumeAttributesClass the PVC currently being reconciled + * + * @generated from field: optional string targetVolumeAttributesClassName = 1; + */ + targetVolumeAttributesClassName?: string; + + /** + * status is the status of the ControllerModifyVolume operation. It can be in any of following states: + * - Pending + * Pending indicates that the PersistentVolumeClaim cannot be modified due to unmet requirements, such as + * the specified VolumeAttributesClass not existing. + * - InProgress + * InProgress indicates that the volume is being modified. + * - Infeasible + * Infeasible indicates that the request has been rejected as invalid by the CSI driver. To + * resolve the error, a valid VolumeAttributesClass needs to be specified. + * Note: New statuses can be added in the future. Consumers should check for unknown statuses and fail appropriately. + * + * @generated from field: optional string status = 2; + */ + status?: string; + + constructor(data?: PartialMessage) { + super(); + proto2.util.initPartial(data, this); + } + + static readonly runtime: typeof proto2 = proto2; + static readonly typeName = "k8s.io.api.core.v1.ModifyVolumeStatus"; + static readonly fields: FieldList = proto2.util.newFieldList(() => [ + { no: 1, name: "targetVolumeAttributesClassName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 2, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ModifyVolumeStatus { + return new ModifyVolumeStatus().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ModifyVolumeStatus { + return new ModifyVolumeStatus().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ModifyVolumeStatus { + return new ModifyVolumeStatus().fromJsonString(jsonString, options); + } + + static equals(a: ModifyVolumeStatus | PlainMessage | undefined, b: ModifyVolumeStatus | PlainMessage | undefined): boolean { + return proto2.util.equals(ModifyVolumeStatus, a, b); + } +} + /** * Represents an NFS mount that lasts the lifetime of a pod. * NFS volumes do not support ownership management or SELinux relabeling. @@ -8278,9 +8521,9 @@ export class PersistentVolumeClaimSpec extends Message) { super(); proto2.util.initPartial(data, this); @@ -8363,12 +8626,13 @@ export class PersistentVolumeClaimSpec extends Message [ { no: 1, name: "accessModes", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, { no: 4, name: "selector", kind: "message", T: LabelSelector, opt: true }, - { no: 2, name: "resources", kind: "message", T: ResourceRequirements, opt: true }, + { no: 2, name: "resources", kind: "message", T: VolumeResourceRequirements, opt: true }, { no: 3, name: "volumeName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 5, name: "storageClassName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 6, name: "volumeMode", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 7, name: "dataSource", kind: "message", T: TypedLocalObjectReference, opt: true }, { no: 8, name: "dataSourceRef", kind: "message", T: TypedObjectReference, opt: true }, + { no: 9, name: "volumeAttributesClassName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): PersistentVolumeClaimSpec { @@ -8431,13 +8695,27 @@ export class PersistentVolumeClaimStatus extends Message allocatedResourceStatuses = 7; + */ + allocatedResourceStatuses: { [key: string]: string } = {}; + + /** + * currentVolumeAttributesClassName is the current name of the VolumeAttributesClass the PVC is using. + * When unset, there is no VolumeAttributeClass applied to this PersistentVolumeClaim + * This is an alpha field and requires enabling VolumeAttributesClass feature. + * +featureGate=VolumeAttributesClass * +optional * - * @generated from field: optional string resizeStatus = 6; + * @generated from field: optional string currentVolumeAttributesClassName = 8; */ - resizeStatus?: string; + currentVolumeAttributesClassName?: string; + + /** + * ModifyVolumeStatus represents the status object of ControllerModifyVolume operation. + * When this is unset, there is no ModifyVolume operation being attempted. + * This is an alpha field and requires enabling VolumeAttributesClass feature. + * +featureGate=VolumeAttributesClass + * +optional + * + * @generated from field: optional k8s.io.api.core.v1.ModifyVolumeStatus modifyVolumeStatus = 9; + */ + modifyVolumeStatus?: ModifyVolumeStatus; constructor(data?: PartialMessage) { super(); @@ -8471,7 +8803,9 @@ export class PersistentVolumeClaimStatus extends Message): PersistentVolumeClaimStatus { @@ -8994,6 +9328,21 @@ export class PersistentVolumeSpec extends Message { */ nodeAffinity?: VolumeNodeAffinity; + /** + * Name of VolumeAttributesClass to which this persistent volume belongs. Empty value + * is not allowed. When this field is not set, it indicates that this volume does not belong to any + * VolumeAttributesClass. This field is mutable and can be changed by the CSI driver + * after a volume has been updated successfully to a new class. + * For an unbound PersistentVolume, the volumeAttributesClassName will be matched with unbound + * PersistentVolumeClaims during the binding process. + * This is an alpha field and requires enabling VolumeAttributesClass feature. + * +featureGate=VolumeAttributesClass + * +optional + * + * @generated from field: optional string volumeAttributesClassName = 10; + */ + volumeAttributesClassName?: string; + constructor(data?: PartialMessage) { super(); proto2.util.initPartial(data, this); @@ -9011,6 +9360,7 @@ export class PersistentVolumeSpec extends Message { { no: 7, name: "mountOptions", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, { no: 8, name: "volumeMode", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 9, name: "nodeAffinity", kind: "message", T: VolumeNodeAffinity, opt: true }, + { no: 10, name: "volumeAttributesClassName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): PersistentVolumeSpec { @@ -9062,6 +9412,17 @@ export class PersistentVolumeStatus extends Message { */ reason?: string; + /** + * lastPhaseTransitionTime is the time the phase transitioned from one to another + * and automatically resets to current time everytime a volume phase transitions. + * This is a beta field and requires the PersistentVolumeLastPhaseTransitionTime feature to be enabled (enabled by default). + * +featureGate=PersistentVolumeLastPhaseTransitionTime + * +optional + * + * @generated from field: optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastPhaseTransitionTime = 4; + */ + lastPhaseTransitionTime?: Time; + constructor(data?: PartialMessage) { super(); proto2.util.initPartial(data, this); @@ -9073,6 +9434,7 @@ export class PersistentVolumeStatus extends Message { { no: 1, name: "phase", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 2, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 3, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 4, name: "lastPhaseTransitionTime", kind: "message", T: Time, opt: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): PersistentVolumeStatus { @@ -9288,6 +9650,7 @@ export class PodAffinity extends Message { export class PodAffinityTerm extends Message { /** * A label query over a set of resources, in this case pods. + * If it's null, this PodAffinityTerm matches with no Pods. * +optional * * @generated from field: optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector labelSelector = 1; @@ -9328,6 +9691,40 @@ export class PodAffinityTerm extends Message { */ namespaceSelector?: LabelSelector; + /** + * MatchLabelKeys is a set of pod label keys to select which pods will + * be taken into consideration. The keys are used to lookup values from the + * incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)` + * to select the group of existing pods which pods will be taken into consideration + * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + * pod labels will be ignored. The default value is empty. + * The same key is forbidden to exist in both MatchLabelKeys and LabelSelector. + * Also, MatchLabelKeys cannot be set when LabelSelector isn't set. + * This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate. + * +listType=atomic + * +optional + * + * @generated from field: repeated string matchLabelKeys = 5; + */ + matchLabelKeys: string[] = []; + + /** + * MismatchLabelKeys is a set of pod label keys to select which pods will + * be taken into consideration. The keys are used to lookup values from the + * incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)` + * to select the group of existing pods which pods will be taken into consideration + * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming + * pod labels will be ignored. The default value is empty. + * The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector. + * Also, MismatchLabelKeys cannot be set when LabelSelector isn't set. + * This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate. + * +listType=atomic + * +optional + * + * @generated from field: repeated string mismatchLabelKeys = 6; + */ + mismatchLabelKeys: string[] = []; + constructor(data?: PartialMessage) { super(); proto2.util.initPartial(data, this); @@ -9340,6 +9737,8 @@ export class PodAffinityTerm extends Message { { no: 2, name: "namespaces", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, { no: 3, name: "topologyKey", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 4, name: "namespaceSelector", kind: "message", T: LabelSelector, opt: true }, + { no: 5, name: "matchLabelKeys", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + { no: 6, name: "mismatchLabelKeys", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): PodAffinityTerm { @@ -9810,16 +10209,13 @@ export class PodExecOptions extends Message { } /** - * IP address information for entries in the (plural) PodIPs field. - * Each entry includes: - * - * IP: An IP address allocated to the pod. Routable at least within the cluster. + * PodIP represents a single IP address allocated to the pod. * * @generated from message k8s.io.api.core.v1.PodIP */ export class PodIP extends Message { /** - * ip is an IP address (IPv4 or IPv6) assigned to the pod + * IP is the IP address assigned to the pod * * @generated from field: optional string ip = 1; */ @@ -10261,6 +10657,64 @@ export class PodResourceClaim extends Message { } } +/** + * PodResourceClaimStatus is stored in the PodStatus for each PodResourceClaim + * which references a ResourceClaimTemplate. It stores the generated name for + * the corresponding ResourceClaim. + * + * @generated from message k8s.io.api.core.v1.PodResourceClaimStatus + */ +export class PodResourceClaimStatus extends Message { + /** + * Name uniquely identifies this resource claim inside the pod. + * This must match the name of an entry in pod.spec.resourceClaims, + * which implies that the string must be a DNS_LABEL. + * + * @generated from field: optional string name = 1; + */ + name?: string; + + /** + * ResourceClaimName is the name of the ResourceClaim that was + * generated for the Pod in the namespace of the Pod. It this is + * unset, then generating a ResourceClaim was not necessary. The + * pod.spec.resourceClaims entry can be ignored in this case. + * + * +optional + * + * @generated from field: optional string resourceClaimName = 2; + */ + resourceClaimName?: string; + + constructor(data?: PartialMessage) { + super(); + proto2.util.initPartial(data, this); + } + + static readonly runtime: typeof proto2 = proto2; + static readonly typeName = "k8s.io.api.core.v1.PodResourceClaimStatus"; + static readonly fields: FieldList = proto2.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 2, name: "resourceClaimName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): PodResourceClaimStatus { + return new PodResourceClaimStatus().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): PodResourceClaimStatus { + return new PodResourceClaimStatus().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): PodResourceClaimStatus { + return new PodResourceClaimStatus().fromJsonString(jsonString, options); + } + + static equals(a: PodResourceClaimStatus | PlainMessage | undefined, b: PodResourceClaimStatus | PlainMessage | undefined): boolean { + return proto2.util.equals(PodResourceClaimStatus, a, b); + } +} + /** * PodSchedulingGate is associated to a Pod to guard its scheduling. * @@ -11152,7 +11606,9 @@ export class PodStatus extends Message { nominatedNodeName?: string; /** - * IP address of the host to which the pod is assigned. Empty if not yet scheduled. + * hostIP holds the IP address of the host to which the pod is assigned. Empty if the pod has not started yet. + * A pod can be assigned to a node that has a problem in kubelet which in turns mean that HostIP will + * not be updated even if there is a node is assigned to pod * +optional * * @generated from field: optional string hostIP = 5; @@ -11160,7 +11616,21 @@ export class PodStatus extends Message { hostIP?: string; /** - * IP address allocated to the pod. Routable at least within the cluster. + * hostIPs holds the IP addresses allocated to the host. If this field is specified, the first entry must + * match the hostIP field. This list is empty if the pod has not started yet. + * A pod can be assigned to a node that has a problem in kubelet which in turns means that HostIPs will + * not be updated even if there is a node is assigned to this pod. + * +optional + * +patchStrategy=merge + * +patchMergeKey=ip + * +listType=atomic + * + * @generated from field: repeated k8s.io.api.core.v1.HostIP hostIPs = 16; + */ + hostIPs: HostIP[] = []; + + /** + * podIP address allocated to the pod. Routable at least within the cluster. * Empty if not yet allocated. * +optional * @@ -11237,6 +11707,19 @@ export class PodStatus extends Message { */ resize?: string; + /** + * Status of resource claims. + * +patchMergeKey=name + * +patchStrategy=merge,retainKeys + * +listType=map + * +listMapKey=name + * +featureGate=DynamicResourceAllocation + * +optional + * + * @generated from field: repeated k8s.io.api.core.v1.PodResourceClaimStatus resourceClaimStatuses = 15; + */ + resourceClaimStatuses: PodResourceClaimStatus[] = []; + constructor(data?: PartialMessage) { super(); proto2.util.initPartial(data, this); @@ -11251,6 +11734,7 @@ export class PodStatus extends Message { { no: 4, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 11, name: "nominatedNodeName", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 5, name: "hostIP", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 16, name: "hostIPs", kind: "message", T: HostIP, repeated: true }, { no: 6, name: "podIP", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 12, name: "podIPs", kind: "message", T: PodIP, repeated: true }, { no: 7, name: "startTime", kind: "message", T: Time, opt: true }, @@ -11259,6 +11743,7 @@ export class PodStatus extends Message { { no: 9, name: "qosClass", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, { no: 13, name: "ephemeralContainerStatuses", kind: "message", T: ContainerStatus, repeated: true }, { no: 14, name: "resize", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 15, name: "resourceClaimStatuses", kind: "message", T: PodResourceClaimStatus, repeated: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): PodStatus { @@ -13638,7 +14123,7 @@ export class SeccompProfile extends Message { * localhostProfile indicates a profile defined in a file on the node should be used. * The profile must be preconfigured on the node to work. * Must be a descending path, relative to the kubelet's configured seccomp profile location. - * Must only be set if type is "Localhost". + * Must be set if type is "Localhost". Must NOT be set for any other type. * +optional * * @generated from field: optional string localhostProfile = 2; @@ -14707,10 +15192,19 @@ export class ServicePort extends Message { /** * The application protocol for this port. + * This is used as a hint for implementations to offer richer behavior for protocols that they understand. * This field follows standard Kubernetes label syntax. - * Un-prefixed names are reserved for IANA standard service names (as per + * Valid values are either: + * + * * Un-prefixed protocol names - reserved for IANA standard service names (as per * RFC-6335 and https://www.iana.org/assignments/service-names). - * Non-standard protocols should use prefixed names such as + * + * * Kubernetes-defined prefixed names: + * * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior- + * * 'kubernetes.io/ws' - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455 + * * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455 + * + * * Other protocols should use implementation-defined prefixed names such as * mycompany.com/my-custom-protocol. * +optional * @@ -14973,10 +15467,9 @@ export class ServiceSpec extends Message { * This feature depends on whether the underlying cloud-provider supports specifying * the loadBalancerIP when a load balancer is created. * This field will be ignored if the cloud-provider does not support the feature. - * Deprecated: This field was under-specified and its meaning varies across implementations, - * and it cannot support dual-stack. - * As of Kubernetes v1.24, users are encouraged to use implementation-specific annotations when available. - * This field may be removed in a future API version. + * Deprecated: This field was under-specified and its meaning varies across implementations. + * Using it is non-portable and it may not support dual-stack. + * Users are encouraged to use implementation-specific annotations when available. * +optional * * @generated from field: optional string loadBalancerIP = 8; @@ -15292,6 +15785,47 @@ export class SessionAffinityConfig extends Message { } } +/** + * SleepAction describes a "sleep" action. + * + * @generated from message k8s.io.api.core.v1.SleepAction + */ +export class SleepAction extends Message { + /** + * Seconds is the number of seconds to sleep. + * + * @generated from field: optional int64 seconds = 1; + */ + seconds?: bigint; + + constructor(data?: PartialMessage) { + super(); + proto2.util.initPartial(data, this); + } + + static readonly runtime: typeof proto2 = proto2; + static readonly typeName = "k8s.io.api.core.v1.SleepAction"; + static readonly fields: FieldList = proto2.util.newFieldList(() => [ + { no: 1, name: "seconds", kind: "scalar", T: 3 /* ScalarType.INT64 */, opt: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SleepAction { + return new SleepAction().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SleepAction { + return new SleepAction().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SleepAction { + return new SleepAction().fromJsonString(jsonString, options); + } + + static equals(a: SleepAction | PlainMessage | undefined, b: SleepAction | PlainMessage | undefined): boolean { + return proto2.util.equals(SleepAction, a, b); + } +} + /** * Represents a StorageOS persistent volume resource. * @@ -16429,6 +16963,28 @@ export class VolumeProjection extends Message { */ serviceAccountToken?: ServiceAccountTokenProjection; + /** + * ClusterTrustBundle allows a pod to access the `.spec.trustBundle` field + * of ClusterTrustBundle objects in an auto-updating file. + * + * Alpha, gated by the ClusterTrustBundleProjection feature gate. + * + * ClusterTrustBundle objects can either be selected by name, or by the + * combination of signer name and a label selector. + * + * Kubelet performs aggressive normalization of the PEM contents written + * into the pod filesystem. Esoteric PEM features such as inter-block + * comments and block headers are stripped. Certificates are deduplicated. + * The ordering of certificates within the file is arbitrary, and Kubelet + * may change the order over time. + * + * +featureGate=ClusterTrustBundleProjection + * +optional + * + * @generated from field: optional k8s.io.api.core.v1.ClusterTrustBundleProjection clusterTrustBundle = 5; + */ + clusterTrustBundle?: ClusterTrustBundleProjection; + constructor(data?: PartialMessage) { super(); proto2.util.initPartial(data, this); @@ -16441,6 +16997,7 @@ export class VolumeProjection extends Message { { no: 2, name: "downwardAPI", kind: "message", T: DownwardAPIProjection, opt: true }, { no: 3, name: "configMap", kind: "message", T: ConfigMapProjection, opt: true }, { no: 4, name: "serviceAccountToken", kind: "message", T: ServiceAccountTokenProjection, opt: true }, + { no: 5, name: "clusterTrustBundle", kind: "message", T: ClusterTrustBundleProjection, opt: true }, ]); static fromBinary(bytes: Uint8Array, options?: Partial): VolumeProjection { @@ -16460,6 +17017,61 @@ export class VolumeProjection extends Message { } } +/** + * VolumeResourceRequirements describes the storage resource requirements for a volume. + * + * @generated from message k8s.io.api.core.v1.VolumeResourceRequirements + */ +export class VolumeResourceRequirements extends Message { + /** + * Limits describes the maximum amount of compute resources allowed. + * More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ + * +optional + * + * @generated from field: map limits = 1; + */ + limits: { [key: string]: Quantity } = {}; + + /** + * Requests describes the minimum amount of compute resources required. + * If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, + * otherwise to an implementation-defined value. Requests cannot exceed Limits. + * More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ + * +optional + * + * @generated from field: map requests = 2; + */ + requests: { [key: string]: Quantity } = {}; + + constructor(data?: PartialMessage) { + super(); + proto2.util.initPartial(data, this); + } + + static readonly runtime: typeof proto2 = proto2; + static readonly typeName = "k8s.io.api.core.v1.VolumeResourceRequirements"; + static readonly fields: FieldList = proto2.util.newFieldList(() => [ + { no: 1, name: "limits", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: Quantity} }, + { no: 2, name: "requests", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: Quantity} }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): VolumeResourceRequirements { + return new VolumeResourceRequirements().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): VolumeResourceRequirements { + return new VolumeResourceRequirements().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): VolumeResourceRequirements { + return new VolumeResourceRequirements().fromJsonString(jsonString, options); + } + + static equals(a: VolumeResourceRequirements | PlainMessage | undefined, b: VolumeResourceRequirements | PlainMessage | undefined): boolean { + return proto2.util.equals(VolumeResourceRequirements, a, b); + } +} + /** * Represents the source of a volume to mount. * Only one of its members may be specified. @@ -16959,12 +17571,9 @@ export class WindowsSecurityContextOptions extends Message { export class LabelSelectorRequirement extends Message { /** * key is the label key that the selector applies to. - * +patchMergeKey=key - * +patchStrategy=merge * * @generated from field: optional string key = 1; */