From d5de927cb29ec340f66589ef173bac1b226e065c Mon Sep 17 00:00:00 2001 From: Charlie Doern Date: Thu, 21 Sep 2023 16:06:44 -0400 Subject: [PATCH] Add MachineState types to machineconfiguration Signed-off-by: Charlie Doern --- .../v1/0000_80_controllerconfig.crd.yaml | 5 + .../v1/0000_80_machinestate.crd.yaml | 186 ++++++++++++++++++ machineconfiguration/v1/register.go | 2 + .../v1/stable.machinestate.testsuite.yaml | 15 ++ machineconfiguration/v1/types.go | 170 ++++++++++++++++ .../v1/zz_generated.deepcopy.go | 148 ++++++++++++++ .../v1/zz_generated.swagger_doc_generated.go | 61 ++++++ 7 files changed, 587 insertions(+) create mode 100644 machineconfiguration/v1/0000_80_machinestate.crd.yaml create mode 100644 machineconfiguration/v1/stable.machinestate.testsuite.yaml diff --git a/machineconfiguration/v1/0000_80_controllerconfig.crd.yaml b/machineconfiguration/v1/0000_80_controllerconfig.crd.yaml index 8c1835efccc..44a00b49cae 100644 --- a/machineconfiguration/v1/0000_80_controllerconfig.crd.yaml +++ b/machineconfiguration/v1/0000_80_controllerconfig.crd.yaml @@ -1046,6 +1046,11 @@ spec: type: string nullable: true x-kubernetes-embedded-resource: true + internalRegistryPullSecret: + description: internalRegistryPullSecret is the pull secret for the internal registry + type: string + format: byte + nullable: true ipFamilies: description: ipFamilies indicates the IP families in use by the cluster network type: string diff --git a/machineconfiguration/v1/0000_80_machinestate.crd.yaml b/machineconfiguration/v1/0000_80_machinestate.crd.yaml new file mode 100644 index 00000000000..9e6bb36b7ae --- /dev/null +++ b/machineconfiguration/v1/0000_80_machinestate.crd.yaml @@ -0,0 +1,186 @@ +apiVersion: apiextensions.k8s.io/v1 +kind: CustomResourceDefinition +metadata: + name: machinestates.machineconfiguration.openshift.io + labels: + "openshift.io/operator-managed": "" + annotations: + include.release.openshift.io/ibm-cloud-managed: "true" + include.release.openshift.io/self-managed-high-availability: "true" + include.release.openshift.io/single-node-developer: "true" +spec: + # group name to use for REST API: /apis// + group: machineconfiguration.openshift.io + scope: Cluster + names: + kind: MachineState + singular: machinestate + plural: machinestates + shortnames: + - state + versions: + - name: v1 + # Each version can be enabled/disabled by Served flag. + served: true + # One and only one version must be marked as the storage version. + storage: true + subresources: + status: {} + additionalPrinterColumns: + - jsonPath: .spec.machineStateKind + name: Type + type: string + - jsonPath: .status.healthy + name: Healthy + type: boolean + - jsonPath: .status.allStates[0].state + name: Progress + type: string + - jsonPath: .status.allStates[0].name + name: Object + type: string + - jsonPath: .status.allStates[0].kind + name: ObjectType + type: string + - jsonPath: .status.allStates[0].reason + name: Action + type: string + - jsonPath: .status.error + name: Error + type: string + schema: + openAPIV3Schema: + description: "MachineState describes the health of the Machines on the system \n Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer)." + type: object + required: + - spec + properties: + apiVersion: + description: 'APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources' + type: string + kind: + description: 'Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds' + type: string + metadata: + type: object + spec: + description: MachineStateSpec describes the type of State we are managing + type: object + properties: + configuration: + description: MachineStateConfig describes the configuration of a MachineState + type: object + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: 'If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: "spec.containers{name}" (where "name" refers to the name of the container that triggered the event) or if no container name is specified "spec.containers[2]" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object. TODO: this design is not final and this field is subject to change in the future.' + type: string + kind: + description: 'Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds' + type: string + name: + description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names' + type: string + namespace: + description: 'Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/' + type: string + resourceVersion: + description: 'Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency' + type: string + uid: + description: 'UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids' + type: string + x-kubernetes-map-type: atomic + machineStateKind: + description: Kind describes the type of MachineState + type: string + status: + description: MachineStateStatus holds the reported information on a particular MachineState + type: object + properties: + allStates: + description: Progression describes the 20 Most Recent MachineStates + type: array + items: + description: ProgressionCondition is the base struct that contains all information about an event reported from an MCO component + type: object + properties: + kind: + description: Kind describes the type of object for this condition (node, mcp, etc) + type: string + name: + description: Name is the object's name + type: string + phase: + description: Phase is the general action occuring + type: string + reason: + description: Reason is a more detailed description of the phase + type: string + state: + description: State describes what is happening with this object + type: string + time: + description: Time is the timestamp of this event + type: string + format: date-time + configuration: + description: Config Describes the Kind of MachineState + type: object + properties: + apiVersion: + description: API version of the referent. + type: string + fieldPath: + description: 'If referring to a piece of an object instead of an entire object, this string should contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2]. For example, if the object reference is to a container within a pod, this would take on a value like: "spec.containers{name}" (where "name" refers to the name of the container that triggered the event) or if no container name is specified "spec.containers[2]" (container with index 2 in this pod). This syntax is chosen only to have some well-defined way of referencing a part of an object. TODO: this design is not final and this field is subject to change in the future.' + type: string + kind: + description: 'Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds' + type: string + name: + description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names' + type: string + namespace: + description: 'Namespace of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/' + type: string + resourceVersion: + description: 'Specific resourceVersion to which this reference is made, if any. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency' + type: string + uid: + description: 'UID of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids' + type: string + x-kubernetes-map-type: atomic + error: + description: MostRecentError is populated if the State reports an error. + type: string + healthy: + description: Healthy reports if the state is Healthy Overall + type: boolean + progress: + description: MostRecentState MCO Object Mapped to a Progress Condition + type: object + additionalProperties: + description: ProgressionCondition is the base struct that contains all information about an event reported from an MCO component + type: object + properties: + kind: + description: Kind describes the type of object for this condition (node, mcp, etc) + type: string + name: + description: Name is the object's name + type: string + phase: + description: Phase is the general action occuring + type: string + reason: + description: Reason is a more detailed description of the phase + type: string + state: + description: State describes what is happening with this object + type: string + time: + description: Time is the timestamp of this event + type: string + format: date-time diff --git a/machineconfiguration/v1/register.go b/machineconfiguration/v1/register.go index bbafc28dea3..78ac081b27d 100644 --- a/machineconfiguration/v1/register.go +++ b/machineconfiguration/v1/register.go @@ -34,6 +34,8 @@ func addKnownTypes(scheme *runtime.Scheme) error { &MachineConfigList{}, &MachineConfigPool{}, &MachineConfigPoolList{}, + &MachineState{}, + &MachineStateList{}, ) metav1.AddToGroupVersion(scheme, GroupVersion) diff --git a/machineconfiguration/v1/stable.machinestate.testsuite.yaml b/machineconfiguration/v1/stable.machinestate.testsuite.yaml new file mode 100644 index 00000000000..1ca964f566d --- /dev/null +++ b/machineconfiguration/v1/stable.machinestate.testsuite.yaml @@ -0,0 +1,15 @@ + +apiVersion: apiextensions.k8s.io/v1 # Hack because controller-gen complains if we don't have this +name: "[Stable] MachineState" +crd: 0000_80_machinestate.crd.yaml +tests: + onCreate: + - name: Should be able to create a minimal MachineState + initial: | + apiVersion: machineconfiguration.openshift.io/v1 + kind: MachineState + spec: {} + expected: | + apiVersion: machineconfiguration.openshift.io/v1 + kind: MachineState + spec: {} \ No newline at end of file diff --git a/machineconfiguration/v1/types.go b/machineconfiguration/v1/types.go index 67de2cb811f..034d418487e 100644 --- a/machineconfiguration/v1/types.go +++ b/machineconfiguration/v1/types.go @@ -93,6 +93,10 @@ type ControllerConfigSpec struct { // +optional PullSecret *corev1.ObjectReference `json:"pullSecret,omitempty"` + // internalRegistryPullSecret is the pull secret for the internal registry + // +nullable + InternalRegistryPullSecret []byte `json:"internalRegistryPullSecret"` + // images is map of images that are used by the controller to render templates under ./templates/ // +kubebuilder:validation:Required Images map[string]string `json:"images"` @@ -745,3 +749,169 @@ type ContainerRuntimeConfigList struct { Items []ContainerRuntimeConfig `json:"items"` } + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// MachineState describes the health of the Machines on the system +// +// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). +// +openshift:compatibility-gen:level=1 +type MachineState struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // +kubebuilder:validation:Required + Spec MachineStateSpec `json:"spec"` + // +optional + Status MachineStateStatus `json:"status"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// MachineStateList describes all of the MachinesStates on the system +// +// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer). +// +openshift:compatibility-gen:level=1 +type MachineStateList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata"` + + Items []MachineState `json:"items"` +} + +// MachineStateSpec describes the type of State we are managing +type MachineStateSpec struct { + // Kind describes the type of MachineState + // +optional + Kind MachineStateType `json:"machineStateKind,omitempty"` + Config MachineStateConfig `json:"configuration"` +} + +// MachineStateStatus holds the reported information on a particular MachineState +type MachineStateStatus struct { + // Config Describes the Kind of MachineState + Config MachineStateConfig `json:"configuration"` + // MostRecentState MCO Object Mapped to a Progress Condition + MostRecentState map[string]ProgressionCondition `json:"progress"` + // Progression describes the 20 Most Recent MachineStates + Progression []ProgressionCondition `json:"allStates"` + // MostRecentError is populated if the State reports an error. + MostRecentError string `json:"error"` + // Healthy reports if the state is Healthy Overall + Healthy bool `json:"healthy"` +} + +// MachineStateConfig describes the configuration of a MachineState +type MachineStateConfig struct { + corev1.ObjectReference `json:",inline"` +} + +// An OperatorObject is used as the key in the map describing the most recent states +// for example, if the MachineStateKind == DaemonState, the Object will be a Node and we will report +// each node's most recent state. +type OperatorObject string + +const ( + // MCP describes a MachineConfigPool + MCP OperatorObject = "MachineConfigPool" + // KC describes a KubeletConfig object + KC OperatorObject = "KubeletConfig" + // MC describes a MachineConfig object + MC OperatorObject = "MachineConfig" + // CC describes a ControllerConfig object + CC OperatorObject = "ControllerConfig" + // Node describes a Node object + Node OperatorObject = "Node" +) + +// StateProgress is each possible state for each possible MachineStateType +// UpgradeProgression Kind will only use the "MachinConfigPoolUpdate..." types for example +type StateProgress string + +const ( + // OperatorSyncRenderConfig describes a machine that is creating or syncing its render config + OperatorSyncRenderConfig StateProgress = "OperatorSyncRenderConfig" + // OperatorSyncMCP describes a machine that is syncing or applying its MachineConigPools + OperatorSyncMCP StateProgress = "OperatorSyncMCP" + // OperatorSyncMCD describes a machine that is syncing or applying Daemon related files. + OperatorSyncMCD StateProgress = "OperatorSyncMCD" + // OperatorSyncMCC describes a machine that is sycing or applying Controller related files + OperatorSyncMCC StateProgress = "OperatorSyncMCC" + // OperatorSyncMCS describes a machine that is syncing or applying server related files + OperatorSyncMCS StateProgress = "OperatorSyncMCS" + // OperatorSyncMCPRequired describes a machine in the process of ensuring and applying required MachineConfigPools + OperatorSyncMCPRequired StateProgress = "OperatorSyncMCPRequired" + // OperatorSyncKubeletConfig describes a machine that is syncing its KubeletConfig + OperatorSyncKubeletConfig StateProgress = "OperatorSyncKubeletConfig" + // MachineConfigPoolUpdatePreparing describes a machine that is preparing in the daemon to trigger an update + MachineConfigPoolUpdatePreparing StateProgress = "UpdatePreparing" + // MachineConfigPoolUpdateInProgress describes a machine that is in progress of updating + MachineConfigPoolUpdateInProgress StateProgress = "UpdateInProgress" + // MachineConfigPoolUpdatePostAction describes a machine that is executing its post update action + MachineConfigPoolUpdatePostAction StateProgress = "UpdatePostAction" + // MachineConfigPoolUpdateCompleting describes a machine that is in the process of resuming normal processes + MachineConfigPoolUpdateCompleting StateProgress = "UpdateCompleting" + // MachineConfigPoolUpdateComplete describes a machine that has a matching desired and current config after executing an update + MachineConfigPoolUpdateComplete StateProgress = "Updated" + // MachineConfigPoolUpdateResuming describes a machine that is in the process of resuming normal processes + MachineConfigPoolResuming StateProgress = "Resuming" + // MachineConfigPoolReady describes a machine that has a matching desired and current config + MachineConfigPoolReady StateProgress = "Ready" + // MCCSync describes the process of syncing the MCC regularly + MCCSync StateProgress = "SyncController" + // MCDSync describes the process of syncing the MCD regularly + MCDSync StateProgress = "SyncDaemon" + // MetricSync describes the process of updating metrics and their related options + MetricsSync StateProgress = "SyncMetrics" + // BootstrapProgression describes processes occuring during the bootstrapping process + BootstrapProgression StateProgress = "BootstrapProgression" + // MachineStateErroed describes a machine that has errored during its proccess + MachineStateErrored StateProgress = "Errored" +) + +// MachineStateType describes the Kind of MachineState we are using +type MachineStateType string + +const ( + // UpgradeProgression describes the machine state dealing with machine upgrades + UpgradeProgression MachineStateType = "UpgradeProgression" + // MCCBootstrapProgression describes behaviors occuring in the MCC bootstrap container + MCCBootstrapProgression MachineStateType = "MCCBootstrapProgression" + // MCSBootstrapProgression describes behaviors occuring in the MCS bootstrap container + MCSBootstrapProgression MachineStateType = "MCSBootstrapProgression" + // OperatorProgression describes behaviors in the Operator's sync functions + OperatorProgression MachineStateType = "OperatorProgression" + // ControllerState describes behaviors in the Controller's sync function + ControllerState MachineStateType = "ControllerState" + // DaemonState describes behaviors in the Daemon's sync function + DaemonState MachineStateType = "DaemonState" + // ServerState describes behaviors in the Serve's sync function + ServerState MachineStateType = "ServerState" + // UpdatingMetrics describes changes to metrics on the cluster + UpdatingMetrics MachineStateType = "UpdatingMetrics" +) + +type StateSubController string + +const ( + // StateSubControllerBootstrap describes the bootstrap sub-state controller + StateSubControllerBootstrap StateSubController = "BootstrapStateController" +) + +// ProgressionCondition is the base struct that contains all information about an event reported from an MCO component +type ProgressionCondition struct { + // Kind describes the type of object for this condition (node, mcp, etc) + Kind OperatorObject `json:"kind"` + // State describes what is happening with this object + State StateProgress `json:"state"` + // Name is the object's name + Name string `json:"name"` + // Phase is the general action occuring + Phase string `json:"phase"` + // Reason is a more detailed description of the phase + Reason string `json:"reason"` + // Time is the timestamp of this event + Time metav1.Time `json:"time"` +} diff --git a/machineconfiguration/v1/zz_generated.deepcopy.go b/machineconfiguration/v1/zz_generated.deepcopy.go index 279d2b28606..dbb5fc191b1 100644 --- a/machineconfiguration/v1/zz_generated.deepcopy.go +++ b/machineconfiguration/v1/zz_generated.deepcopy.go @@ -310,6 +310,11 @@ func (in *ControllerConfigSpec) DeepCopyInto(out *ControllerConfigSpec) { *out = new(corev1.ObjectReference) **out = **in } + if in.InternalRegistryPullSecret != nil { + in, out := &in.InternalRegistryPullSecret, &out.InternalRegistryPullSecret + *out = make([]byte, len(*in)) + copy(*out, *in) + } if in.Images != nil { in, out := &in.Images, &out.Images *out = make(map[string]string, len(*in)) @@ -810,6 +815,132 @@ func (in *MachineConfigSpec) DeepCopy() *MachineConfigSpec { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MachineState) DeepCopyInto(out *MachineState) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + out.Spec = in.Spec + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineState. +func (in *MachineState) DeepCopy() *MachineState { + if in == nil { + return nil + } + out := new(MachineState) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *MachineState) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MachineStateConfig) DeepCopyInto(out *MachineStateConfig) { + *out = *in + out.ObjectReference = in.ObjectReference + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineStateConfig. +func (in *MachineStateConfig) DeepCopy() *MachineStateConfig { + if in == nil { + return nil + } + out := new(MachineStateConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MachineStateList) DeepCopyInto(out *MachineStateList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]MachineState, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineStateList. +func (in *MachineStateList) DeepCopy() *MachineStateList { + if in == nil { + return nil + } + out := new(MachineStateList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *MachineStateList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MachineStateSpec) DeepCopyInto(out *MachineStateSpec) { + *out = *in + out.Config = in.Config + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineStateSpec. +func (in *MachineStateSpec) DeepCopy() *MachineStateSpec { + if in == nil { + return nil + } + out := new(MachineStateSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MachineStateStatus) DeepCopyInto(out *MachineStateStatus) { + *out = *in + out.Config = in.Config + if in.MostRecentState != nil { + in, out := &in.MostRecentState, &out.MostRecentState + *out = make(map[string]ProgressionCondition, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + if in.Progression != nil { + in, out := &in.Progression, &out.Progression + *out = make([]ProgressionCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MachineStateStatus. +func (in *MachineStateStatus) DeepCopy() *MachineStateStatus { + if in == nil { + return nil + } + out := new(MachineStateStatus) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NetworkInfo) DeepCopyInto(out *NetworkInfo) { *out = *in @@ -830,3 +961,20 @@ func (in *NetworkInfo) DeepCopy() *NetworkInfo { in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ProgressionCondition) DeepCopyInto(out *ProgressionCondition) { + *out = *in + in.Time.DeepCopyInto(&out.Time) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProgressionCondition. +func (in *ProgressionCondition) DeepCopy() *ProgressionCondition { + if in == nil { + return nil + } + out := new(ProgressionCondition) + in.DeepCopyInto(out) + return out +} diff --git a/machineconfiguration/v1/zz_generated.swagger_doc_generated.go b/machineconfiguration/v1/zz_generated.swagger_doc_generated.go index 75ffd3c4ae2..3e4097eabc2 100644 --- a/machineconfiguration/v1/zz_generated.swagger_doc_generated.go +++ b/machineconfiguration/v1/zz_generated.swagger_doc_generated.go @@ -125,6 +125,7 @@ var map_ControllerConfigSpec = map[string]string{ "imageRegistryBundleUserData": "imageRegistryBundleUserData is Image Registry Data provided by the user", "imageRegistryBundleData": "imageRegistryBundleData is the ImageRegistryData", "pullSecret": "pullSecret is the default pull secret that needs to be installed on all machines.", + "internalRegistryPullSecret": "internalRegistryPullSecret is the pull secret for the internal registry", "images": "images is map of images that are used by the controller to render templates under ./templates/", "baseOSContainerImage": "BaseOSContainerImage is the new-format container image for operating system updates.", "baseOSExtensionsContainerImage": "BaseOSExtensionsContainerImage is the matching extensions container for the new-format container", @@ -325,6 +326,52 @@ func (MachineConfigSpec) SwaggerDoc() map[string]string { return map_MachineConfigSpec } +var map_MachineState = map[string]string{ + "": "MachineState describes the health of the Machines on the system\n\nCompatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).", +} + +func (MachineState) SwaggerDoc() map[string]string { + return map_MachineState +} + +var map_MachineStateConfig = map[string]string{ + "": "MachineStateConfig describes the configuration of a MachineState", +} + +func (MachineStateConfig) SwaggerDoc() map[string]string { + return map_MachineStateConfig +} + +var map_MachineStateList = map[string]string{ + "": "MachineStateList describes all of the MachinesStates on the system\n\nCompatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).", +} + +func (MachineStateList) SwaggerDoc() map[string]string { + return map_MachineStateList +} + +var map_MachineStateSpec = map[string]string{ + "": "MachineStateSpec describes the type of State we are managing", + "machineStateKind": "Kind describes the type of MachineState", +} + +func (MachineStateSpec) SwaggerDoc() map[string]string { + return map_MachineStateSpec +} + +var map_MachineStateStatus = map[string]string{ + "": "MachineStateStatus holds the reported information on a particular MachineState", + "configuration": "Config Describes the Kind of MachineState", + "progress": "MostRecentState MCO Object Mapped to a Progress Condition", + "allStates": "Progression describes the 20 Most Recent MachineStates", + "error": "MostRecentError is populated if the State reports an error.", + "healthy": "Healthy reports if the state is Healthy Overall", +} + +func (MachineStateStatus) SwaggerDoc() map[string]string { + return map_MachineStateStatus +} + var map_NetworkInfo = map[string]string{ "": "Network contains network related configuration", "mtuMigration": "MTUMigration contains the MTU migration configuration.", @@ -334,4 +381,18 @@ func (NetworkInfo) SwaggerDoc() map[string]string { return map_NetworkInfo } +var map_ProgressionCondition = map[string]string{ + "": "ProgressionCondition is the base struct that contains all information about an event reported from an MCO component", + "kind": "Kind describes the type of object for this condition (node, mcp, etc)", + "state": "State describes what is happening with this object", + "name": "Name is the object's name", + "phase": "Phase is the general action occuring", + "reason": "Reason is a more detailed description of the phase", + "time": "Time is the timestamp of this event", +} + +func (ProgressionCondition) SwaggerDoc() map[string]string { + return map_ProgressionCondition +} + // AUTO-GENERATED FUNCTIONS END HERE