mattermost_mattermostcom

package
v1.0.0-beta.10....-72150bb Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 22, 2023 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Overview

mattermost_mattermostcom

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ClusterInstallation_GVK 

func ClusterInstallation_GVK() *cdk8s.GroupVersionKind

func ClusterInstallation_IsApiObject 

func ClusterInstallation_IsApiObject(o interface{}) *bool

Return whether the given object is an `ApiObject`.

We do attribute detection since we can't reliably use 'instanceof'.

func ClusterInstallation_IsConstruct 

func ClusterInstallation_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func ClusterInstallation_Manifest 

func ClusterInstallation_Manifest(props *ClusterInstallationProps) interface{}

Renders a Kubernetes manifest for "ClusterInstallation".

This can be used to inline resource manifests inside other objects (e.g. as templates).

func ClusterInstallation_Of 

func ClusterInstallation_Of(c constructs.IConstruct) cdk8s.ApiObject

Returns the `ApiObject` named `Resource` which is a child of the given construct.

If `c` is an `ApiObject`, it is returned directly. Throws an exception if the construct does not have a child named `Default` _or_ if this child is not an `ApiObject`.

func NewClusterInstallation_Override 

func NewClusterInstallation_Override(c ClusterInstallation, scope constructs.Construct, id *string, props *ClusterInstallationProps)

Defines a "ClusterInstallation" API object.

Types

type ClusterInstallation 

type ClusterInstallation interface {
	cdk8s.ApiObject
	// The group portion of the API version (e.g. `authorization.k8s.io`).
	ApiGroup() *string
	// The object's API version (e.g. `authorization.k8s.io/v1`).
	ApiVersion() *string
	// The chart in which this object is defined.
	Chart() cdk8s.Chart
	// The object kind.
	Kind() *string
	// Metadata associated with this API object.
	Metadata() cdk8s.ApiObjectMetadataDefinition
	// The name of the API object.
	//
	// If a name is specified in `metadata.name` this will be the name returned.
	// Otherwise, a name will be generated by calling
	// `Chart.of(this).generatedObjectName(this)`, which by default uses the
	// construct path to generate a DNS-compatible name for the resource.
	Name() *string
	// The tree node.
	Node() constructs.Node
	// Create a dependency between this ApiObject and other constructs.
	//
	// These can be other ApiObjects, Charts, or custom.
	AddDependency(dependencies ...constructs.IConstruct)
	// Applies a set of RFC-6902 JSON-Patch operations to the manifest synthesized for this API object.
	//
	// Example:
	//     kubePod.addJsonPatch(JsonPatch.replace('/spec/enableServiceLinks', true));
	//
	AddJsonPatch(ops ...cdk8s.JsonPatch)
	// Renders the object to Kubernetes JSON.
	ToJson() interface{}
	// Returns a string representation of this construct.
	ToString() *string
}

ClusterInstallation is the Schema for the clusterinstallations API.

func NewClusterInstallation 

func NewClusterInstallation(scope constructs.Construct, id *string, props *ClusterInstallationProps) ClusterInstallation

Defines a "ClusterInstallation" API object.

type ClusterInstallationProps 

type ClusterInstallationProps struct {
	// Specification of the desired behavior of the Mattermost cluster.
	//
	// More info: https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status
	Spec     *ClusterInstallationSpec `field:"required" json:"spec" yaml:"spec"`
	Metadata *cdk8s.ApiObjectMetadata `field:"optional" json:"metadata" yaml:"metadata"`
}

ClusterInstallation is the Schema for the clusterinstallations API.

type ClusterInstallationSpec 

type ClusterInstallationSpec struct {
	// IngressName defines the name to be used when creating the ingress rules.
	IngressName *string `field:"required" json:"ingressName" yaml:"ingressName"`
	// If specified, affinity will define the pod's scheduling constraints.
	Affinity *ClusterInstallationSpecAffinity `field:"optional" json:"affinity" yaml:"affinity"`
	// BlueGreen defines the configuration of BlueGreen deployment for a ClusterInstallation.
	BlueGreen *ClusterInstallationSpecBlueGreen `field:"optional" json:"blueGreen" yaml:"blueGreen"`
	// Canary defines the configuration of Canary deployment for a ClusterInstallation.
	Canary *ClusterInstallationSpecCanary `field:"optional" json:"canary" yaml:"canary"`
	// Database defines the database configuration for a ClusterInstallation.
	Database *ClusterInstallationSpecDatabase `field:"optional" json:"database" yaml:"database"`
	// ElasticSearch defines the ElasticSearch configuration for a ClusterInstallation.
	ElasticSearch *ClusterInstallationSpecElasticSearch `field:"optional" json:"elasticSearch" yaml:"elasticSearch"`
	// Image defines the ClusterInstallation Docker image.
	Image              *string             `field:"optional" json:"image" yaml:"image"`
	IngressAnnotations *map[string]*string `field:"optional" json:"ingressAnnotations" yaml:"ingressAnnotations"`
	// Defines the probe to check if the application is up and running.
	LivenessProbe *ClusterInstallationSpecLivenessProbe `field:"optional" json:"livenessProbe" yaml:"livenessProbe"`
	// Optional environment variables to set in the Mattermost application pods.
	MattermostEnv *[]*ClusterInstallationSpecMattermostEnv `field:"optional" json:"mattermostEnv" yaml:"mattermostEnv"`
	// Secret that contains the mattermost license.
	MattermostLicenseSecret *string `field:"optional" json:"mattermostLicenseSecret" yaml:"mattermostLicenseSecret"`
	// Minio defines the configuration of Minio for a ClusterInstallation.
	Minio *ClusterInstallationSpecMinio `field:"optional" json:"minio" yaml:"minio"`
	// NodeSelector is a selector which must be true for the pod to fit on a node.
	//
	// Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
	NodeSelector *map[string]*string `field:"optional" json:"nodeSelector" yaml:"nodeSelector"`
	// Defines the probe to check if the application is ready to accept traffic.
	ReadinessProbe *ClusterInstallationSpecReadinessProbe `field:"optional" json:"readinessProbe" yaml:"readinessProbe"`
	// Replicas defines the number of replicas to use for the Mattermost app servers.
	//
	// Setting this will override the number of replicas set by 'Size'.
	Replicas *float64 `field:"optional" json:"replicas" yaml:"replicas"`
	// Defines the resource requests and limits for the Mattermost app server pods.
	Resources          *ClusterInstallationSpecResources `field:"optional" json:"resources" yaml:"resources"`
	ServiceAnnotations *map[string]*string               `field:"optional" json:"serviceAnnotations" yaml:"serviceAnnotations"`
	// Size defines the size of the ClusterInstallation.
	//
	// This is typically specified in number of users. This will set replica and resource requests/limits appropriately for the provided number of users. Accepted values are: 100users, 1000users, 5000users, 10000users, 250000users. Defaults to 5000users. Setting 'Replicas', 'Resources', 'Minio.Replicas', 'Minio.Resource', 'Database.Replicas', or 'Database.Resources' will override the values set by Size.
	Size                   *string `field:"optional" json:"size" yaml:"size"`
	UseServiceLoadBalancer *bool   `field:"optional" json:"useServiceLoadBalancer" yaml:"useServiceLoadBalancer"`
	// Version defines the ClusterInstallation Docker image version.
	Version *string `field:"optional" json:"version" yaml:"version"`
}

Specification of the desired behavior of the Mattermost cluster.

More info: https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#spec-and-status

type ClusterInstallationSpecAffinity 

type ClusterInstallationSpecAffinity struct {
	// Describes node affinity scheduling rules for the pod.
	NodeAffinity *ClusterInstallationSpecAffinityNodeAffinity `field:"optional" json:"nodeAffinity" yaml:"nodeAffinity"`
	// Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
	PodAffinity *ClusterInstallationSpecAffinityPodAffinity `field:"optional" json:"podAffinity" yaml:"podAffinity"`
	// Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
	PodAntiAffinity *ClusterInstallationSpecAffinityPodAntiAffinity `field:"optional" json:"podAntiAffinity" yaml:"podAntiAffinity"`
}

If specified, affinity will define the pod's scheduling constraints.

type ClusterInstallationSpecAffinityNodeAffinity 

type ClusterInstallationSpecAffinityNodeAffinity struct {
	// The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions.
	//
	// The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node matches the corresponding matchExpressions; the node(s) with the highest sum are the most preferred.
	PreferredDuringSchedulingIgnoredDuringExecution *[]*ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution `` /* 126-byte string literal not displayed */
	// If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node.
	//
	// If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.
	RequiredDuringSchedulingIgnoredDuringExecution *ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution `field:"optional" json:"requiredDuringSchedulingIgnoredDuringExecution" yaml:"requiredDuringSchedulingIgnoredDuringExecution"`
}

Describes node affinity scheduling rules for the pod.

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution 

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution struct {
	// A node selector term, associated with the corresponding weight.
	Preference *ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference `field:"required" json:"preference" yaml:"preference"`
	// Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
	Weight *float64 `field:"required" json:"weight" yaml:"weight"`
}

An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference 

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference struct {
	// A list of node selector requirements by node's labels.
	MatchExpressions *[]*ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions `field:"optional" json:"matchExpressions" yaml:"matchExpressions"`
	// A list of node selector requirements by node's fields.
	MatchFields *[]*ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields `field:"optional" json:"matchFields" yaml:"matchFields"`
}

A node selector term, associated with the corresponding weight.

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions 

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions struct {
	// The label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// Represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// An array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields 

type ClusterInstallationSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields struct {
	// The label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// Represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// An array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution 

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution struct {
	// Required.
	//
	// A list of node selector terms. The terms are ORed.
	NodeSelectorTerms *[]*ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms `field:"required" json:"nodeSelectorTerms" yaml:"nodeSelectorTerms"`
}

If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node.

If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to an update), the system may or may not try to eventually evict the pod from its node.

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms 

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms struct {
	// A list of node selector requirements by node's labels.
	MatchExpressions *[]*ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions `field:"optional" json:"matchExpressions" yaml:"matchExpressions"`
	// A list of node selector requirements by node's fields.
	MatchFields *[]*ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields `field:"optional" json:"matchFields" yaml:"matchFields"`
}

A null or empty node selector term matches no objects.

The requirements of them are ANDed. The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions 

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions struct {
	// The label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// Represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// An array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields 

type ClusterInstallationSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields struct {
	// The label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// Represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// An array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the operator is Gt or Lt, the values array must have a single element, which will be interpreted as an integer. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A node selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecAffinityPodAffinity 

type ClusterInstallationSpecAffinityPodAffinity struct {
	// The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions.
	//
	// The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
	PreferredDuringSchedulingIgnoredDuringExecution *[]*ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution `` /* 126-byte string literal not displayed */
	// If the affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node.
	//
	// If the affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingIgnoredDuringExecution *[]*ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution `field:"optional" json:"requiredDuringSchedulingIgnoredDuringExecution" yaml:"requiredDuringSchedulingIgnoredDuringExecution"`
}

Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution 

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution struct {
	// Required.
	//
	// A pod affinity term, associated with the corresponding weight.
	PodAffinityTerm *ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm `field:"required" json:"podAffinityTerm" yaml:"podAffinityTerm"`
	// weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
	Weight *float64 `field:"required" json:"weight" yaml:"weight"`
}

The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s).

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm 

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm struct {
	// This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running.
	//
	// Empty topologyKey is not allowed.
	TopologyKey *string `field:"required" json:"topologyKey" yaml:"topologyKey"`
	// A label query over a set of resources, in this case pods.
	LabelSelector *ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector `field:"optional" json:"labelSelector" yaml:"labelSelector"`
	// namespaces specifies which namespaces the labelSelector applies to (matches against);
	//
	// null or empty list means "this pod's namespace".
	Namespaces *[]*string `field:"optional" json:"namespaces" yaml:"namespaces"`
}

Required.

A pod affinity term, associated with the corresponding weight.

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector 

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector struct {
	// matchExpressions is a list of label selector requirements.
	//
	// The requirements are ANDed.
	MatchExpressions *[]*ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions `field:"optional" json:"matchExpressions" yaml:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs.
	//
	// A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels *map[string]*string `field:"optional" json:"matchLabels" yaml:"matchLabels"`
}

A label query over a set of resources, in this case pods.

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions 

type ClusterInstallationSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions struct {
	// key is the label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// operator represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// values is an array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution 

type ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution struct {
	// This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running.
	//
	// Empty topologyKey is not allowed.
	TopologyKey *string `field:"required" json:"topologyKey" yaml:"topologyKey"`
	// A label query over a set of resources, in this case pods.
	LabelSelector *ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector `field:"optional" json:"labelSelector" yaml:"labelSelector"`
	// namespaces specifies which namespaces the labelSelector applies to (matches against);
	//
	// null or empty list means "this pod's namespace".
	Namespaces *[]*string `field:"optional" json:"namespaces" yaml:"namespaces"`
}

Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running.

type ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector 

type ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector struct {
	// matchExpressions is a list of label selector requirements.
	//
	// The requirements are ANDed.
	MatchExpressions *[]*ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions `field:"optional" json:"matchExpressions" yaml:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs.
	//
	// A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels *map[string]*string `field:"optional" json:"matchLabels" yaml:"matchLabels"`
}

A label query over a set of resources, in this case pods.

type ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions 

type ClusterInstallationSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions struct {
	// key is the label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// operator represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// values is an array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecAffinityPodAntiAffinity 

type ClusterInstallationSpecAffinityPodAntiAffinity struct {
	// The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity expressions specified by this field, but it may choose a node that violates one or more of the expressions.
	//
	// The node that is most preferred is the one with the greatest sum of weights, i.e. for each node that meets all of the scheduling requirements (resource request, requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through the elements of this field and adding "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
	PreferredDuringSchedulingIgnoredDuringExecution *[]*ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution `` /* 126-byte string literal not displayed */
	// If the anti-affinity requirements specified by this field are not met at scheduling time, the pod will not be scheduled onto the node.
	//
	// If the anti-affinity requirements specified by this field cease to be met at some point during pod execution (e.g. due to a pod label update), the system may or may not try to eventually evict the pod from its node. When there are multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all terms must be satisfied.
	RequiredDuringSchedulingIgnoredDuringExecution *[]*ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution `field:"optional" json:"requiredDuringSchedulingIgnoredDuringExecution" yaml:"requiredDuringSchedulingIgnoredDuringExecution"`
}

Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution 

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution struct {
	// Required.
	//
	// A pod affinity term, associated with the corresponding weight.
	PodAffinityTerm *ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm `field:"required" json:"podAffinityTerm" yaml:"podAffinityTerm"`
	// weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
	Weight *float64 `field:"required" json:"weight" yaml:"weight"`
}

The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s).

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm 

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm struct {
	// This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running.
	//
	// Empty topologyKey is not allowed.
	TopologyKey *string `field:"required" json:"topologyKey" yaml:"topologyKey"`
	// A label query over a set of resources, in this case pods.
	LabelSelector *ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector `field:"optional" json:"labelSelector" yaml:"labelSelector"`
	// namespaces specifies which namespaces the labelSelector applies to (matches against);
	//
	// null or empty list means "this pod's namespace".
	Namespaces *[]*string `field:"optional" json:"namespaces" yaml:"namespaces"`
}

Required.

A pod affinity term, associated with the corresponding weight.

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector 

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector struct {
	// matchExpressions is a list of label selector requirements.
	//
	// The requirements are ANDed.
	MatchExpressions *[]*ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions `field:"optional" json:"matchExpressions" yaml:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs.
	//
	// A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels *map[string]*string `field:"optional" json:"matchLabels" yaml:"matchLabels"`
}

A label query over a set of resources, in this case pods.

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions 

type ClusterInstallationSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions struct {
	// key is the label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// operator represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// values is an array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution 

type ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution struct {
	// This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running.
	//
	// Empty topologyKey is not allowed.
	TopologyKey *string `field:"required" json:"topologyKey" yaml:"topologyKey"`
	// A label query over a set of resources, in this case pods.
	LabelSelector *ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector `field:"optional" json:"labelSelector" yaml:"labelSelector"`
	// namespaces specifies which namespaces the labelSelector applies to (matches against);
	//
	// null or empty list means "this pod's namespace".
	Namespaces *[]*string `field:"optional" json:"namespaces" yaml:"namespaces"`
}

Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running.

type ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector 

type ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector struct {
	// matchExpressions is a list of label selector requirements.
	//
	// The requirements are ANDed.
	MatchExpressions *[]*ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions `field:"optional" json:"matchExpressions" yaml:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs.
	//
	// A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels *map[string]*string `field:"optional" json:"matchLabels" yaml:"matchLabels"`
}

A label query over a set of resources, in this case pods.

type ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions 

type ClusterInstallationSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions struct {
	// key is the label key that the selector applies to.
	Key *string `field:"required" json:"key" yaml:"key"`
	// operator represents a key's relationship to a set of values.
	//
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator *string `field:"required" json:"operator" yaml:"operator"`
	// values is an array of string values.
	//
	// If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.
	Values *[]*string `field:"optional" json:"values" yaml:"values"`
}

A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

type ClusterInstallationSpecBlueGreen 

type ClusterInstallationSpecBlueGreen struct {
	// Blue defines the blue deployment.
	Blue *ClusterInstallationSpecBlueGreenBlue `field:"optional" json:"blue" yaml:"blue"`
	// Enable defines if BlueGreen deployment will be applied.
	Enable *bool `field:"optional" json:"enable" yaml:"enable"`
	// Green defines the green deployment.
	Green *ClusterInstallationSpecBlueGreenGreen `field:"optional" json:"green" yaml:"green"`
	// ProductionDeployment defines if the current production is blue or green.
	ProductionDeployment *string `field:"optional" json:"productionDeployment" yaml:"productionDeployment"`
}

BlueGreen defines the configuration of BlueGreen deployment for a ClusterInstallation.

type ClusterInstallationSpecBlueGreenBlue 

type ClusterInstallationSpecBlueGreenBlue struct {
	// Image defines the base Docker image that will be used for the deployment.
	//
	// Required when BlueGreen or Canary is enabled.
	Image *string `field:"optional" json:"image" yaml:"image"`
	// IngressName defines the ingress name that will be used by the deployment.
	//
	// This option is not used for Canary builds.
	IngressName *string `field:"optional" json:"ingressName" yaml:"ingressName"`
	// Name defines the name of the deployment.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Version defines the Docker image version that will be used for the deployment.
	//
	// Required when BlueGreen or Canary is enabled.
	Version *string `field:"optional" json:"version" yaml:"version"`
}

Blue defines the blue deployment.

type ClusterInstallationSpecBlueGreenGreen 

type ClusterInstallationSpecBlueGreenGreen struct {
	// Image defines the base Docker image that will be used for the deployment.
	//
	// Required when BlueGreen or Canary is enabled.
	Image *string `field:"optional" json:"image" yaml:"image"`
	// IngressName defines the ingress name that will be used by the deployment.
	//
	// This option is not used for Canary builds.
	IngressName *string `field:"optional" json:"ingressName" yaml:"ingressName"`
	// Name defines the name of the deployment.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Version defines the Docker image version that will be used for the deployment.
	//
	// Required when BlueGreen or Canary is enabled.
	Version *string `field:"optional" json:"version" yaml:"version"`
}

Green defines the green deployment.

type ClusterInstallationSpecCanary 

type ClusterInstallationSpecCanary struct {
	// Deployment defines the canary deployment.
	Deployment *ClusterInstallationSpecCanaryDeployment `field:"optional" json:"deployment" yaml:"deployment"`
	// Enable defines if a canary build will be deployed.
	Enable *bool `field:"optional" json:"enable" yaml:"enable"`
}

Canary defines the configuration of Canary deployment for a ClusterInstallation.

type ClusterInstallationSpecCanaryDeployment 

type ClusterInstallationSpecCanaryDeployment struct {
	// Image defines the base Docker image that will be used for the deployment.
	//
	// Required when BlueGreen or Canary is enabled.
	Image *string `field:"optional" json:"image" yaml:"image"`
	// IngressName defines the ingress name that will be used by the deployment.
	//
	// This option is not used for Canary builds.
	IngressName *string `field:"optional" json:"ingressName" yaml:"ingressName"`
	// Name defines the name of the deployment.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Version defines the Docker image version that will be used for the deployment.
	//
	// Required when BlueGreen or Canary is enabled.
	Version *string `field:"optional" json:"version" yaml:"version"`
}

Deployment defines the canary deployment.

type ClusterInstallationSpecDatabase 

type ClusterInstallationSpecDatabase struct {
	// Defines the backup retention policy.
	BackupRemoteDeletePolicy *string `field:"optional" json:"backupRemoteDeletePolicy" yaml:"backupRemoteDeletePolicy"`
	// Defines the secret to be used when performing a database restore.
	BackupRestoreSecretName *string `field:"optional" json:"backupRestoreSecretName" yaml:"backupRestoreSecretName"`
	// Defines the interval for backups in cron expression format.
	BackupSchedule *string `field:"optional" json:"backupSchedule" yaml:"backupSchedule"`
	// Defines the secret to be used for uploading/restoring backup.
	BackupSecretName *string `field:"optional" json:"backupSecretName" yaml:"backupSecretName"`
	// Defines the object storage url for uploading backups.
	BackupUrl *string `field:"optional" json:"backupUrl" yaml:"backupUrl"`
	// Defines the AWS S3 bucket where the Database Backup is stored.
	//
	// The operator will download the file to restore the data.
	InitBucketUrl *string `field:"optional" json:"initBucketUrl" yaml:"initBucketUrl"`
	// Defines the number of database replicas.
	//
	// For redundancy use at least 2 replicas. Setting this will override the number of replicas set by 'Size'.
	Replicas *float64 `field:"optional" json:"replicas" yaml:"replicas"`
	// Defines the resource requests and limits for the database pods.
	Resources *ClusterInstallationSpecDatabaseResources `field:"optional" json:"resources" yaml:"resources"`
	// Optionally enter the name of an already-existing Secret for connecting to the database.
	//
	// This secret should be configured as follows:
	// User-Managed Database   - Key: DB_CONNECTION_STRING | Value: <FULL_DATABASE_CONNECTION_STRING> Operator-Managed Database   - Key: ROOT_PASSWORD | Value: <ROOT_DATABASE_PASSWORD>   - Key: USER | Value: <USER_NAME>   - Key: PASSWORD | Value: <USER_PASSWORD>   - Key: DATABASE Value: <DATABASE_NAME>
	// Notes:   If you define all secret values for both User-Managed and   Operator-Managed database types, the User-Managed connection string will   take precedence and the Operator-Managed values will be ignored. If the   secret is left blank, the default behavior is to use an Operator-Managed   database with strong randomly-generated database credentials.
	Secret *string `field:"optional" json:"secret" yaml:"secret"`
	// Defines the storage size for the database.
	//
	// ie 50Gi.
	StorageSize *string `field:"optional" json:"storageSize" yaml:"storageSize"`
	Type        *string `field:"optional" json:"type" yaml:"type"`
}

Database defines the database configuration for a ClusterInstallation.

type ClusterInstallationSpecDatabaseResources 

type ClusterInstallationSpecDatabaseResources struct {
	// Limits describes the maximum amount of compute resources allowed.
	//
	// More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/
	Limits *map[string]*string `field:"optional" json:"limits" yaml:"limits"`
	// Requests describes the minimum amount of compute resources required.
	//
	// If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/
	Requests *map[string]*string `field:"optional" json:"requests" yaml:"requests"`
}

Defines the resource requests and limits for the database pods.

type ClusterInstallationSpecElasticSearch 

type ClusterInstallationSpecElasticSearch struct {
	Host     *string `field:"optional" json:"host" yaml:"host"`
	Password *string `field:"optional" json:"password" yaml:"password"`
	Username *string `field:"optional" json:"username" yaml:"username"`
}

ElasticSearch defines the ElasticSearch configuration for a ClusterInstallation.

type ClusterInstallationSpecLivenessProbe 

type ClusterInstallationSpecLivenessProbe struct {
	// One and only one of the following should be specified.
	//
	// Exec specifies the action to take.
	Exec *ClusterInstallationSpecLivenessProbeExec `field:"optional" json:"exec" yaml:"exec"`
	// Minimum consecutive failures for the probe to be considered failed after having succeeded.
	//
	// Defaults to 3. Minimum value is 1.
	FailureThreshold *float64 `field:"optional" json:"failureThreshold" yaml:"failureThreshold"`
	// HTTPGet specifies the http request to perform.
	HttpGet *ClusterInstallationSpecLivenessProbeHttpGet `field:"optional" json:"httpGet" yaml:"httpGet"`
	// Number of seconds after the container has started before liveness probes are initiated.
	//
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	InitialDelaySeconds *float64 `field:"optional" json:"initialDelaySeconds" yaml:"initialDelaySeconds"`
	// How often (in seconds) to perform the probe.
	//
	// Default to 10 seconds. Minimum value is 1.
	PeriodSeconds *float64 `field:"optional" json:"periodSeconds" yaml:"periodSeconds"`
	// Minimum consecutive successes for the probe to be considered successful after having failed.
	//
	// Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.
	SuccessThreshold *float64 `field:"optional" json:"successThreshold" yaml:"successThreshold"`
	// TCPSocket specifies an action involving a TCP port.
	//
	// TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook.
	TcpSocket *ClusterInstallationSpecLivenessProbeTcpSocket `field:"optional" json:"tcpSocket" yaml:"tcpSocket"`
	// Number of seconds after which the probe times out.
	//
	// Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	TimeoutSeconds *float64 `field:"optional" json:"timeoutSeconds" yaml:"timeoutSeconds"`
}

Defines the probe to check if the application is up and running.

type ClusterInstallationSpecLivenessProbeExec 

type ClusterInstallationSpecLivenessProbeExec struct {
	// Command is the command line to execute inside the container, the working directory for the command  is root ('/') in the container's filesystem.
	//
	// The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.
	Command *[]*string `field:"optional" json:"command" yaml:"command"`
}

One and only one of the following should be specified.

Exec specifies the action to take.

type ClusterInstallationSpecLivenessProbeHttpGet 

type ClusterInstallationSpecLivenessProbeHttpGet struct {
	// Name or number of the port to access on the container.
	//
	// Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
	Port ClusterInstallationSpecLivenessProbeHttpGetPort `field:"required" json:"port" yaml:"port"`
	// Host name to connect to, defaults to the pod IP.
	//
	// You probably want to set "Host" in httpHeaders instead.
	Host *string `field:"optional" json:"host" yaml:"host"`
	// Custom headers to set in the request.
	//
	// HTTP allows repeated headers.
	HttpHeaders *[]*ClusterInstallationSpecLivenessProbeHttpGetHttpHeaders `field:"optional" json:"httpHeaders" yaml:"httpHeaders"`
	// Path to access on the HTTP server.
	Path *string `field:"optional" json:"path" yaml:"path"`
	// Scheme to use for connecting to the host.
	//
	// Defaults to HTTP.
	Scheme *string `field:"optional" json:"scheme" yaml:"scheme"`
}

HTTPGet specifies the http request to perform.

type ClusterInstallationSpecLivenessProbeHttpGetHttpHeaders 

type ClusterInstallationSpecLivenessProbeHttpGetHttpHeaders struct {
	// The header field name.
	Name *string `field:"required" json:"name" yaml:"name"`
	// The header field value.
	Value *string `field:"required" json:"value" yaml:"value"`
}

HTTPHeader describes a custom header to be used in HTTP probes.

type ClusterInstallationSpecLivenessProbeHttpGetPort 

type ClusterInstallationSpecLivenessProbeHttpGetPort interface {
	Value() interface{}
}

Name or number of the port to access on the container.

Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.

func ClusterInstallationSpecLivenessProbeHttpGetPort_FromNumber 

func ClusterInstallationSpecLivenessProbeHttpGetPort_FromNumber(value *float64) ClusterInstallationSpecLivenessProbeHttpGetPort

func ClusterInstallationSpecLivenessProbeHttpGetPort_FromString 

func ClusterInstallationSpecLivenessProbeHttpGetPort_FromString(value *string) ClusterInstallationSpecLivenessProbeHttpGetPort

type ClusterInstallationSpecLivenessProbeTcpSocket 

type ClusterInstallationSpecLivenessProbeTcpSocket struct {
	// Number or name of the port to access on the container.
	//
	// Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
	Port ClusterInstallationSpecLivenessProbeTcpSocketPort `field:"required" json:"port" yaml:"port"`
	// Optional: Host name to connect to, defaults to the pod IP.
	Host *string `field:"optional" json:"host" yaml:"host"`
}

TCPSocket specifies an action involving a TCP port.

TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook.

type ClusterInstallationSpecLivenessProbeTcpSocketPort 

type ClusterInstallationSpecLivenessProbeTcpSocketPort interface {
	Value() interface{}
}

Number or name of the port to access on the container.

Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.

func ClusterInstallationSpecLivenessProbeTcpSocketPort_FromNumber 

func ClusterInstallationSpecLivenessProbeTcpSocketPort_FromNumber(value *float64) ClusterInstallationSpecLivenessProbeTcpSocketPort

func ClusterInstallationSpecLivenessProbeTcpSocketPort_FromString 

func ClusterInstallationSpecLivenessProbeTcpSocketPort_FromString(value *string) ClusterInstallationSpecLivenessProbeTcpSocketPort

type ClusterInstallationSpecMattermostEnv 

type ClusterInstallationSpecMattermostEnv struct {
	// Name of the environment variable.
	//
	// Must be a C_IDENTIFIER.
	Name *string `field:"required" json:"name" yaml:"name"`
	// Variable references $(VAR_NAME) are expanded using the previous defined environment variables in the container and any service environment variables.
	//
	// If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Defaults to "".
	Value *string `field:"optional" json:"value" yaml:"value"`
	// Source for the environment variable's value.
	//
	// Cannot be used if value is not empty.
	ValueFrom *ClusterInstallationSpecMattermostEnvValueFrom `field:"optional" json:"valueFrom" yaml:"valueFrom"`
}

EnvVar represents an environment variable present in a Container.

type ClusterInstallationSpecMattermostEnvValueFrom 

type ClusterInstallationSpecMattermostEnvValueFrom struct {
	// Selects a key of a ConfigMap.
	ConfigMapKeyRef *ClusterInstallationSpecMattermostEnvValueFromConfigMapKeyRef `field:"optional" json:"configMapKeyRef" yaml:"configMapKeyRef"`
	// Selects a field of the pod: supports metadata.name, metadata.namespace, metadata.labels, metadata.annotations, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
	FieldRef *ClusterInstallationSpecMattermostEnvValueFromFieldRef `field:"optional" json:"fieldRef" yaml:"fieldRef"`
	// Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
	ResourceFieldRef *ClusterInstallationSpecMattermostEnvValueFromResourceFieldRef `field:"optional" json:"resourceFieldRef" yaml:"resourceFieldRef"`
	// Selects a key of a secret in the pod's namespace.
	SecretKeyRef *ClusterInstallationSpecMattermostEnvValueFromSecretKeyRef `field:"optional" json:"secretKeyRef" yaml:"secretKeyRef"`
}

Source for the environment variable's value.

Cannot be used if value is not empty.

type ClusterInstallationSpecMattermostEnvValueFromConfigMapKeyRef 

type ClusterInstallationSpecMattermostEnvValueFromConfigMapKeyRef struct {
	// The key to select.
	Key *string `field:"required" json:"key" yaml:"key"`
	// Name of the referent.
	//
	// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid?
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Specify whether the ConfigMap or its key must be defined.
	Optional *bool `field:"optional" json:"optional" yaml:"optional"`
}

Selects a key of a ConfigMap.

type ClusterInstallationSpecMattermostEnvValueFromFieldRef 

type ClusterInstallationSpecMattermostEnvValueFromFieldRef struct {
	// Path of the field to select in the specified API version.
	FieldPath *string `field:"required" json:"fieldPath" yaml:"fieldPath"`
	// Version of the schema the FieldPath is written in terms of, defaults to "v1".
	ApiVersion *string `field:"optional" json:"apiVersion" yaml:"apiVersion"`
}

Selects a field of the pod: supports metadata.name, metadata.namespace, metadata.labels, metadata.annotations, spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.

type ClusterInstallationSpecMattermostEnvValueFromResourceFieldRef 

type ClusterInstallationSpecMattermostEnvValueFromResourceFieldRef struct {
	// Required: resource to select.
	Resource *string `field:"required" json:"resource" yaml:"resource"`
	// Container name: required for volumes, optional for env vars.
	ContainerName *string `field:"optional" json:"containerName" yaml:"containerName"`
	// Specifies the output format of the exposed resources, defaults to "1".
	Divisor *string `field:"optional" json:"divisor" yaml:"divisor"`
}

Selects a resource of the container: only resources limits and requests (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.

type ClusterInstallationSpecMattermostEnvValueFromSecretKeyRef 

type ClusterInstallationSpecMattermostEnvValueFromSecretKeyRef struct {
	// The key of the secret to select from.
	//
	// Must be a valid secret key.
	Key *string `field:"required" json:"key" yaml:"key"`
	// Name of the referent.
	//
	// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names TODO: Add other useful fields. apiVersion, kind, uid?
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Specify whether the Secret or its key must be defined.
	Optional *bool `field:"optional" json:"optional" yaml:"optional"`
}

Selects a key of a secret in the pod's namespace.

type ClusterInstallationSpecMinio 

type ClusterInstallationSpecMinio struct {
	// Set to the bucket name of your external MinIO or S3.
	ExternalBucket *string `field:"optional" json:"externalBucket" yaml:"externalBucket"`
	// Set to use an external MinIO deployment or S3.
	//
	// Must also set 'Secret' and 'ExternalBucket'.
	ExternalUrl *string `field:"optional" json:"externalUrl" yaml:"externalUrl"`
	// Defines the number of Minio replicas.
	//
	// Supply 1 to run Minio in standalone mode with no redundancy. Supply 4 or more to run Minio in distributed mode. Note that it is not possible to upgrade Minio from standalone to distributed mode. Setting this will override the number of replicas set by 'Size'. More info: https://docs.min.io/docs/distributed-minio-quickstart-guide.html
	Replicas *float64 `field:"optional" json:"replicas" yaml:"replicas"`
	// Defines the resource requests and limits for the Minio pods.
	Resources *ClusterInstallationSpecMinioResources `field:"optional" json:"resources" yaml:"resources"`
	// Optionally enter the name of already existing secret.
	//
	// Secret should have two values: "accesskey" and "secretkey". Required when "ExternalURL" is set.
	Secret *string `field:"optional" json:"secret" yaml:"secret"`
	// Defines the storage size for Minio.
	//
	// ie 50Gi.
	StorageSize *string `field:"optional" json:"storageSize" yaml:"storageSize"`
}

Minio defines the configuration of Minio for a ClusterInstallation.

type ClusterInstallationSpecMinioResources 

type ClusterInstallationSpecMinioResources struct {
	// Limits describes the maximum amount of compute resources allowed.
	//
	// More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/
	Limits *map[string]*string `field:"optional" json:"limits" yaml:"limits"`
	// Requests describes the minimum amount of compute resources required.
	//
	// If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/
	Requests *map[string]*string `field:"optional" json:"requests" yaml:"requests"`
}

Defines the resource requests and limits for the Minio pods.

type ClusterInstallationSpecReadinessProbe 

type ClusterInstallationSpecReadinessProbe struct {
	// One and only one of the following should be specified.
	//
	// Exec specifies the action to take.
	Exec *ClusterInstallationSpecReadinessProbeExec `field:"optional" json:"exec" yaml:"exec"`
	// Minimum consecutive failures for the probe to be considered failed after having succeeded.
	//
	// Defaults to 3. Minimum value is 1.
	FailureThreshold *float64 `field:"optional" json:"failureThreshold" yaml:"failureThreshold"`
	// HTTPGet specifies the http request to perform.
	HttpGet *ClusterInstallationSpecReadinessProbeHttpGet `field:"optional" json:"httpGet" yaml:"httpGet"`
	// Number of seconds after the container has started before liveness probes are initiated.
	//
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	InitialDelaySeconds *float64 `field:"optional" json:"initialDelaySeconds" yaml:"initialDelaySeconds"`
	// How often (in seconds) to perform the probe.
	//
	// Default to 10 seconds. Minimum value is 1.
	PeriodSeconds *float64 `field:"optional" json:"periodSeconds" yaml:"periodSeconds"`
	// Minimum consecutive successes for the probe to be considered successful after having failed.
	//
	// Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.
	SuccessThreshold *float64 `field:"optional" json:"successThreshold" yaml:"successThreshold"`
	// TCPSocket specifies an action involving a TCP port.
	//
	// TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook.
	TcpSocket *ClusterInstallationSpecReadinessProbeTcpSocket `field:"optional" json:"tcpSocket" yaml:"tcpSocket"`
	// Number of seconds after which the probe times out.
	//
	// Defaults to 1 second. Minimum value is 1. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	TimeoutSeconds *float64 `field:"optional" json:"timeoutSeconds" yaml:"timeoutSeconds"`
}

Defines the probe to check if the application is ready to accept traffic.

type ClusterInstallationSpecReadinessProbeExec 

type ClusterInstallationSpecReadinessProbeExec struct {
	// Command is the command line to execute inside the container, the working directory for the command  is root ('/') in the container's filesystem.
	//
	// The command is simply exec'd, it is not run inside a shell, so traditional shell instructions ('|', etc) won't work. To use a shell, you need to explicitly call out to that shell. Exit status of 0 is treated as live/healthy and non-zero is unhealthy.
	Command *[]*string `field:"optional" json:"command" yaml:"command"`
}

One and only one of the following should be specified.

Exec specifies the action to take.

type ClusterInstallationSpecReadinessProbeHttpGet 

type ClusterInstallationSpecReadinessProbeHttpGet struct {
	// Name or number of the port to access on the container.
	//
	// Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
	Port ClusterInstallationSpecReadinessProbeHttpGetPort `field:"required" json:"port" yaml:"port"`
	// Host name to connect to, defaults to the pod IP.
	//
	// You probably want to set "Host" in httpHeaders instead.
	Host *string `field:"optional" json:"host" yaml:"host"`
	// Custom headers to set in the request.
	//
	// HTTP allows repeated headers.
	HttpHeaders *[]*ClusterInstallationSpecReadinessProbeHttpGetHttpHeaders `field:"optional" json:"httpHeaders" yaml:"httpHeaders"`
	// Path to access on the HTTP server.
	Path *string `field:"optional" json:"path" yaml:"path"`
	// Scheme to use for connecting to the host.
	//
	// Defaults to HTTP.
	Scheme *string `field:"optional" json:"scheme" yaml:"scheme"`
}

HTTPGet specifies the http request to perform.

type ClusterInstallationSpecReadinessProbeHttpGetHttpHeaders 

type ClusterInstallationSpecReadinessProbeHttpGetHttpHeaders struct {
	// The header field name.
	Name *string `field:"required" json:"name" yaml:"name"`
	// The header field value.
	Value *string `field:"required" json:"value" yaml:"value"`
}

HTTPHeader describes a custom header to be used in HTTP probes.

type ClusterInstallationSpecReadinessProbeHttpGetPort 

type ClusterInstallationSpecReadinessProbeHttpGetPort interface {
	Value() interface{}
}

Name or number of the port to access on the container.

Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.

func ClusterInstallationSpecReadinessProbeHttpGetPort_FromNumber 

func ClusterInstallationSpecReadinessProbeHttpGetPort_FromNumber(value *float64) ClusterInstallationSpecReadinessProbeHttpGetPort

func ClusterInstallationSpecReadinessProbeHttpGetPort_FromString 

func ClusterInstallationSpecReadinessProbeHttpGetPort_FromString(value *string) ClusterInstallationSpecReadinessProbeHttpGetPort

type ClusterInstallationSpecReadinessProbeTcpSocket 

type ClusterInstallationSpecReadinessProbeTcpSocket struct {
	// Number or name of the port to access on the container.
	//
	// Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
	Port ClusterInstallationSpecReadinessProbeTcpSocketPort `field:"required" json:"port" yaml:"port"`
	// Optional: Host name to connect to, defaults to the pod IP.
	Host *string `field:"optional" json:"host" yaml:"host"`
}

TCPSocket specifies an action involving a TCP port.

TCP hooks not yet supported TODO: implement a realistic TCP lifecycle hook.

type ClusterInstallationSpecReadinessProbeTcpSocketPort 

type ClusterInstallationSpecReadinessProbeTcpSocketPort interface {
	Value() interface{}
}

Number or name of the port to access on the container.

Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.

func ClusterInstallationSpecReadinessProbeTcpSocketPort_FromNumber 

func ClusterInstallationSpecReadinessProbeTcpSocketPort_FromNumber(value *float64) ClusterInstallationSpecReadinessProbeTcpSocketPort

func ClusterInstallationSpecReadinessProbeTcpSocketPort_FromString 

func ClusterInstallationSpecReadinessProbeTcpSocketPort_FromString(value *string) ClusterInstallationSpecReadinessProbeTcpSocketPort

type ClusterInstallationSpecResources 

type ClusterInstallationSpecResources struct {
	// Limits describes the maximum amount of compute resources allowed.
	//
	// More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/
	Limits *map[string]*string `field:"optional" json:"limits" yaml:"limits"`
	// Requests describes the minimum amount of compute resources required.
	//
	// If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/
	Requests *map[string]*string `field:"optional" json:"requests" yaml:"requests"`
}

Defines the resource requests and limits for the Mattermost app server pods.

Source Files

View all Source files

Directories

Path Synopsis
Package jsii contains the functionaility needed for jsii packages to initialize their dependencies and themselves.
 Package jsii contains the functionaility needed for jsii packages to initialize their dependencies and themselves.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.