From 9348b833bbd91c82e5828ce81b75ef9872604fa9 Mon Sep 17 00:00:00 2001 From: Anindita Das Date: Fri, 21 Aug 2026 10:51:41 -0400 Subject: [PATCH] chore: OCPBUGS-105402: Remove EVPN feature gate The EVPN feature gate has been enabled by default and is no longer needed within the product. All clusters now have EVPN functionality available without requiring an explicit feature gate. This commit removes: - FeatureGateEVPN definition from features/features.go - EVPN references from all payload manifest files - EVPN entry from features.md documentation The feature gate graduation is complete and the gate is no longer required for cluster configuration. Signed-off-by: Anindita Das --- apps/v1/generated.proto | 203 ++++---- build/v1/generated.proto | 445 +++++++++--------- features.md | 1 - features/features.go | 8 - .../featureGate-4-10-Hypershift-Default.yaml | 3 - ...e-4-10-Hypershift-DevPreviewNoUpgrade.yaml | 3 - .../featureGate-4-10-Hypershift-OKD.yaml | 3 - ...-4-10-Hypershift-TechPreviewNoUpgrade.yaml | 3 - ...eatureGate-4-10-SelfManagedHA-Default.yaml | 3 - ...-10-SelfManagedHA-DevPreviewNoUpgrade.yaml | 3 - .../featureGate-4-10-SelfManagedHA-OKD.yaml | 3 - ...10-SelfManagedHA-TechPreviewNoUpgrade.yaml | 3 - 12 files changed, 337 insertions(+), 344 deletions(-) diff --git a/apps/v1/generated.proto b/apps/v1/generated.proto index b0a1a1c0838..e096a800f71 100644 --- a/apps/v1/generated.proto +++ b/apps/v1/generated.proto @@ -5,33 +5,43 @@ syntax = "proto2"; package github.com.openshift.api.apps.v1; +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; import "k8s.io/api/core/v1/generated.proto"; import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; import "k8s.io/apimachinery/pkg/util/intstr/generated.proto"; // Package-wide variables from generator "generated". +option (gogoproto.marshaler_all) = true; +option (gogoproto.stable_marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.stringer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_unrecognized_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; option go_package = "github.com/openshift/api/apps/v1"; // CustomDeploymentStrategyParams are the input to the Custom deployment strategy. message CustomDeploymentStrategyParams { // image specifies a container image which can carry out a deployment. - optional string image = 1; + optional string image = 1 [(gogoproto.customname) = "Image", (gogoproto.nullable) = false]; // environment holds the environment which will be given to the container for Image. - repeated .k8s.io.api.core.v1.EnvVar environment = 2; + repeated .k8s.io.api.core.v1.EnvVar environment = 2 [(gogoproto.customname) = "Environment", (gogoproto.nullable) = false]; // command is optional and overrides CMD in the container Image. - repeated string command = 3; + repeated string command = 3 [(gogoproto.customname) = "Command"]; } // DeploymentCause captures information about a particular cause of a deployment. message DeploymentCause { // type of the trigger that resulted in the creation of a new deployment - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "DeploymentTriggerType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // imageTrigger contains the image trigger details, if this trigger was fired based on an image change - optional DeploymentCauseImageTrigger imageTrigger = 2; + optional DeploymentCauseImageTrigger imageTrigger = 2 [(gogoproto.customname) = "ImageTrigger"]; } // DeploymentCauseImageTrigger represents details about the cause of a deployment originating @@ -39,28 +49,28 @@ message DeploymentCause { message DeploymentCauseImageTrigger { // from is a reference to the changed object which triggered a deployment. The field may have // the kinds DockerImage, ImageStreamTag, or ImageStreamImage. - optional .k8s.io.api.core.v1.ObjectReference from = 1; + optional .k8s.io.api.core.v1.ObjectReference from = 1 [(gogoproto.customname) = "From", (gogoproto.nullable) = false]; } // DeploymentCondition describes the state of a deployment config at a certain point. message DeploymentCondition { // type of deployment condition. - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "DeploymentConditionType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // status of the condition, one of True, False, Unknown. - optional string status = 2; + optional string status = 2 [(gogoproto.casttype) = "k8s.io/api/core/v1.ConditionStatus", (gogoproto.customname) = "Status", (gogoproto.nullable) = false]; // The last time this condition was updated. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastUpdateTime = 6; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastUpdateTime = 6 [(gogoproto.customname) = "LastUpdateTime", (gogoproto.nullable) = false]; // The last time the condition transitioned from one status to another. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3 [(gogoproto.customname) = "LastTransitionTime", (gogoproto.nullable) = false]; // The reason for the condition's last transition. - optional string reason = 4; + optional string reason = 4 [(gogoproto.customname) = "Reason", (gogoproto.nullable) = false]; // A human readable message indicating details about the transition. - optional string message = 5; + optional string message = 5 [(gogoproto.customname) = "Message", (gogoproto.nullable) = false]; } // Deployment Configs define the template for a pod and manages deploying new images or configuration changes. @@ -79,14 +89,14 @@ message DeploymentCondition { message DeploymentConfig { // metadata is the standard object's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1 [(gogoproto.customname) = "ObjectMeta", (gogoproto.nullable) = false]; // spec represents a desired deployment state and how to deploy to it. - optional DeploymentConfigSpec spec = 2; + optional DeploymentConfigSpec spec = 2 [(gogoproto.customname) = "Spec", (gogoproto.nullable) = false]; // status represents the current deployment state. // +optional - optional DeploymentConfigStatus status = 3; + optional DeploymentConfigStatus status = 3 [(gogoproto.customname) = "Status", (gogoproto.nullable) = false]; } // DeploymentConfigList is a collection of deployment configs. @@ -96,10 +106,10 @@ message DeploymentConfig { message DeploymentConfigList { // metadata is the standard list's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1 [(gogoproto.customname) = "ListMeta", (gogoproto.nullable) = false]; // items is a list of deployment configs - repeated DeploymentConfig items = 2; + repeated DeploymentConfig items = 2 [(gogoproto.customname) = "Items", (gogoproto.nullable) = false]; } // DeploymentConfigRollback provides the input to rollback generation. @@ -108,78 +118,78 @@ message DeploymentConfigList { // +openshift:compatibility-gen:level=1 message DeploymentConfigRollback { // name of the deployment config that will be rolled back. - optional string name = 1; + optional string name = 1 [(gogoproto.customname) = "Name", (gogoproto.nullable) = false]; // updatedAnnotations is a set of new annotations that will be added in the deployment config. - map updatedAnnotations = 2; + map updatedAnnotations = 2 [(gogoproto.customname) = "UpdatedAnnotations", (gogoproto.nullable) = false]; // spec defines the options to rollback generation. - optional DeploymentConfigRollbackSpec spec = 3; + optional DeploymentConfigRollbackSpec spec = 3 [(gogoproto.customname) = "Spec", (gogoproto.nullable) = false]; } // DeploymentConfigRollbackSpec represents the options for rollback generation. message DeploymentConfigRollbackSpec { // from points to a ReplicationController which is a deployment. - optional .k8s.io.api.core.v1.ObjectReference from = 1; + optional .k8s.io.api.core.v1.ObjectReference from = 1 [(gogoproto.customname) = "From", (gogoproto.nullable) = false]; // revision to rollback to. If set to 0, rollback to the last revision. - optional int64 revision = 2; + optional int64 revision = 2 [(gogoproto.customname) = "Revision", (gogoproto.nullable) = false]; // includeTriggers specifies whether to include config Triggers. - optional bool includeTriggers = 3; + optional bool includeTriggers = 3 [(gogoproto.customname) = "IncludeTriggers", (gogoproto.nullable) = false]; // includeTemplate specifies whether to include the PodTemplateSpec. - optional bool includeTemplate = 4; + optional bool includeTemplate = 4 [(gogoproto.customname) = "IncludeTemplate", (gogoproto.nullable) = false]; // includeReplicationMeta specifies whether to include the replica count and selector. - optional bool includeReplicationMeta = 5; + optional bool includeReplicationMeta = 5 [(gogoproto.customname) = "IncludeReplicationMeta", (gogoproto.nullable) = false]; // includeStrategy specifies whether to include the deployment Strategy. - optional bool includeStrategy = 6; + optional bool includeStrategy = 6 [(gogoproto.customname) = "IncludeStrategy", (gogoproto.nullable) = false]; } // DeploymentConfigSpec represents the desired state of the deployment. message DeploymentConfigSpec { // strategy describes how a deployment is executed. // +optional - optional DeploymentStrategy strategy = 1; + optional DeploymentStrategy strategy = 1 [(gogoproto.customname) = "Strategy", (gogoproto.nullable) = false]; // minReadySeconds is the minimum number of seconds for which a newly created pod should // be ready without any of its container crashing, for it to be considered available. // Defaults to 0 (pod will be considered available as soon as it is ready) - optional int32 minReadySeconds = 9; + optional int32 minReadySeconds = 9 [(gogoproto.customname) = "MinReadySeconds", (gogoproto.nullable) = false]; // triggers determine how updates to a DeploymentConfig result in new deployments. If no triggers // are defined, a new deployment can only occur as a result of an explicit client update to the // DeploymentConfig with a new LatestVersion. If null, defaults to having a config change trigger. // +optional - optional DeploymentTriggerPolicies triggers = 2; + optional DeploymentTriggerPolicies triggers = 2 [(gogoproto.customname) = "Triggers"]; // replicas is the number of desired replicas. // +optional - optional int32 replicas = 3; + optional int32 replicas = 3 [(gogoproto.customname) = "Replicas", (gogoproto.nullable) = false]; // revisionHistoryLimit is the number of old ReplicationControllers to retain to allow for rollbacks. // This field is a pointer to allow for differentiation between an explicit zero and not specified. // Defaults to 10. (This only applies to DeploymentConfigs created via the new group API resource, not the legacy resource.) - optional int32 revisionHistoryLimit = 4; + optional int32 revisionHistoryLimit = 4 [(gogoproto.customname) = "RevisionHistoryLimit"]; // test ensures that this deployment config will have zero replicas except while a deployment is running. This allows the // deployment config to be used as a continuous deployment test - triggering on images, running the deployment, and then succeeding // or failing. Post strategy hooks and After actions can be used to integrate successful deployment with an action. // +optional - optional bool test = 5; + optional bool test = 5 [(gogoproto.customname) = "Test", (gogoproto.nullable) = false]; // paused indicates that the deployment config is paused resulting in no new deployments on template // changes or changes in the template caused by other triggers. - optional bool paused = 6; + optional bool paused = 6 [(gogoproto.customname) = "Paused", (gogoproto.nullable) = false]; // selector is a label query over pods that should match the Replicas count. - map selector = 7; + map selector = 7 [(gogoproto.customname) = "Selector", (gogoproto.nullable) = false]; // template is the object that describes the pod that will be created if // insufficient replicas are detected. - optional .k8s.io.api.core.v1.PodTemplateSpec template = 8; + optional .k8s.io.api.core.v1.PodTemplateSpec template = 8 [(gogoproto.customname) = "Template"]; } // DeploymentConfigStatus represents the current deployment state. @@ -187,52 +197,52 @@ message DeploymentConfigStatus { // latestVersion is used to determine whether the current deployment associated with a deployment // config is out of sync. // +optional - optional int64 latestVersion = 1; + optional int64 latestVersion = 1 [(gogoproto.customname) = "LatestVersion", (gogoproto.nullable) = false]; // observedGeneration is the most recent generation observed by the deployment config controller. // +optional - optional int64 observedGeneration = 2; + optional int64 observedGeneration = 2 [(gogoproto.customname) = "ObservedGeneration", (gogoproto.nullable) = false]; // replicas is the total number of pods targeted by this deployment config. // +optional - optional int32 replicas = 3; + optional int32 replicas = 3 [(gogoproto.customname) = "Replicas", (gogoproto.nullable) = false]; // updatedReplicas is the total number of non-terminated pods targeted by this deployment config // that have the desired template spec. // +optional - optional int32 updatedReplicas = 4; + optional int32 updatedReplicas = 4 [(gogoproto.customname) = "UpdatedReplicas", (gogoproto.nullable) = false]; // availableReplicas is the total number of available pods targeted by this deployment config. // +optional - optional int32 availableReplicas = 5; + optional int32 availableReplicas = 5 [(gogoproto.customname) = "AvailableReplicas", (gogoproto.nullable) = false]; // unavailableReplicas is the total number of unavailable pods targeted by this deployment config. // +optional - optional int32 unavailableReplicas = 6; + optional int32 unavailableReplicas = 6 [(gogoproto.customname) = "UnavailableReplicas", (gogoproto.nullable) = false]; // details are the reasons for the update to this deployment config. // This could be based on a change made by the user or caused by an automatic trigger // +optional - optional DeploymentDetails details = 7; + optional DeploymentDetails details = 7 [(gogoproto.customname) = "Details"]; // conditions represents the latest available observations of a deployment config's current state. // +patchMergeKey=type // +patchStrategy=merge // +optional - repeated DeploymentCondition conditions = 8; + repeated DeploymentCondition conditions = 8 [(gogoproto.customname) = "Conditions", (gogoproto.nullable) = false]; // Total number of ready pods targeted by this deployment. // +optional - optional int32 readyReplicas = 9; + optional int32 readyReplicas = 9 [(gogoproto.customname) = "ReadyReplicas", (gogoproto.nullable) = false]; } // DeploymentDetails captures information about the causes of a deployment. message DeploymentDetails { // message is the user specified change message, if this deployment was triggered manually by the user - optional string message = 1; + optional string message = 1 [(gogoproto.customname) = "Message", (gogoproto.nullable) = false]; // causes are extended data associated with all the causes for creating a new deployment - repeated DeploymentCause causes = 2; + repeated DeploymentCause causes = 2 [(gogoproto.customname) = "Causes", (gogoproto.nullable) = false]; } // DeploymentLog represents the logs for a deployment @@ -248,47 +258,47 @@ message DeploymentLog { // +openshift:compatibility-gen:level=1 message DeploymentLogOptions { // The container for which to stream logs. Defaults to only container if there is one container in the pod. - optional string container = 1; + optional string container = 1 [(gogoproto.customname) = "Container", (gogoproto.nullable) = false]; // follow if true indicates that the build log should be streamed until // the build terminates. - optional bool follow = 2; + optional bool follow = 2 [(gogoproto.customname) = "Follow", (gogoproto.nullable) = false]; // Return previous deployment logs. Defaults to false. - optional bool previous = 3; + optional bool previous = 3 [(gogoproto.customname) = "Previous", (gogoproto.nullable) = false]; // A relative time in seconds before the current time from which to show logs. If this value // precedes the time a pod was started, only logs since the pod start will be returned. // If this value is in the future, no logs will be returned. // Only one of sinceSeconds or sinceTime may be specified. - optional int64 sinceSeconds = 4; + optional int64 sinceSeconds = 4 [(gogoproto.customname) = "SinceSeconds"]; // An RFC3339 timestamp from which to show logs. If this value // precedes the time a pod was started, only logs since the pod start will be returned. // If this value is in the future, no logs will be returned. // Only one of sinceSeconds or sinceTime may be specified. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time sinceTime = 5; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time sinceTime = 5 [(gogoproto.customname) = "SinceTime"]; // If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line // of log output. Defaults to false. - optional bool timestamps = 6; + optional bool timestamps = 6 [(gogoproto.customname) = "Timestamps", (gogoproto.nullable) = false]; // If set, the number of lines from the end of the logs to show. If not specified, // logs are shown from the creation of the container or sinceSeconds or sinceTime - optional int64 tailLines = 7; + optional int64 tailLines = 7 [(gogoproto.customname) = "TailLines"]; // If set, the number of bytes to read from the server before terminating the // log output. This may not display a complete final line of logging, and may return // slightly more or slightly less than the specified limit. - optional int64 limitBytes = 8; + optional int64 limitBytes = 8 [(gogoproto.customname) = "LimitBytes"]; // nowait if true causes the call to return immediately even if the deployment // is not available yet. Otherwise the server will wait until the deployment has started. // TODO: Fix the tag to 'noWait' in v2 - optional bool nowait = 9; + optional bool nowait = 9 [(gogoproto.customname) = "NoWait", (gogoproto.nullable) = false]; // version of the deployment for which to view logs. - optional int64 version = 10; + optional int64 version = 10 [(gogoproto.customname) = "Version"]; } // DeploymentRequest is a request to a deployment config for a new deployment. @@ -297,89 +307,92 @@ message DeploymentLogOptions { // +openshift:compatibility-gen:level=1 message DeploymentRequest { // name of the deployment config for requesting a new deployment. - optional string name = 1; + optional string name = 1 [(gogoproto.customname) = "Name", (gogoproto.nullable) = false]; // latest will update the deployment config with the latest state from all triggers. - optional bool latest = 2; + optional bool latest = 2 [(gogoproto.customname) = "Latest", (gogoproto.nullable) = false]; // force will try to force a new deployment to run. If the deployment config is paused, // then setting this to true will return an Invalid error. - optional bool force = 3; + optional bool force = 3 [(gogoproto.customname) = "Force", (gogoproto.nullable) = false]; // excludeTriggers instructs the instantiator to avoid processing the specified triggers. // This field overrides the triggers from latest and allows clients to control specific // logic. This field is ignored if not specified. - repeated string excludeTriggers = 4; + repeated string excludeTriggers = 4 [(gogoproto.casttype) = "DeploymentTriggerType", (gogoproto.customname) = "ExcludeTriggers"]; } // DeploymentStrategy describes how to perform a deployment. message DeploymentStrategy { // type is the name of a deployment strategy. // +optional - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "DeploymentStrategyType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // customParams are the input to the Custom deployment strategy, and may also // be specified for the Recreate and Rolling strategies to customize the execution // process that runs the deployment. - optional CustomDeploymentStrategyParams customParams = 2; + optional CustomDeploymentStrategyParams customParams = 2 [(gogoproto.customname) = "CustomParams"]; // recreateParams are the input to the Recreate deployment strategy. - optional RecreateDeploymentStrategyParams recreateParams = 3; + optional RecreateDeploymentStrategyParams recreateParams = 3 [(gogoproto.customname) = "RecreateParams"]; // rollingParams are the input to the Rolling deployment strategy. - optional RollingDeploymentStrategyParams rollingParams = 4; + optional RollingDeploymentStrategyParams rollingParams = 4 [(gogoproto.customname) = "RollingParams"]; // resources contains resource requirements to execute the deployment and any hooks. - optional .k8s.io.api.core.v1.ResourceRequirements resources = 5; + optional .k8s.io.api.core.v1.ResourceRequirements resources = 5 [(gogoproto.customname) = "Resources", (gogoproto.nullable) = false]; // labels is a set of key, value pairs added to custom deployer and lifecycle pre/post hook pods. - map labels = 6; + map labels = 6 [(gogoproto.customname) = "Labels", (gogoproto.nullable) = false]; // annotations is a set of key, value pairs added to custom deployer and lifecycle pre/post hook pods. - map annotations = 7; + map annotations = 7 [(gogoproto.customname) = "Annotations", (gogoproto.nullable) = false]; // activeDeadlineSeconds is the duration in seconds that the deployer pods for this deployment // config may be active on a node before the system actively tries to terminate them. - optional int64 activeDeadlineSeconds = 8; + optional int64 activeDeadlineSeconds = 8 [(gogoproto.customname) = "ActiveDeadlineSeconds"]; } // DeploymentTriggerImageChangeParams represents the parameters to the ImageChange trigger. message DeploymentTriggerImageChangeParams { // automatic means that the detection of a new tag value should result in an image update // inside the pod template. - optional bool automatic = 1; + optional bool automatic = 1 [(gogoproto.customname) = "Automatic", (gogoproto.nullable) = false]; // containerNames is used to restrict tag updates to the specified set of container names in a pod. // If multiple triggers point to the same containers, the resulting behavior is undefined. Future // API versions will make this a validation error. If ContainerNames does not point to a valid container, // the trigger will be ignored. Future API versions will make this a validation error. - repeated string containerNames = 2; + repeated string containerNames = 2 [(gogoproto.customname) = "ContainerNames"]; // from is a reference to an image stream tag to watch for changes. From.Name is the only // required subfield - if From.Namespace is blank, the namespace of the current deployment // trigger will be used. - optional .k8s.io.api.core.v1.ObjectReference from = 3; + optional .k8s.io.api.core.v1.ObjectReference from = 3 [(gogoproto.customname) = "From", (gogoproto.nullable) = false]; // lastTriggeredImage is the last image to be triggered. - optional string lastTriggeredImage = 4; + optional string lastTriggeredImage = 4 [(gogoproto.customname) = "LastTriggeredImage", (gogoproto.nullable) = false]; } // DeploymentTriggerPolicies is a list of policies where nil values and different from empty arrays. // +protobuf.nullable=true // +protobuf.options.(gogoproto.goproto_stringer)=false message DeploymentTriggerPolicies { + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + // items, if empty, will result in an empty slice - repeated DeploymentTriggerPolicy items = 1; + repeated DeploymentTriggerPolicy items = 1 [(gogoproto.customname) = "Items", (gogoproto.nullable) = false]; } // DeploymentTriggerPolicy describes a policy for a single trigger that results in a new deployment. message DeploymentTriggerPolicy { // type of the trigger - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "DeploymentTriggerType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // imageChangeParams represents the parameters for the ImageChange trigger. - optional DeploymentTriggerImageChangeParams imageChangeParams = 2; + optional DeploymentTriggerImageChangeParams imageChangeParams = 2 [(gogoproto.customname) = "ImageChangeParams"]; } // ExecNewPodHook is a hook implementation which runs a command in a new pod @@ -387,31 +400,31 @@ message DeploymentTriggerPolicy { // deployment template. message ExecNewPodHook { // command is the action command and its arguments. - repeated string command = 1; + repeated string command = 1 [(gogoproto.customname) = "Command"]; // env is a set of environment variables to supply to the hook pod's container. - repeated .k8s.io.api.core.v1.EnvVar env = 2; + repeated .k8s.io.api.core.v1.EnvVar env = 2 [(gogoproto.customname) = "Env", (gogoproto.nullable) = false]; // containerName is the name of a container in the deployment pod template // whose container image will be used for the hook pod's container. - optional string containerName = 3; + optional string containerName = 3 [(gogoproto.customname) = "ContainerName", (gogoproto.nullable) = false]; // volumes is a list of named volumes from the pod template which should be // copied to the hook pod. Volumes names not found in pod spec are ignored. // An empty list means no volumes will be copied. - repeated string volumes = 4; + repeated string volumes = 4 [(gogoproto.customname) = "Volumes"]; } // LifecycleHook defines a specific deployment lifecycle action. Only one type of action may be specified at any time. message LifecycleHook { // failurePolicy specifies what action to take if the hook fails. - optional string failurePolicy = 1; + optional string failurePolicy = 1 [(gogoproto.casttype) = "LifecycleHookFailurePolicy", (gogoproto.customname) = "FailurePolicy", (gogoproto.nullable) = false]; // execNewPod specifies the options for a lifecycle hook backed by a pod. - optional ExecNewPodHook execNewPod = 2; + optional ExecNewPodHook execNewPod = 2 [(gogoproto.customname) = "ExecNewPod"]; // tagImages instructs the deployer to tag the current image referenced under a container onto an image stream tag. - repeated TagImageHook tagImages = 3; + repeated TagImageHook tagImages = 3 [(gogoproto.customname) = "TagImages", (gogoproto.nullable) = false]; } // RecreateDeploymentStrategyParams are the input to the Recreate deployment @@ -419,19 +432,19 @@ message LifecycleHook { message RecreateDeploymentStrategyParams { // timeoutSeconds is the time to wait for updates before giving up. If the // value is nil, a default will be used. - optional int64 timeoutSeconds = 1; + optional int64 timeoutSeconds = 1 [(gogoproto.customname) = "TimeoutSeconds"]; // pre is a lifecycle hook which is executed before the strategy manipulates // the deployment. All LifecycleHookFailurePolicy values are supported. - optional LifecycleHook pre = 2; + optional LifecycleHook pre = 2 [(gogoproto.customname) = "Pre"]; // mid is a lifecycle hook which is executed while the deployment is scaled down to zero before the first new // pod is created. All LifecycleHookFailurePolicy values are supported. - optional LifecycleHook mid = 3; + optional LifecycleHook mid = 3 [(gogoproto.customname) = "Mid"]; // post is a lifecycle hook which is executed after the strategy has // finished all deployment logic. All LifecycleHookFailurePolicy values are supported. - optional LifecycleHook post = 4; + optional LifecycleHook post = 4 [(gogoproto.customname) = "Post"]; } // RollingDeploymentStrategyParams are the input to the Rolling deployment @@ -439,15 +452,15 @@ message RecreateDeploymentStrategyParams { message RollingDeploymentStrategyParams { // updatePeriodSeconds is the time to wait between individual pod updates. // If the value is nil, a default will be used. - optional int64 updatePeriodSeconds = 1; + optional int64 updatePeriodSeconds = 1 [(gogoproto.customname) = "UpdatePeriodSeconds"]; // intervalSeconds is the time to wait between polling deployment status // after update. If the value is nil, a default will be used. - optional int64 intervalSeconds = 2; + optional int64 intervalSeconds = 2 [(gogoproto.customname) = "IntervalSeconds"]; // timeoutSeconds is the time to wait for updates before giving up. If the // value is nil, a default will be used. - optional int64 timeoutSeconds = 3; + optional int64 timeoutSeconds = 3 [(gogoproto.customname) = "TimeoutSeconds"]; // maxUnavailable is the maximum number of pods that can be unavailable // during the update. Value can be an absolute number (ex: 5) or a @@ -461,7 +474,7 @@ message RollingDeploymentStrategyParams { // RC can be scaled down further, followed by scaling up the new RC, // ensuring that at least 70% of original number of pods are available at // all times during the update. - optional .k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUnavailable = 4; + optional .k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUnavailable = 4 [(gogoproto.customname) = "MaxUnavailable"]; // maxSurge is the maximum number of pods that can be scheduled above the // original number of pods. Value can be an absolute number (ex: 5) or a @@ -475,25 +488,25 @@ message RollingDeploymentStrategyParams { // killed, new RC can be scaled up further, ensuring that total number of // pods running at any time during the update is atmost 130% of original // pods. - optional .k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 5; + optional .k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 5 [(gogoproto.customname) = "MaxSurge"]; // pre is a lifecycle hook which is executed before the deployment process // begins. All LifecycleHookFailurePolicy values are supported. - optional LifecycleHook pre = 7; + optional LifecycleHook pre = 7 [(gogoproto.customname) = "Pre"]; // post is a lifecycle hook which is executed after the strategy has // finished all deployment logic. All LifecycleHookFailurePolicy values // are supported. - optional LifecycleHook post = 8; + optional LifecycleHook post = 8 [(gogoproto.customname) = "Post"]; } // TagImageHook is a request to tag the image in a particular container onto an ImageStreamTag. message TagImageHook { // containerName is the name of a container in the deployment config whose image value will be used as the source of the tag. If there is only a single // container this value will be defaulted to the name of that container. - optional string containerName = 1; + optional string containerName = 1 [(gogoproto.customname) = "ContainerName", (gogoproto.nullable) = false]; // to is the target ImageStreamTag to set the container's image onto. - optional .k8s.io.api.core.v1.ObjectReference to = 2; + optional .k8s.io.api.core.v1.ObjectReference to = 2 [(gogoproto.customname) = "To", (gogoproto.nullable) = false]; } diff --git a/build/v1/generated.proto b/build/v1/generated.proto index 7a18a7f0276..e8d4f44651e 100644 --- a/build/v1/generated.proto +++ b/build/v1/generated.proto @@ -5,11 +5,21 @@ syntax = "proto2"; package github.com.openshift.api.build.v1; +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; import "k8s.io/api/core/v1/generated.proto"; import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; // Package-wide variables from generator "generated". +option (gogoproto.marshaler_all) = true; +option (gogoproto.stable_marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.stringer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.goproto_unrecognized_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; option go_package = "github.com/openshift/api/build/v1"; // BinaryBuildRequestOptions are the options required to fully speficy a binary build request @@ -19,28 +29,28 @@ option go_package = "github.com/openshift/api/build/v1"; message BinaryBuildRequestOptions { // metadata is the standard object's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1 [(gogoproto.customname) = "ObjectMeta", (gogoproto.nullable) = false]; // asFile determines if the binary should be created as a file within the source rather than extracted as an archive - optional string asFile = 2; + optional string asFile = 2 [(gogoproto.customname) = "AsFile", (gogoproto.nullable) = false]; // revision.commit is the value identifying a specific commit - optional string revisionCommit = 3; + optional string revisionCommit = 3 [(gogoproto.customname) = "Commit", (gogoproto.nullable) = false]; // revision.message is the description of a specific commit - optional string revisionMessage = 4; + optional string revisionMessage = 4 [(gogoproto.customname) = "Message", (gogoproto.nullable) = false]; // revision.authorName of the source control user - optional string revisionAuthorName = 5; + optional string revisionAuthorName = 5 [(gogoproto.customname) = "AuthorName", (gogoproto.nullable) = false]; // revision.authorEmail of the source control user - optional string revisionAuthorEmail = 6; + optional string revisionAuthorEmail = 6 [(gogoproto.customname) = "AuthorEmail", (gogoproto.nullable) = false]; // revision.committerName of the source control user - optional string revisionCommitterName = 7; + optional string revisionCommitterName = 7 [(gogoproto.customname) = "CommitterName", (gogoproto.nullable) = false]; // revision.committerEmail of the source control user - optional string revisionCommitterEmail = 8; + optional string revisionCommitterEmail = 8 [(gogoproto.customname) = "CommitterEmail", (gogoproto.nullable) = false]; } // BinaryBuildSource describes a binary file to be used for the Docker and Source build strategies, @@ -52,13 +62,13 @@ message BinaryBuildSource { // strategies assume this file is a zip, tar, or tar.gz file and extract it as the source. // The custom strategy receives this binary as standard input. This filename may not // contain slashes or be '..' or '.'. - optional string asFile = 1; + optional string asFile = 1 [(gogoproto.customname) = "AsFile", (gogoproto.nullable) = false]; } // BitbucketWebHookCause has information about a Bitbucket webhook that triggered a // build. message BitbucketWebHookCause { - optional CommonWebHookCause commonSpec = 1; + optional CommonWebHookCause commonSpec = 1 [(gogoproto.customname) = "CommonWebHookCause", (gogoproto.nullable) = false]; } // Build encapsulates the inputs needed to produce a new deployable image, as well as @@ -69,35 +79,35 @@ message BitbucketWebHookCause { message Build { // metadata is the standard object's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1 [(gogoproto.customname) = "ObjectMeta", (gogoproto.nullable) = false]; // spec is all the inputs used to execute the build. - optional BuildSpec spec = 2; + optional BuildSpec spec = 2 [(gogoproto.customname) = "Spec", (gogoproto.nullable) = false]; // status is the current status of the build. // +optional - optional BuildStatus status = 3; + optional BuildStatus status = 3 [(gogoproto.customname) = "Status", (gogoproto.nullable) = false]; } // BuildCondition describes the state of a build at a certain point. message BuildCondition { // type of build condition. - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "BuildConditionType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // status of the condition, one of True, False, Unknown. - optional string status = 2; + optional string status = 2 [(gogoproto.casttype) = "k8s.io/api/core/v1.ConditionStatus", (gogoproto.customname) = "Status", (gogoproto.nullable) = false]; // The last time this condition was updated. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastUpdateTime = 6; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastUpdateTime = 6 [(gogoproto.customname) = "LastUpdateTime", (gogoproto.nullable) = false]; // The last time the condition transitioned from one status to another. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3 [(gogoproto.customname) = "LastTransitionTime", (gogoproto.nullable) = false]; // The reason for the condition's last transition. - optional string reason = 4; + optional string reason = 4 [(gogoproto.customname) = "Reason", (gogoproto.nullable) = false]; // A human readable message indicating details about the transition. - optional string message = 5; + optional string message = 5 [(gogoproto.customname) = "Message", (gogoproto.nullable) = false]; } // Build configurations define a build process for new container images. There are three types of builds possible - a container image build using a Dockerfile, a Source-to-Image build that uses a specially prepared base image that accepts source code that it can make runnable, and a custom build that can run // arbitrary container images as a base and accept the build parameters. Builds run on the cluster and on completion are pushed to the container image registry specified in the "output" section. A build can be triggered via a webhook, when the base image changes, or when a user manually requests a new build be // created. @@ -109,15 +119,15 @@ message BuildCondition { message BuildConfig { // metadata is the standard object's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1 [(gogoproto.customname) = "ObjectMeta", (gogoproto.nullable) = false]; // spec holds all the input necessary to produce a new build, and the conditions when // to trigger them. - optional BuildConfigSpec spec = 2; + optional BuildConfigSpec spec = 2 [(gogoproto.customname) = "Spec", (gogoproto.nullable) = false]; // status holds any relevant information about a build config // +optional - optional BuildConfigStatus status = 3; + optional BuildConfigStatus status = 3 [(gogoproto.customname) = "Status", (gogoproto.nullable) = false]; } // BuildConfigList is a collection of BuildConfigs. @@ -127,10 +137,10 @@ message BuildConfig { message BuildConfigList { // metadata is the standard list's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1 [(gogoproto.customname) = "ListMeta", (gogoproto.nullable) = false]; // items is a list of build configs - repeated BuildConfig items = 2; + repeated BuildConfig items = 2 [(gogoproto.customname) = "Items", (gogoproto.nullable) = false]; } // BuildConfigSpec describes when and how builds are created @@ -139,38 +149,38 @@ message BuildConfigSpec { // no triggers are defined, a new build can only occur as a result of an // explicit client build creation. // +optional - repeated BuildTriggerPolicy triggers = 1; + repeated BuildTriggerPolicy triggers = 1 [(gogoproto.customname) = "Triggers", (gogoproto.nullable) = false]; // runPolicy describes how the new build created from this build // configuration will be scheduled for execution. // This is optional, if not specified we default to "Serial". - optional string runPolicy = 2; + optional string runPolicy = 2 [(gogoproto.casttype) = "BuildRunPolicy", (gogoproto.customname) = "RunPolicy", (gogoproto.nullable) = false]; // CommonSpec is the desired build specification - optional CommonSpec commonSpec = 3; + optional CommonSpec commonSpec = 3 [(gogoproto.customname) = "CommonSpec", (gogoproto.nullable) = false]; // successfulBuildsHistoryLimit is the number of old successful builds to retain. // When a BuildConfig is created, the 5 most recent successful builds are retained unless this value is set. // If removed after the BuildConfig has been created, all successful builds are retained. - optional int32 successfulBuildsHistoryLimit = 4; + optional int32 successfulBuildsHistoryLimit = 4 [(gogoproto.customname) = "SuccessfulBuildsHistoryLimit"]; // failedBuildsHistoryLimit is the number of old failed builds to retain. // When a BuildConfig is created, the 5 most recent failed builds are retained unless this value is set. // If removed after the BuildConfig has been created, all failed builds are retained. - optional int32 failedBuildsHistoryLimit = 5; + optional int32 failedBuildsHistoryLimit = 5 [(gogoproto.customname) = "FailedBuildsHistoryLimit"]; } // BuildConfigStatus contains current state of the build config object. message BuildConfigStatus { // lastVersion is used to inform about number of last triggered build. // +optional - optional int64 lastVersion = 1; + optional int64 lastVersion = 1 [(gogoproto.customname) = "LastVersion", (gogoproto.nullable) = false]; // imageChangeTriggers captures the runtime state of any ImageChangeTrigger specified in the BuildConfigSpec, // including the value reconciled by the OpenShift APIServer for the lastTriggeredImageID. There is a single entry // in this array for each image change trigger in spec. Each trigger status references the ImageStreamTag that acts as the source of the trigger. // +optional - repeated ImageChangeTriggerStatus imageChangeTriggers = 2; + repeated ImageChangeTriggerStatus imageChangeTriggers = 2 [(gogoproto.customname) = "ImageChangeTriggers", (gogoproto.nullable) = false]; } // BuildList is a collection of Builds. @@ -180,10 +190,10 @@ message BuildConfigStatus { message BuildList { // metadata is the standard list's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1 [(gogoproto.customname) = "ListMeta", (gogoproto.nullable) = false]; // items is a list of builds - repeated Build items = 2; + repeated Build items = 2 [(gogoproto.customname) = "Items", (gogoproto.nullable) = false]; } // BuildLog is the (unused) resource associated with the build log redirector @@ -199,47 +209,47 @@ message BuildLog { // +openshift:compatibility-gen:level=1 message BuildLogOptions { // cointainer for which to stream logs. Defaults to only container if there is one container in the pod. - optional string container = 1; + optional string container = 1 [(gogoproto.customname) = "Container", (gogoproto.nullable) = false]; // follow if true indicates that the build log should be streamed until // the build terminates. - optional bool follow = 2; + optional bool follow = 2 [(gogoproto.customname) = "Follow", (gogoproto.nullable) = false]; // previous returns previous build logs. Defaults to false. - optional bool previous = 3; + optional bool previous = 3 [(gogoproto.customname) = "Previous", (gogoproto.nullable) = false]; // sinceSeconds is a relative time in seconds before the current time from which to show logs. If this value // precedes the time a pod was started, only logs since the pod start will be returned. // If this value is in the future, no logs will be returned. // Only one of sinceSeconds or sinceTime may be specified. - optional int64 sinceSeconds = 4; + optional int64 sinceSeconds = 4 [(gogoproto.customname) = "SinceSeconds"]; // sinceTime is an RFC3339 timestamp from which to show logs. If this value // precedes the time a pod was started, only logs since the pod start will be returned. // If this value is in the future, no logs will be returned. // Only one of sinceSeconds or sinceTime may be specified. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time sinceTime = 5; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time sinceTime = 5 [(gogoproto.customname) = "SinceTime"]; // timestamps, If true, add an RFC3339 or RFC3339Nano timestamp at the beginning of every line // of log output. Defaults to false. - optional bool timestamps = 6; + optional bool timestamps = 6 [(gogoproto.customname) = "Timestamps", (gogoproto.nullable) = false]; // tailLines, If set, is the number of lines from the end of the logs to show. If not specified, // logs are shown from the creation of the container or sinceSeconds or sinceTime - optional int64 tailLines = 7; + optional int64 tailLines = 7 [(gogoproto.customname) = "TailLines"]; // limitBytes, If set, is the number of bytes to read from the server before terminating the // log output. This may not display a complete final line of logging, and may return // slightly more or slightly less than the specified limit. - optional int64 limitBytes = 8; + optional int64 limitBytes = 8 [(gogoproto.customname) = "LimitBytes"]; // nowait if true causes the call to return immediately even if the build // is not available yet. Otherwise the server will wait until the build has started. // TODO: Fix the tag to 'noWait' in v2 - optional bool nowait = 9; + optional bool nowait = 9 [(gogoproto.customname) = "NoWait", (gogoproto.nullable) = false]; // version of the build for which to view logs. - optional int64 version = 10; + optional int64 version = 10 [(gogoproto.customname) = "Version"]; // insecureSkipTLSVerifyBackend indicates that the apiserver should not confirm the validity of the // serving certificate of the backend it is connecting to. This will make the HTTPS connection between the apiserver @@ -248,7 +258,7 @@ message BuildLogOptions { // connection to the real kubelet is vulnerable to a man in the middle attack (e.g. an attacker could not intercept // the actual log data coming from the real kubelet). // +optional - optional bool insecureSkipTLSVerifyBackend = 11; + optional bool insecureSkipTLSVerifyBackend = 11 [(gogoproto.customname) = "InsecureSkipTLSVerifyBackend", (gogoproto.nullable) = false]; } // BuildOutput is input to a build strategy and describes the container image that the strategy @@ -259,16 +269,16 @@ message BuildOutput { // This value will be used to look up a container image repository to push to. // In the case of an ImageStreamTag, the ImageStreamTag will be looked for in the namespace of // the build unless Namespace is specified. - optional .k8s.io.api.core.v1.ObjectReference to = 1; + optional .k8s.io.api.core.v1.ObjectReference to = 1 [(gogoproto.customname) = "To"]; // pushSecret is the name of a Secret that would be used for setting // up the authentication for executing the Docker push to authentication // enabled Docker Registry (or Docker Hub). - optional .k8s.io.api.core.v1.LocalObjectReference pushSecret = 2; + optional .k8s.io.api.core.v1.LocalObjectReference pushSecret = 2 [(gogoproto.customname) = "PushSecret"]; // imageLabels define a list of labels that are applied to the resulting image. If there // are multiple labels with the same name then the last one in the list is used. - repeated ImageLabel imageLabels = 3; + repeated ImageLabel imageLabels = 3 [(gogoproto.customname) = "ImageLabels", (gogoproto.nullable) = false]; } // A BuildPostCommitSpec holds a build post commit hook specification. The hook @@ -341,12 +351,12 @@ message BuildPostCommitSpec { // This might be needed if the image doesn't have `/bin/sh`, or if you // do not want to use a shell. In all other cases, using Script might be // more convenient. - repeated string command = 1; + repeated string command = 1 [(gogoproto.customname) = "Command"]; // args is a list of arguments that are provided to either Command, // Script or the container image's default entrypoint. The arguments are // placed immediately after the command to be run. - repeated string args = 2; + repeated string args = 2 [(gogoproto.customname) = "Args"]; // script is a shell script to be run with `/bin/sh -ic`. It may not be // specified with Command. Use Script when a shell script is appropriate @@ -358,7 +368,7 @@ message BuildPostCommitSpec { // collections enabled in the shell. E.g., in the Ruby image, this is // necessary to make `ruby`, `bundle` and other binaries available in // the PATH. - optional string script = 3; + optional string script = 3 [(gogoproto.customname) = "Script", (gogoproto.nullable) = false]; } // BuildRequest is the resource used to pass parameters to build generator @@ -368,37 +378,37 @@ message BuildPostCommitSpec { message BuildRequest { // metadata is the standard object's metadata. // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata - optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1 [(gogoproto.customname) = "ObjectMeta", (gogoproto.nullable) = false]; // revision is the information from the source for a specific repo snapshot. - optional SourceRevision revision = 2; + optional SourceRevision revision = 2 [(gogoproto.customname) = "Revision"]; // triggeredByImage is the Image that triggered this build. - optional .k8s.io.api.core.v1.ObjectReference triggeredByImage = 3; + optional .k8s.io.api.core.v1.ObjectReference triggeredByImage = 3 [(gogoproto.customname) = "TriggeredByImage"]; // from is the reference to the ImageStreamTag that triggered the build. - optional .k8s.io.api.core.v1.ObjectReference from = 4; + optional .k8s.io.api.core.v1.ObjectReference from = 4 [(gogoproto.customname) = "From"]; // binary indicates a request to build from a binary provided to the builder - optional BinaryBuildSource binary = 5; + optional BinaryBuildSource binary = 5 [(gogoproto.customname) = "Binary"]; // lastVersion (optional) is the LastVersion of the BuildConfig that was used // to generate the build. If the BuildConfig in the generator doesn't match, a build will // not be generated. - optional int64 lastVersion = 6; + optional int64 lastVersion = 6 [(gogoproto.customname) = "LastVersion"]; // env contains additional environment variables you want to pass into a builder container. - repeated .k8s.io.api.core.v1.EnvVar env = 7; + repeated .k8s.io.api.core.v1.EnvVar env = 7 [(gogoproto.customname) = "Env", (gogoproto.nullable) = false]; // triggeredBy describes which triggers started the most recent update to the // build configuration and contains information about those triggers. - repeated BuildTriggerCause triggeredBy = 8; + repeated BuildTriggerCause triggeredBy = 8 [(gogoproto.customname) = "TriggeredBy", (gogoproto.nullable) = false]; // dockerStrategyOptions contains additional docker-strategy specific options for the build - optional DockerStrategyOptions dockerStrategyOptions = 9; + optional DockerStrategyOptions dockerStrategyOptions = 9 [(gogoproto.customname) = "DockerStrategyOptions"]; // sourceStrategyOptions contains additional source-strategy specific options for the build - optional SourceStrategyOptions sourceStrategyOptions = 10; + optional SourceStrategyOptions sourceStrategyOptions = 10 [(gogoproto.customname) = "SourceStrategyOptions"]; } // BuildSource is the SCM used for the build. @@ -406,7 +416,7 @@ message BuildSource { // type of build input to accept // +k8s:conversion-gen=false // +optional - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "BuildSourceType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // binary builds accept a binary as their input. The binary is generally assumed to be a tar, // gzipped tar, or zip file depending on the strategy. For container image builds, this is the build @@ -415,7 +425,7 @@ message BuildSource { // Source and container image builds, if binary.asFile is set the build will receive a directory with // a single file. contextDir may be used when an archive is provided. Custom builds will // receive this binary as input on STDIN. - optional BinaryBuildSource binary = 2; + optional BinaryBuildSource binary = 2 [(gogoproto.customname) = "Binary"]; // dockerfile is the raw contents of a Dockerfile which should be built. When this option is // specified, the FROM may be modified based on your strategy base image and additional ENV @@ -423,44 +433,44 @@ message BuildSource { // of your Dockerfile stanzas. The Dockerfile source type may be used with other options like // git - in those cases the Git repo will have any innate Dockerfile replaced in the context // dir. - optional string dockerfile = 3; + optional string dockerfile = 3 [(gogoproto.customname) = "Dockerfile"]; // git contains optional information about git build source - optional GitBuildSource git = 4; + optional GitBuildSource git = 4 [(gogoproto.customname) = "Git"]; // images describes a set of images to be used to provide source for the build - repeated ImageSource images = 5; + repeated ImageSource images = 5 [(gogoproto.customname) = "Images", (gogoproto.nullable) = false]; // contextDir specifies the sub-directory where the source code for the application exists. // This allows to have buildable sources in directory other than root of // repository. - optional string contextDir = 6; + optional string contextDir = 6 [(gogoproto.customname) = "ContextDir", (gogoproto.nullable) = false]; // sourceSecret is the name of a Secret that would be used for setting // up the authentication for cloning private repository. // The secret contains valid credentials for remote repository, where the // data's key represent the authentication method to be used and value is // the base64 encoded credentials. Supported auth methods are: ssh-privatekey. - optional .k8s.io.api.core.v1.LocalObjectReference sourceSecret = 7; + optional .k8s.io.api.core.v1.LocalObjectReference sourceSecret = 7 [(gogoproto.customname) = "SourceSecret"]; // secrets represents a list of secrets and their destinations that will // be used only for the build. - repeated SecretBuildSource secrets = 8; + repeated SecretBuildSource secrets = 8 [(gogoproto.customname) = "Secrets", (gogoproto.nullable) = false]; // configMaps represents a list of configMaps and their destinations that will // be used for the build. - repeated ConfigMapBuildSource configMaps = 9; + repeated ConfigMapBuildSource configMaps = 9 [(gogoproto.customname) = "ConfigMaps", (gogoproto.nullable) = false]; } // BuildSpec has the information to represent a build and also additional // information about a build message BuildSpec { // CommonSpec is the information that represents a build - optional CommonSpec commonSpec = 1; + optional CommonSpec commonSpec = 1 [(gogoproto.customname) = "CommonSpec", (gogoproto.nullable) = false]; // triggeredBy describes which triggers started the most recent update to the // build configuration and contains information about those triggers. - repeated BuildTriggerCause triggeredBy = 2; + repeated BuildTriggerCause triggeredBy = 2 [(gogoproto.customname) = "TriggeredBy", (gogoproto.nullable) = false]; } // BuildStatus contains the status of a build @@ -468,73 +478,73 @@ message BuildStatus { // phase is the point in the build lifecycle. Possible values are // "New", "Pending", "Running", "Complete", "Failed", "Error", and "Cancelled". // +optional - optional string phase = 1; + optional string phase = 1 [(gogoproto.casttype) = "BuildPhase", (gogoproto.customname) = "Phase", (gogoproto.nullable) = false]; // cancelled describes if a cancel event was triggered for the build. // +optional - optional bool cancelled = 2; + optional bool cancelled = 2 [(gogoproto.customname) = "Cancelled", (gogoproto.nullable) = false]; // reason is a brief CamelCase string that describes any failure and is meant for machine parsing and tidy display in the CLI. // +optional - optional string reason = 3; + optional string reason = 3 [(gogoproto.casttype) = "StatusReason", (gogoproto.customname) = "Reason", (gogoproto.nullable) = false]; // message is a human-readable message indicating details about why the build has this status. // +optional - optional string message = 4; + optional string message = 4 [(gogoproto.customname) = "Message", (gogoproto.nullable) = false]; // startTimestamp is a timestamp representing the server time when this Build started // running in a Pod. // It is represented in RFC3339 form and is in UTC. // +optional - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time startTimestamp = 5; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time startTimestamp = 5 [(gogoproto.customname) = "StartTimestamp"]; // completionTimestamp is a timestamp representing the server time when this Build was // finished, whether that build failed or succeeded. It reflects the time at which // the Pod running the Build terminated. // It is represented in RFC3339 form and is in UTC. // +optional - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time completionTimestamp = 6; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time completionTimestamp = 6 [(gogoproto.customname) = "CompletionTimestamp"]; // duration contains time.Duration object describing build time. // +optional - optional int64 duration = 7; + optional int64 duration = 7 [(gogoproto.casttype) = "time.Duration", (gogoproto.customname) = "Duration", (gogoproto.nullable) = false]; // outputDockerImageReference contains a reference to the container image that // will be built by this build. Its value is computed from // Build.Spec.Output.To, and should include the registry address, so that // it can be used to push and pull the image. // +optional - optional string outputDockerImageReference = 8; + optional string outputDockerImageReference = 8 [(gogoproto.customname) = "OutputDockerImageReference", (gogoproto.nullable) = false]; // config is an ObjectReference to the BuildConfig this Build is based on. // +optional - optional .k8s.io.api.core.v1.ObjectReference config = 9; + optional .k8s.io.api.core.v1.ObjectReference config = 9 [(gogoproto.customname) = "Config"]; // output describes the container image the build has produced. // +optional - optional BuildStatusOutput output = 10; + optional BuildStatusOutput output = 10 [(gogoproto.customname) = "Output", (gogoproto.nullable) = false]; // stages contains details about each stage that occurs during the build // including start time, duration (in milliseconds), and the steps that // occured within each stage. // +optional - repeated StageInfo stages = 11; + repeated StageInfo stages = 11 [(gogoproto.customname) = "Stages", (gogoproto.nullable) = false]; // logSnippet is the last few lines of the build log. This value is only set for builds that failed. // +optional - optional string logSnippet = 12; + optional string logSnippet = 12 [(gogoproto.customname) = "LogSnippet", (gogoproto.nullable) = false]; // conditions represents the latest available observations of a build's current state. // +patchMergeKey=type // +patchStrategy=merge // +optional - repeated BuildCondition conditions = 13; + repeated BuildCondition conditions = 13 [(gogoproto.customname) = "Conditions", (gogoproto.nullable) = false]; } // BuildStatusOutput contains the status of the built image. message BuildStatusOutput { // to describes the status of the built image being pushed to a registry. - optional BuildStatusOutputTo to = 1; + optional BuildStatusOutputTo to = 1 [(gogoproto.customname) = "To"]; } // BuildStatusOutputTo describes the status of the built image with regards to @@ -546,7 +556,7 @@ message BuildStatusOutputTo { // Please note that this field may not always be set even if the push // completes successfully - e.g. when the registry returns no digest or // returns it in a format that the builder doesn't understand. - optional string imageDigest = 1; + optional string imageDigest = 1 [(gogoproto.customname) = "ImageDigest", (gogoproto.nullable) = false]; } // BuildStrategy contains the details of how to perform a build. @@ -554,20 +564,20 @@ message BuildStrategy { // type is the kind of build strategy. // +k8s:conversion-gen=false // +optional - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "BuildStrategyType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // dockerStrategy holds the parameters to the container image build strategy. - optional DockerBuildStrategy dockerStrategy = 2; + optional DockerBuildStrategy dockerStrategy = 2 [(gogoproto.customname) = "DockerStrategy"]; // sourceStrategy holds the parameters to the Source build strategy. - optional SourceBuildStrategy sourceStrategy = 3; + optional SourceBuildStrategy sourceStrategy = 3 [(gogoproto.customname) = "SourceStrategy"]; // customStrategy holds the parameters to the Custom build strategy - optional CustomBuildStrategy customStrategy = 4; + optional CustomBuildStrategy customStrategy = 4 [(gogoproto.customname) = "CustomStrategy"]; // jenkinsPipelineStrategy holds the parameters to the Jenkins Pipeline build strategy. // Deprecated: use OpenShift Pipelines - optional JenkinsPipelineBuildStrategy jenkinsPipelineStrategy = 5; + optional JenkinsPipelineBuildStrategy jenkinsPipelineStrategy = 5 [(gogoproto.customname) = "JenkinsPipelineStrategy"]; } // BuildTriggerCause holds information about a triggered build. It is used for @@ -577,26 +587,26 @@ message BuildStrategy { message BuildTriggerCause { // message is used to store a human readable message for why the build was // triggered. E.g.: "Manually triggered by user", "Configuration change",etc. - optional string message = 1; + optional string message = 1 [(gogoproto.customname) = "Message", (gogoproto.nullable) = false]; // genericWebHook holds data about a builds generic webhook trigger. - optional GenericWebHookCause genericWebHook = 2; + optional GenericWebHookCause genericWebHook = 2 [(gogoproto.customname) = "GenericWebHook"]; // githubWebHook represents data for a GitHub webhook that fired a // specific build. - optional GitHubWebHookCause githubWebHook = 3; + optional GitHubWebHookCause githubWebHook = 3 [(gogoproto.customname) = "GitHubWebHook"]; // imageChangeBuild stores information about an imagechange event // that triggered a new build. - optional ImageChangeCause imageChangeBuild = 4; + optional ImageChangeCause imageChangeBuild = 4 [(gogoproto.customname) = "ImageChangeBuild"]; // gitlabWebHook represents data for a GitLab webhook that fired a specific // build. - optional GitLabWebHookCause gitlabWebHook = 5; + optional GitLabWebHookCause gitlabWebHook = 5 [(gogoproto.customname) = "GitLabWebHook"]; // bitbucketWebHook represents data for a Bitbucket webhook that fired a // specific build. - optional BitbucketWebHookCause bitbucketWebHook = 6; + optional BitbucketWebHookCause bitbucketWebHook = 6 [(gogoproto.customname) = "BitbucketWebHook"]; } // BuildTriggerPolicy describes a policy for a single trigger that results in a new Build. @@ -626,23 +636,23 @@ message BuildTriggerPolicy { // - ConfigChange // ConfigChangeBuildTriggerType will trigger a build on an initial build config creation // WARNING: In the future the behavior will change to trigger a build on any config change - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "BuildTriggerType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // github contains the parameters for a GitHub webhook type of trigger - optional WebHookTrigger github = 2; + optional WebHookTrigger github = 2 [(gogoproto.customname) = "GitHubWebHook"]; // generic contains the parameters for a Generic webhook type of trigger - optional WebHookTrigger generic = 3; + optional WebHookTrigger generic = 3 [(gogoproto.customname) = "GenericWebHook"]; // imageChange contains parameters for an ImageChange type of trigger - optional ImageChangeTrigger imageChange = 4; + optional ImageChangeTrigger imageChange = 4 [(gogoproto.customname) = "ImageChange"]; // GitLabWebHook contains the parameters for a GitLab webhook type of trigger - optional WebHookTrigger gitlab = 5; + optional WebHookTrigger gitlab = 5 [(gogoproto.customname) = "GitLabWebHook"]; // BitbucketWebHook contains the parameters for a Bitbucket webhook type of // trigger - optional WebHookTrigger bitbucket = 6; + optional WebHookTrigger bitbucket = 6 [(gogoproto.customname) = "BitbucketWebHook"]; } // BuildVolume describes a volume that is made available to build pods, @@ -655,11 +665,11 @@ message BuildVolume { // failed build with an error message detailing which name caused the error. // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names // +required - optional string name = 1; + optional string name = 1 [(gogoproto.customname) = "Name", (gogoproto.nullable) = false]; // source represents the location and type of the mounted volume. // +required - optional BuildVolumeSource source = 2; + optional BuildVolumeSource source = 2 [(gogoproto.customname) = "Source", (gogoproto.nullable) = false]; // mounts represents the location of the volume in the image build container // +required @@ -667,7 +677,7 @@ message BuildVolume { // +listMapKey=destinationPath // +patchMergeKey=destinationPath // +patchStrategy=merge - repeated BuildVolumeMount mounts = 3; + repeated BuildVolumeMount mounts = 3 [(gogoproto.customname) = "Mounts", (gogoproto.nullable) = false]; } // BuildVolumeMount describes the mounting of a Volume within buildah's runtime environment. @@ -678,7 +688,7 @@ message BuildVolumeMount { // by the builder process // Paths that collide with those added by the build controller will result in a // failed build with an error message detailing which path caused the error. - optional string destinationPath = 1; + optional string destinationPath = 1 [(gogoproto.customname) = "DestinationPath", (gogoproto.nullable) = false]; } // BuildVolumeSource represents the source of a volume to mount @@ -687,20 +697,20 @@ message BuildVolumeSource { // type is the BuildVolumeSourceType for the volume source. // Type must match the populated volume source. // Valid types are: Secret, ConfigMap - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "BuildVolumeSourceType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // secret represents a Secret that should populate this volume. // More info: https://kubernetes.io/docs/concepts/storage/volumes#secret // +optional - optional .k8s.io.api.core.v1.SecretVolumeSource secret = 2; + optional .k8s.io.api.core.v1.SecretVolumeSource secret = 2 [(gogoproto.customname) = "Secret"]; // configMap represents a ConfigMap that should populate this volume // +optional - optional .k8s.io.api.core.v1.ConfigMapVolumeSource configMap = 3; + optional .k8s.io.api.core.v1.ConfigMapVolumeSource configMap = 3 [(gogoproto.customname) = "ConfigMap"]; // csi represents ephemeral storage provided by external CSI drivers which support this capability // +optional - optional .k8s.io.api.core.v1.CSIVolumeSource csi = 4; + optional .k8s.io.api.core.v1.CSIVolumeSource csi = 4 [(gogoproto.customname) = "CSI"]; } // CommonSpec encapsulates all the inputs necessary to represent a build. @@ -708,40 +718,40 @@ message CommonSpec { // serviceAccount is the name of the ServiceAccount to use to run the pod // created by this build. // The pod will be allowed to use secrets referenced by the ServiceAccount - optional string serviceAccount = 1; + optional string serviceAccount = 1 [(gogoproto.customname) = "ServiceAccount", (gogoproto.nullable) = false]; // source describes the SCM in use. - optional BuildSource source = 2; + optional BuildSource source = 2 [(gogoproto.customname) = "Source", (gogoproto.nullable) = false]; // revision is the information from the source for a specific repo snapshot. // This is optional. - optional SourceRevision revision = 3; + optional SourceRevision revision = 3 [(gogoproto.customname) = "Revision"]; // strategy defines how to perform a build. - optional BuildStrategy strategy = 4; + optional BuildStrategy strategy = 4 [(gogoproto.customname) = "Strategy", (gogoproto.nullable) = false]; // output describes the container image the Strategy should produce. - optional BuildOutput output = 5; + optional BuildOutput output = 5 [(gogoproto.customname) = "Output", (gogoproto.nullable) = false]; // resources computes resource requirements to execute the build. - optional .k8s.io.api.core.v1.ResourceRequirements resources = 6; + optional .k8s.io.api.core.v1.ResourceRequirements resources = 6 [(gogoproto.customname) = "Resources", (gogoproto.nullable) = false]; // postCommit is a build hook executed after the build output image is // committed, before it is pushed to a registry. - optional BuildPostCommitSpec postCommit = 7; + optional BuildPostCommitSpec postCommit = 7 [(gogoproto.customname) = "PostCommit", (gogoproto.nullable) = false]; // completionDeadlineSeconds is an optional duration in seconds, counted from // the time when a build pod gets scheduled in the system, that the build may // be active on a node before the system actively tries to terminate the // build; value must be positive integer - optional int64 completionDeadlineSeconds = 8; + optional int64 completionDeadlineSeconds = 8 [(gogoproto.customname) = "CompletionDeadlineSeconds"]; // nodeSelector is a selector which must be true for the build pod to fit on a node // If nil, it can be overridden by default build nodeselector values for the cluster. // If set to an empty map or a map with any values, default build nodeselector values // are ignored. // +optional - optional OptionalNodeSelector nodeSelector = 9; + optional OptionalNodeSelector nodeSelector = 9 [(gogoproto.customname) = "NodeSelector"]; // mountTrustedCA bind mounts the cluster's trusted certificate authorities, as defined in // the cluster's proxy configuration, into the build. This lets processes within a build trust @@ -751,7 +761,7 @@ message CommonSpec { // When this field is set to true, the contents of `/etc/pki/ca-trust` within the build are // managed by the build container, and any changes to this directory or its subdirectories (for // example - within a Dockerfile `RUN` instruction) are not persisted in the build's output image. - optional bool mountTrustedCA = 10; + optional bool mountTrustedCA = 10 [(gogoproto.customname) = "MountTrustedCA"]; } // CommonWebHookCause factors out the identical format of these webhook @@ -759,10 +769,10 @@ message CommonSpec { // GitHub and Generic but we can leverage this pattern with GitLab and Bitbucket. message CommonWebHookCause { // revision is the git source revision information of the trigger. - optional SourceRevision revision = 1; + optional SourceRevision revision = 1 [(gogoproto.customname) = "Revision"]; // secret is the obfuscated webhook secret that triggered a build. - optional string secret = 2; + optional string secret = 2 [(gogoproto.customname) = "Secret", (gogoproto.nullable) = false]; } // ConfigMapBuildSource describes a configmap and its destination directory that will be @@ -771,7 +781,7 @@ message CommonWebHookCause { message ConfigMapBuildSource { // configMap is a reference to an existing configmap that you want to use in your // build. - optional .k8s.io.api.core.v1.LocalObjectReference configMap = 1; + optional .k8s.io.api.core.v1.LocalObjectReference configMap = 1 [(gogoproto.customname) = "ConfigMap", (gogoproto.nullable) = false]; // destinationDir is the directory where the files from the configmap should be // available for the build time. @@ -780,37 +790,37 @@ message ConfigMapBuildSource { // For the container image build strategy, these will be copied into the build // directory, where the Dockerfile is located, so users can ADD or COPY them // during container image build. - optional string destinationDir = 2; + optional string destinationDir = 2 [(gogoproto.customname) = "DestinationDir", (gogoproto.nullable) = false]; } // CustomBuildStrategy defines input parameters specific to Custom build. message CustomBuildStrategy { // from is reference to an DockerImage, ImageStreamTag, or ImageStreamImage from which // the container image should be pulled - optional .k8s.io.api.core.v1.ObjectReference from = 1; + optional .k8s.io.api.core.v1.ObjectReference from = 1 [(gogoproto.customname) = "From", (gogoproto.nullable) = false]; // pullSecret is the name of a Secret that would be used for setting up // the authentication for pulling the container images from the private Docker // registries - optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 2; + optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 2 [(gogoproto.customname) = "PullSecret"]; // env contains additional environment variables you want to pass into a builder container. - repeated .k8s.io.api.core.v1.EnvVar env = 3; + repeated .k8s.io.api.core.v1.EnvVar env = 3 [(gogoproto.customname) = "Env", (gogoproto.nullable) = false]; // exposeDockerSocket will allow running Docker commands (and build container images) from // inside the container. // TODO: Allow admins to enforce 'false' for this option - optional bool exposeDockerSocket = 4; + optional bool exposeDockerSocket = 4 [(gogoproto.customname) = "ExposeDockerSocket", (gogoproto.nullable) = false]; // forcePull describes if the controller should configure the build pod to always pull the images // for the builder or only pull if it is not present locally - optional bool forcePull = 5; + optional bool forcePull = 5 [(gogoproto.customname) = "ForcePull", (gogoproto.nullable) = false]; // secrets is a list of additional secrets that will be included in the build pod - repeated SecretSpec secrets = 6; + repeated SecretSpec secrets = 6 [(gogoproto.customname) = "Secrets", (gogoproto.nullable) = false]; // buildAPIVersion is the requested API version for the Build object serialized and passed to the custom builder - optional string buildAPIVersion = 7; + optional string buildAPIVersion = 7 [(gogoproto.customname) = "BuildAPIVersion", (gogoproto.nullable) = false]; } // DockerBuildStrategy defines input parameters specific to container image build. @@ -818,33 +828,33 @@ message DockerBuildStrategy { // from is a reference to an DockerImage, ImageStreamTag, or ImageStreamImage which overrides // the FROM image in the Dockerfile for the build. If the Dockerfile uses multi-stage builds, // this will replace the image in the last FROM directive of the file. - optional .k8s.io.api.core.v1.ObjectReference from = 1; + optional .k8s.io.api.core.v1.ObjectReference from = 1 [(gogoproto.customname) = "From"]; // pullSecret is the name of a Secret that would be used for setting up // the authentication for pulling the container images from the private Docker // registries - optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 2; + optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 2 [(gogoproto.customname) = "PullSecret"]; // noCache if set to true indicates that the container image build must be executed with the // --no-cache=true flag - optional bool noCache = 3; + optional bool noCache = 3 [(gogoproto.customname) = "NoCache", (gogoproto.nullable) = false]; // env contains additional environment variables you want to pass into a builder container. - repeated .k8s.io.api.core.v1.EnvVar env = 4; + repeated .k8s.io.api.core.v1.EnvVar env = 4 [(gogoproto.customname) = "Env", (gogoproto.nullable) = false]; // forcePull describes if the builder should pull the images from registry prior to building. - optional bool forcePull = 5; + optional bool forcePull = 5 [(gogoproto.customname) = "ForcePull", (gogoproto.nullable) = false]; // dockerfilePath is the path of the Dockerfile that will be used to build the container image, // relative to the root of the context (contextDir). // Defaults to `Dockerfile` if unset. - optional string dockerfilePath = 6; + optional string dockerfilePath = 6 [(gogoproto.customname) = "DockerfilePath", (gogoproto.nullable) = false]; // buildArgs contains build arguments that will be resolved in the Dockerfile. See // https://docs.docker.com/engine/reference/builder/#/arg for more details. // NOTE: Only the 'name' and 'value' fields are supported. Any settings on the 'valueFrom' field // are ignored. - repeated .k8s.io.api.core.v1.EnvVar buildArgs = 7; + repeated .k8s.io.api.core.v1.EnvVar buildArgs = 7 [(gogoproto.customname) = "BuildArgs", (gogoproto.nullable) = false]; // imageOptimizationPolicy describes what optimizations the system can use when building images // to reduce the final size or time spent building the image. The default policy is 'None' which @@ -853,7 +863,7 @@ message DockerBuildStrategy { // image step, and will fail if the Dockerfile cannot provide compatibility with the 'None' // policy. An additional experimental policy 'SkipLayersAndWarn' is the same as // 'SkipLayers' but simply warns if compatibility cannot be preserved. - optional string imageOptimizationPolicy = 8; + optional string imageOptimizationPolicy = 8 [(gogoproto.casttype) = "ImageOptimizationPolicy", (gogoproto.customname) = "ImageOptimizationPolicy"]; // volumes is a list of input volumes that can be mounted into the builds runtime environment. // Only a subset of Kubernetes Volume sources are supported by builds. @@ -862,17 +872,17 @@ message DockerBuildStrategy { // +listMapKey=name // +patchMergeKey=name // +patchStrategy=merge - repeated BuildVolume volumes = 9; + repeated BuildVolume volumes = 9 [(gogoproto.customname) = "Volumes", (gogoproto.nullable) = false]; } // DockerStrategyOptions contains extra strategy options for container image builds message DockerStrategyOptions { // Args contains any build arguments that are to be passed to Docker. See // https://docs.docker.com/engine/reference/builder/#/arg for more details - repeated .k8s.io.api.core.v1.EnvVar buildArgs = 1; + repeated .k8s.io.api.core.v1.EnvVar buildArgs = 1 [(gogoproto.customname) = "BuildArgs", (gogoproto.nullable) = false]; // noCache overrides the docker-strategy noCache option in the build config - optional bool noCache = 2; + optional bool noCache = 2 [(gogoproto.customname) = "NoCache"]; } // GenericWebHookCause holds information about a generic WebHook that @@ -880,102 +890,102 @@ message DockerStrategyOptions { message GenericWebHookCause { // revision is an optional field that stores the git source revision // information of the generic webhook trigger when it is available. - optional SourceRevision revision = 1; + optional SourceRevision revision = 1 [(gogoproto.customname) = "Revision"]; // secret is the obfuscated webhook secret that triggered a build. - optional string secret = 2; + optional string secret = 2 [(gogoproto.customname) = "Secret", (gogoproto.nullable) = false]; } // GenericWebHookEvent is the payload expected for a generic webhook post message GenericWebHookEvent { // type is the type of source repository // +k8s:conversion-gen=false - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "BuildSourceType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // git is the git information if the Type is BuildSourceGit - optional GitInfo git = 2; + optional GitInfo git = 2 [(gogoproto.customname) = "Git"]; // env contains additional environment variables you want to pass into a builder container. // ValueFrom is not supported. - repeated .k8s.io.api.core.v1.EnvVar env = 3; + repeated .k8s.io.api.core.v1.EnvVar env = 3 [(gogoproto.customname) = "Env", (gogoproto.nullable) = false]; // dockerStrategyOptions contains additional docker-strategy specific options for the build - optional DockerStrategyOptions dockerStrategyOptions = 4; + optional DockerStrategyOptions dockerStrategyOptions = 4 [(gogoproto.customname) = "DockerStrategyOptions"]; } // GitBuildSource defines the parameters of a Git SCM message GitBuildSource { // uri points to the source that will be built. The structure of the source // will depend on the type of build to run - optional string uri = 1; + optional string uri = 1 [(gogoproto.customname) = "URI", (gogoproto.nullable) = false]; // ref is the branch/tag/ref to build. - optional string ref = 2; + optional string ref = 2 [(gogoproto.customname) = "Ref", (gogoproto.nullable) = false]; // proxyConfig defines the proxies to use for the git clone operation. Values // not set here are inherited from cluster-wide build git proxy settings. - optional ProxyConfig proxyConfig = 3; + optional ProxyConfig proxyConfig = 3 [(gogoproto.customname) = "ProxyConfig", (gogoproto.nullable) = false]; } // GitHubWebHookCause has information about a GitHub webhook that triggered a // build. message GitHubWebHookCause { // revision is the git revision information of the trigger. - optional SourceRevision revision = 1; + optional SourceRevision revision = 1 [(gogoproto.customname) = "Revision"]; // secret is the obfuscated webhook secret that triggered a build. - optional string secret = 2; + optional string secret = 2 [(gogoproto.customname) = "Secret", (gogoproto.nullable) = false]; } // GitInfo is the aggregated git information for a generic webhook post message GitInfo { - optional GitBuildSource gitBuildSource = 1; + optional GitBuildSource gitBuildSource = 1 [(gogoproto.customname) = "GitBuildSource", (gogoproto.nullable) = false]; - optional GitSourceRevision gitSourceRevision = 2; + optional GitSourceRevision gitSourceRevision = 2 [(gogoproto.customname) = "GitSourceRevision", (gogoproto.nullable) = false]; // refs is a list of GitRefs for the provided repo - generally sent // when used from a post-receive hook. This field is optional and is // used when sending multiple refs - repeated GitRefInfo refs = 3; + repeated GitRefInfo refs = 3 [(gogoproto.customname) = "Refs", (gogoproto.nullable) = false]; } // GitLabWebHookCause has information about a GitLab webhook that triggered a // build. message GitLabWebHookCause { - optional CommonWebHookCause commonSpec = 1; + optional CommonWebHookCause commonSpec = 1 [(gogoproto.customname) = "CommonWebHookCause", (gogoproto.nullable) = false]; } // GitRefInfo is a single ref message GitRefInfo { - optional GitBuildSource gitBuildSource = 1; + optional GitBuildSource gitBuildSource = 1 [(gogoproto.customname) = "GitBuildSource", (gogoproto.nullable) = false]; - optional GitSourceRevision gitSourceRevision = 2; + optional GitSourceRevision gitSourceRevision = 2 [(gogoproto.customname) = "GitSourceRevision", (gogoproto.nullable) = false]; } // GitSourceRevision is the commit information from a git source for a build message GitSourceRevision { // commit is the commit hash identifying a specific commit - optional string commit = 1; + optional string commit = 1 [(gogoproto.customname) = "Commit", (gogoproto.nullable) = false]; // author is the author of a specific commit - optional SourceControlUser author = 2; + optional SourceControlUser author = 2 [(gogoproto.customname) = "Author", (gogoproto.nullable) = false]; // committer is the committer of a specific commit - optional SourceControlUser committer = 3; + optional SourceControlUser committer = 3 [(gogoproto.customname) = "Committer", (gogoproto.nullable) = false]; // message is the description of a specific commit - optional string message = 4; + optional string message = 4 [(gogoproto.customname) = "Message", (gogoproto.nullable) = false]; } // ImageChangeCause contains information about the image that triggered a // build message ImageChangeCause { // imageID is the ID of the image that triggered a new build. - optional string imageID = 1; + optional string imageID = 1 [(gogoproto.customname) = "ImageID", (gogoproto.nullable) = false]; // fromRef contains detailed information about an image that triggered a // build. - optional .k8s.io.api.core.v1.ObjectReference fromRef = 2; + optional .k8s.io.api.core.v1.ObjectReference fromRef = 2 [(gogoproto.customname) = "FromRef"]; } // ImageChangeTrigger allows builds to be triggered when an ImageStream changes @@ -984,16 +994,16 @@ message ImageChangeTrigger { // used image ID for build // This field is deprecated and will be removed in a future release. // Deprecated - optional string lastTriggeredImageID = 1; + optional string lastTriggeredImageID = 1 [(gogoproto.customname) = "LastTriggeredImageID", (gogoproto.nullable) = false]; // from is a reference to an ImageStreamTag that will trigger a build when updated // It is optional. If no From is specified, the From image from the build strategy // will be used. Only one ImageChangeTrigger with an empty From reference is allowed in // a build configuration. - optional .k8s.io.api.core.v1.ObjectReference from = 2; + optional .k8s.io.api.core.v1.ObjectReference from = 2 [(gogoproto.customname) = "From"]; // paused is true if this trigger is temporarily disabled. Optional. - optional bool paused = 3; + optional bool paused = 3 [(gogoproto.customname) = "Paused", (gogoproto.nullable) = false]; } // ImageChangeTriggerStatus tracks the latest resolved status of the associated ImageChangeTrigger policy @@ -1001,23 +1011,23 @@ message ImageChangeTrigger { message ImageChangeTriggerStatus { // lastTriggeredImageID represents the sha/id of the ImageStreamTag when a Build for this BuildConfig was started. // The lastTriggeredImageID is updated each time a Build for this BuildConfig is started, even if this ImageStreamTag is not the reason the Build is started. - optional string lastTriggeredImageID = 1; + optional string lastTriggeredImageID = 1 [(gogoproto.customname) = "LastTriggeredImageID", (gogoproto.nullable) = false]; // from is the ImageStreamTag that is the source of the trigger. - optional ImageStreamTagReference from = 2; + optional ImageStreamTagReference from = 2 [(gogoproto.customname) = "From", (gogoproto.nullable) = false]; // lastTriggerTime is the last time this particular ImageStreamTag triggered a Build to start. // This field is only updated when this trigger specifically started a Build. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTriggerTime = 3; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTriggerTime = 3 [(gogoproto.customname) = "LastTriggerTime", (gogoproto.nullable) = false]; } // ImageLabel represents a label applied to the resulting image. message ImageLabel { // name defines the name of the label. It must have non-zero length. - optional string name = 1; + optional string name = 1 [(gogoproto.customname) = "Name", (gogoproto.nullable) = false]; // value defines the literal value of the label. - optional string value = 2; + optional string value = 2 [(gogoproto.customname) = "Value", (gogoproto.nullable) = false]; } // ImageSource is used to describe build source that will be extracted from an image or used during a @@ -1030,7 +1040,7 @@ message ImageLabel { message ImageSource { // from is a reference to an ImageStreamTag, ImageStreamImage, or DockerImage to // copy source from. - optional .k8s.io.api.core.v1.ObjectReference from = 1; + optional .k8s.io.api.core.v1.ObjectReference from = 1 [(gogoproto.customname) = "From", (gogoproto.nullable) = false]; // A list of image names that this source will be used in place of during a multi-stage container image // build. For instance, a Dockerfile that uses "COPY --from=nginx:latest" will first check for an image @@ -1038,17 +1048,17 @@ message ImageSource { // does not reference an image source it is ignored. This field and paths may both be set, in which case // the contents will be used twice. // +optional - repeated string as = 4; + repeated string as = 4 [(gogoproto.customname) = "As"]; // paths is a list of source and destination paths to copy from the image. This content will be copied // into the build context prior to starting the build. If no paths are set, the build context will // not be altered. // +optional - repeated ImageSourcePath paths = 2; + repeated ImageSourcePath paths = 2 [(gogoproto.customname) = "Paths", (gogoproto.nullable) = false]; // pullSecret is a reference to a secret to be used to pull the image from a registry // If the image is pulled from the OpenShift registry, this field does not need to be set. - optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 3; + optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 3 [(gogoproto.customname) = "PullSecret"]; } // ImageSourcePath describes a path to be copied from a source image and its destination within the build directory. @@ -1057,20 +1067,20 @@ message ImageSourcePath { // copy to the build directory. If the source path ends in /. then the content of // the directory will be copied, but the directory itself will not be created at the // destination. - optional string sourcePath = 1; + optional string sourcePath = 1 [(gogoproto.customname) = "SourcePath", (gogoproto.nullable) = false]; // destinationDir is the relative directory within the build directory // where files copied from the image are placed. - optional string destinationDir = 2; + optional string destinationDir = 2 [(gogoproto.customname) = "DestinationDir", (gogoproto.nullable) = false]; } // ImageStreamTagReference references the ImageStreamTag in an image change trigger by namespace and name. message ImageStreamTagReference { // namespace is the namespace where the ImageStreamTag for an ImageChangeTrigger is located - optional string namespace = 1; + optional string namespace = 1 [(gogoproto.customname) = "Namespace", (gogoproto.nullable) = false]; // name is the name of the ImageStreamTag for an ImageChangeTrigger - optional string name = 2; + optional string name = 2 [(gogoproto.customname) = "Name", (gogoproto.nullable) = false]; } // JenkinsPipelineBuildStrategy holds parameters specific to a Jenkins Pipeline build. @@ -1079,34 +1089,37 @@ message JenkinsPipelineBuildStrategy { // jenkinsfilePath is the optional path of the Jenkinsfile that will be used to configure the pipeline // relative to the root of the context (contextDir). If both JenkinsfilePath & Jenkinsfile are // both not specified, this defaults to Jenkinsfile in the root of the specified contextDir. - optional string jenkinsfilePath = 1; + optional string jenkinsfilePath = 1 [(gogoproto.customname) = "JenkinsfilePath", (gogoproto.nullable) = false]; // jenkinsfile defines the optional raw contents of a Jenkinsfile which defines a Jenkins pipeline build. - optional string jenkinsfile = 2; + optional string jenkinsfile = 2 [(gogoproto.customname) = "Jenkinsfile", (gogoproto.nullable) = false]; // env contains additional environment variables you want to pass into a build pipeline. - repeated .k8s.io.api.core.v1.EnvVar env = 3; + repeated .k8s.io.api.core.v1.EnvVar env = 3 [(gogoproto.customname) = "Env", (gogoproto.nullable) = false]; } // OptionalNodeSelector is a map that may also be left nil to distinguish between set and unset. // +protobuf.nullable=true // +protobuf.options.(gogoproto.goproto_stringer)=false message OptionalNodeSelector { + option (gogoproto.goproto_stringer) = false; + option (gogoproto.stringer) = false; + // items, if empty, will result in an empty map - map items = 1; + map items = 1 [(gogoproto.customname) = "Items", (gogoproto.nullable) = false]; } // ProxyConfig defines what proxies to use for an operation message ProxyConfig { // httpProxy is a proxy used to reach the git repository over http - optional string httpProxy = 3; + optional string httpProxy = 3 [(gogoproto.customname) = "HTTPProxy"]; // httpsProxy is a proxy used to reach the git repository over https - optional string httpsProxy = 4; + optional string httpsProxy = 4 [(gogoproto.customname) = "HTTPSProxy"]; // noProxy is the list of domains for which the proxy should not be used - optional string noProxy = 5; + optional string noProxy = 5 [(gogoproto.customname) = "NoProxy"]; } // SecretBuildSource describes a secret and its destination directory that will be @@ -1115,7 +1128,7 @@ message ProxyConfig { message SecretBuildSource { // secret is a reference to an existing secret that you want to use in your // build. - optional .k8s.io.api.core.v1.LocalObjectReference secret = 1; + optional .k8s.io.api.core.v1.LocalObjectReference secret = 1 [(gogoproto.customname) = "Secret", (gogoproto.nullable) = false]; // destinationDir is the directory where the files from the secret should be // available for the build time. @@ -1125,46 +1138,46 @@ message SecretBuildSource { // For the container image build strategy, these will be copied into the build // directory, where the Dockerfile is located, so users can ADD or COPY them // during container image build. - optional string destinationDir = 2; + optional string destinationDir = 2 [(gogoproto.customname) = "DestinationDir", (gogoproto.nullable) = false]; } // SecretLocalReference contains information that points to the local secret being used message SecretLocalReference { // name is the name of the resource in the same namespace being referenced - optional string name = 1; + optional string name = 1 [(gogoproto.customname) = "Name", (gogoproto.nullable) = false]; } // SecretSpec specifies a secret to be included in a build pod and its corresponding mount point message SecretSpec { // secretSource is a reference to the secret - optional .k8s.io.api.core.v1.LocalObjectReference secretSource = 1; + optional .k8s.io.api.core.v1.LocalObjectReference secretSource = 1 [(gogoproto.customname) = "SecretSource", (gogoproto.nullable) = false]; // mountPath is the path at which to mount the secret - optional string mountPath = 2; + optional string mountPath = 2 [(gogoproto.customname) = "MountPath", (gogoproto.nullable) = false]; } // SourceBuildStrategy defines input parameters specific to an Source build. message SourceBuildStrategy { // from is reference to an DockerImage, ImageStreamTag, or ImageStreamImage from which // the container image should be pulled - optional .k8s.io.api.core.v1.ObjectReference from = 1; + optional .k8s.io.api.core.v1.ObjectReference from = 1 [(gogoproto.customname) = "From", (gogoproto.nullable) = false]; // pullSecret is the name of a Secret that would be used for setting up // the authentication for pulling the container images from the private Docker // registries - optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 2; + optional .k8s.io.api.core.v1.LocalObjectReference pullSecret = 2 [(gogoproto.customname) = "PullSecret"]; // env contains additional environment variables you want to pass into a builder container. - repeated .k8s.io.api.core.v1.EnvVar env = 3; + repeated .k8s.io.api.core.v1.EnvVar env = 3 [(gogoproto.customname) = "Env", (gogoproto.nullable) = false]; // scripts is the location of Source scripts - optional string scripts = 4; + optional string scripts = 4 [(gogoproto.customname) = "Scripts", (gogoproto.nullable) = false]; // incremental flag forces the Source build to do incremental builds if true. - optional bool incremental = 5; + optional bool incremental = 5 [(gogoproto.customname) = "Incremental"]; // forcePull describes if the builder should pull the images from registry prior to building. - optional bool forcePull = 6; + optional bool forcePull = 6 [(gogoproto.customname) = "ForcePull", (gogoproto.nullable) = false]; // volumes is a list of input volumes that can be mounted into the builds runtime environment. // Only a subset of Kubernetes Volume sources are supported by builds. @@ -1173,82 +1186,82 @@ message SourceBuildStrategy { // +listMapKey=name // +patchMergeKey=name // +patchStrategy=merge - repeated BuildVolume volumes = 9; + repeated BuildVolume volumes = 9 [(gogoproto.customname) = "Volumes", (gogoproto.nullable) = false]; } // SourceControlUser defines the identity of a user of source control message SourceControlUser { // name of the source control user - optional string name = 1; + optional string name = 1 [(gogoproto.customname) = "Name", (gogoproto.nullable) = false]; // email of the source control user - optional string email = 2; + optional string email = 2 [(gogoproto.customname) = "Email", (gogoproto.nullable) = false]; } // SourceRevision is the revision or commit information from the source for the build message SourceRevision { // type of the build source, may be one of 'Source', 'Dockerfile', 'Binary', or 'Images' // +k8s:conversion-gen=false - optional string type = 1; + optional string type = 1 [(gogoproto.casttype) = "BuildSourceType", (gogoproto.customname) = "Type", (gogoproto.nullable) = false]; // git contains information about git-based build source - optional GitSourceRevision git = 2; + optional GitSourceRevision git = 2 [(gogoproto.customname) = "Git"]; } // SourceStrategyOptions contains extra strategy options for Source builds message SourceStrategyOptions { // incremental overrides the source-strategy incremental option in the build config - optional bool incremental = 1; + optional bool incremental = 1 [(gogoproto.customname) = "Incremental"]; } // StageInfo contains details about a build stage. message StageInfo { // name is a unique identifier for each build stage that occurs. - optional string name = 1; + optional string name = 1 [(gogoproto.casttype) = "StageName", (gogoproto.customname) = "Name", (gogoproto.nullable) = false]; // startTime is a timestamp representing the server time when this Stage started. // It is represented in RFC3339 form and is in UTC. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time startTime = 2; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time startTime = 2 [(gogoproto.customname) = "StartTime", (gogoproto.nullable) = false]; // durationMilliseconds identifies how long the stage took // to complete in milliseconds. // Note: the duration of a stage can exceed the sum of the duration of the steps within // the stage as not all actions are accounted for in explicit build steps. - optional int64 durationMilliseconds = 3; + optional int64 durationMilliseconds = 3 [(gogoproto.customname) = "DurationMilliseconds", (gogoproto.nullable) = false]; // steps contains details about each step that occurs during a build stage // including start time and duration in milliseconds. - repeated StepInfo steps = 4; + repeated StepInfo steps = 4 [(gogoproto.customname) = "Steps", (gogoproto.nullable) = false]; } // StepInfo contains details about a build step. message StepInfo { // name is a unique identifier for each build step. - optional string name = 1; + optional string name = 1 [(gogoproto.casttype) = "StepName", (gogoproto.customname) = "Name", (gogoproto.nullable) = false]; // startTime is a timestamp representing the server time when this Step started. // it is represented in RFC3339 form and is in UTC. - optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time startTime = 2; + optional .k8s.io.apimachinery.pkg.apis.meta.v1.Time startTime = 2 [(gogoproto.customname) = "StartTime", (gogoproto.nullable) = false]; // durationMilliseconds identifies how long the step took // to complete in milliseconds. - optional int64 durationMilliseconds = 3; + optional int64 durationMilliseconds = 3 [(gogoproto.customname) = "DurationMilliseconds", (gogoproto.nullable) = false]; } // WebHookTrigger is a trigger that gets invoked using a webhook type of post message WebHookTrigger { // secret used to validate requests. // Deprecated: use SecretReference instead. - optional string secret = 1; + optional string secret = 1 [(gogoproto.customname) = "Secret", (gogoproto.nullable) = false]; // allowEnv determines whether the webhook can set environment variables; can only // be set to true for GenericWebHook. - optional bool allowEnv = 2; + optional bool allowEnv = 2 [(gogoproto.customname) = "AllowEnv", (gogoproto.nullable) = false]; // secretReference is a reference to a secret in the same namespace, // containing the value to be validated when the webhook is invoked. // The secret being referenced must contain a key named "WebHookSecretKey", the value // of which will be checked against the value supplied in the webhook invocation. - optional SecretLocalReference secretReference = 3; + optional SecretLocalReference secretReference = 3 [(gogoproto.customname) = "SecretReference"]; } diff --git a/features.md b/features.md index 5740fc034fb..a0a729bdcd9 100644 --- a/features.md +++ b/features.md @@ -95,7 +95,6 @@ | BootImageSkewEnforcement| Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | | BuildCSIVolumes| Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | | DualReplica| Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | -| EVPN| Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | | EtcdBackendQuota| Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | | EventTTL| Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | | ExternalOIDC| Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | Enabled | diff --git a/features/features.go b/features/features.go index 9e1150f2d6a..a418dd1d0a2 100644 --- a/features/features.go +++ b/features/features.go @@ -194,14 +194,6 @@ var ( enable(inDevPreviewNoUpgrade(), inTechPreviewNoUpgrade()). mustRegister() - FeatureGateEVPN = newFeatureGate("EVPN"). - reportProblemsToJiraComponent("Networking/ovn-kubernetes"). - contactPerson("jcaamano"). - productScope(ocpSpecific). - enhancementPR("https://github.com/openshift/enhancements/pull/1862"). - enable(inDefault(), inOKD(), inDevPreviewNoUpgrade(), inTechPreviewNoUpgrade()). - mustRegister() - FeatureGateOVNObservability = newFeatureGate("OVNObservability"). reportProblemsToJiraComponent("Networking"). contactPerson("npinaeva"). diff --git a/payload-manifests/featuregates/featureGate-4-10-Hypershift-Default.yaml b/payload-manifests/featuregates/featureGate-4-10-Hypershift-Default.yaml index fc3a3dc3a30..3da6b6f8770 100644 --- a/payload-manifests/featuregates/featureGate-4-10-Hypershift-Default.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-Hypershift-Default.yaml @@ -298,9 +298,6 @@ { "name": "DualReplica" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" }, diff --git a/payload-manifests/featuregates/featureGate-4-10-Hypershift-DevPreviewNoUpgrade.yaml b/payload-manifests/featuregates/featureGate-4-10-Hypershift-DevPreviewNoUpgrade.yaml index a857545a423..97a6f8bca37 100644 --- a/payload-manifests/featuregates/featureGate-4-10-Hypershift-DevPreviewNoUpgrade.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-Hypershift-DevPreviewNoUpgrade.yaml @@ -198,9 +198,6 @@ { "name": "DyanmicServiceEndpointIBMCloud" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" }, diff --git a/payload-manifests/featuregates/featureGate-4-10-Hypershift-OKD.yaml b/payload-manifests/featuregates/featureGate-4-10-Hypershift-OKD.yaml index 1513fbdf881..f1fc7edce5d 100644 --- a/payload-manifests/featuregates/featureGate-4-10-Hypershift-OKD.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-Hypershift-OKD.yaml @@ -300,9 +300,6 @@ { "name": "DualReplica" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" }, diff --git a/payload-manifests/featuregates/featureGate-4-10-Hypershift-TechPreviewNoUpgrade.yaml b/payload-manifests/featuregates/featureGate-4-10-Hypershift-TechPreviewNoUpgrade.yaml index 0aef14ca1a4..31c297353cd 100644 --- a/payload-manifests/featuregates/featureGate-4-10-Hypershift-TechPreviewNoUpgrade.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-Hypershift-TechPreviewNoUpgrade.yaml @@ -210,9 +210,6 @@ { "name": "DyanmicServiceEndpointIBMCloud" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" }, diff --git a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-Default.yaml b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-Default.yaml index 662bcb95df8..faf2cd44b9f 100644 --- a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-Default.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-Default.yaml @@ -289,9 +289,6 @@ { "name": "DualReplica" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" }, diff --git a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-DevPreviewNoUpgrade.yaml b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-DevPreviewNoUpgrade.yaml index 89c1963d9da..41f4dd77e87 100644 --- a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-DevPreviewNoUpgrade.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-DevPreviewNoUpgrade.yaml @@ -171,9 +171,6 @@ { "name": "DyanmicServiceEndpointIBMCloud" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" }, diff --git a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-OKD.yaml b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-OKD.yaml index 1396a78cd0f..6ee314b8d3b 100644 --- a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-OKD.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-OKD.yaml @@ -291,9 +291,6 @@ { "name": "DualReplica" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" }, diff --git a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-TechPreviewNoUpgrade.yaml b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-TechPreviewNoUpgrade.yaml index 0ae832f15bd..b1bbda679fd 100644 --- a/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-TechPreviewNoUpgrade.yaml +++ b/payload-manifests/featuregates/featureGate-4-10-SelfManagedHA-TechPreviewNoUpgrade.yaml @@ -189,9 +189,6 @@ { "name": "DyanmicServiceEndpointIBMCloud" }, - { - "name": "EVPN" - }, { "name": "EtcdBackendQuota" },