Documentation

Index

Constants

View Source
const (
	// TODO(sig-cli): Enforce consistent naming for generators here.
	// See discussion in https://github.com/kubernetes/kubernetes/issues/46237
	// before you add any more.
	RunV1GeneratorName                      = "run/v1"
	RunPodV1GeneratorName                   = "run-pod/v1"
	ServiceV1GeneratorName                  = "service/v1"
	ServiceV2GeneratorName                  = "service/v2"
	ServiceNodePortGeneratorV1Name          = "service-nodeport/v1"
	ServiceClusterIPGeneratorV1Name         = "service-clusterip/v1"
	ServiceLoadBalancerGeneratorV1Name      = "service-loadbalancer/v1"
	ServiceExternalNameGeneratorV1Name      = "service-externalname/v1"
	ServiceAccountV1GeneratorName           = "serviceaccount/v1"
	HorizontalPodAutoscalerV1GeneratorName  = "horizontalpodautoscaler/v1"
	DeploymentV1Beta1GeneratorName          = "deployment/v1beta1"
	DeploymentAppsV1Beta1GeneratorName      = "deployment/apps.v1beta1"
	DeploymentAppsV1GeneratorName           = "deployment/apps.v1"
	DeploymentBasicV1Beta1GeneratorName     = "deployment-basic/v1beta1"
	DeploymentBasicAppsV1Beta1GeneratorName = "deployment-basic/apps.v1beta1"
	DeploymentBasicAppsV1GeneratorName      = "deployment-basic/apps.v1"
	JobV1GeneratorName                      = "job/v1"
	CronJobV2Alpha1GeneratorName            = "cronjob/v2alpha1"
	CronJobV1Beta1GeneratorName             = "cronjob/v1beta1"
	NamespaceV1GeneratorName                = "namespace/v1"
	ResourceQuotaV1GeneratorName            = "resourcequotas/v1"
	SecretV1GeneratorName                   = "secret/v1"
	SecretForDockerRegistryV1GeneratorName  = "secret-for-docker-registry/v1"
	SecretForTLSV1GeneratorName             = "secret-for-tls/v1"
	ConfigMapV1GeneratorName                = "configmap/v1"
	ClusterRoleBindingV1GeneratorName       = "clusterrolebinding.rbac.authorization.k8s.io/v1alpha1"
	RoleBindingV1GeneratorName              = "rolebinding.rbac.authorization.k8s.io/v1alpha1"
	PodDisruptionBudgetV1GeneratorName      = "poddisruptionbudget/v1beta1"
	PodDisruptionBudgetV2GeneratorName      = "poddisruptionbudget/v1beta1/v2"
	PriorityClassV1Alpha1GeneratorName      = "priorityclass/v1alpha1"
)

Variables

    GeneratorFn gives a way to easily override the function for unit testing if needed

    Functions

    func DefaultGenerators

    func DefaultGenerators(cmdName string) map[string]generate.Generator

      DefaultGenerators returns the set of default generators for use in Factory instances

      func FallbackGeneratorNameIfNecessary

      func FallbackGeneratorNameIfNecessary(
      	generatorName string,
      	discoveryClient discovery.DiscoveryInterface,
      	cmdErr io.Writer,
      ) (string, error)

        FallbackGeneratorNameIfNecessary returns the name of the old generator if server does not support new generator. Otherwise, the generator string is returned unchanged.

        If the generator name is changed, print a warning message to let the user know.

        func HandleResourceRequirementsV1

        func HandleResourceRequirementsV1(params map[string]string) (v1.ResourceRequirements, error)

          HandleResourceRequirementsV1 parses the limits and requests parameters if specified and returns ResourceRequirements.

          func HasResource

          func HasResource(client discovery.DiscoveryInterface, resource schema.GroupVersionResource) (bool, error)

          Types

          type BaseDeploymentGenerator

          type BaseDeploymentGenerator struct {
          	Name   string
          	Images []string
          }

            BaseDeploymentGenerator implements the common functionality of DeploymentBasicGeneratorV1, DeploymentBasicAppsGeneratorV1Beta1 and DeploymentBasicAppsGeneratorV1. To reduce confusion, it's best to keep this struct in the same file as those generators.

            type BasicPod

            type BasicPod struct{}

            func (BasicPod) Generate

            func (BasicPod) Generate(genericParams map[string]interface{}) (runtime.Object, error)

            func (BasicPod) ParamNames

            func (BasicPod) ParamNames() []generate.GeneratorParam

            type BasicReplicationController

            type BasicReplicationController struct{}

            func (BasicReplicationController) Generate

            func (BasicReplicationController) Generate(genericParams map[string]interface{}) (runtime.Object, error)

            func (BasicReplicationController) ParamNames

            type ClusterRoleBindingGeneratorV1

            type ClusterRoleBindingGeneratorV1 struct {
            	// Name of clusterRoleBinding (required)
            	Name string
            	// ClusterRole for the clusterRoleBinding (required)
            	ClusterRole string
            	// Users to derive the clusterRoleBinding from (optional)
            	Users []string
            	// Groups to derive the clusterRoleBinding from (optional)
            	Groups []string
            	// ServiceAccounts to derive the clusterRoleBinding from in namespace:name format(optional)
            	ServiceAccounts []string
            }

              ClusterRoleBindingGeneratorV1 supports stable generation of a clusterRoleBinding.

              func (ClusterRoleBindingGeneratorV1) Generate

              func (s ClusterRoleBindingGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                Generate returns a clusterRoleBinding using the specified parameters.

                func (ClusterRoleBindingGeneratorV1) ParamNames

                  ParamNames returns the set of supported input parameters when using the parameter injection generator pattern.

                  func (ClusterRoleBindingGeneratorV1) StructuredGenerate

                  func (s ClusterRoleBindingGeneratorV1) StructuredGenerate() (runtime.Object, error)

                    StructuredGenerate outputs a clusterRoleBinding object using the configured fields.

                    type ConfigMapGeneratorV1

                    type ConfigMapGeneratorV1 struct {
                    	// Name of configMap (required)
                    	Name string
                    	// Type of configMap (optional)
                    	Type string
                    	// FileSources to derive the configMap from (optional)
                    	FileSources []string
                    	// LiteralSources to derive the configMap from (optional)
                    	LiteralSources []string
                    	// EnvFileSource to derive the configMap from (optional)
                    	EnvFileSource string
                    	// AppendHash; if true, derive a hash from the ConfigMap and append it to the name
                    	AppendHash bool
                    }

                      ConfigMapGeneratorV1 supports stable generation of a configMap.

                      func (ConfigMapGeneratorV1) Generate

                      func (s ConfigMapGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                        Generate returns a configMap using the specified parameters.

                        func (ConfigMapGeneratorV1) ParamNames

                        func (s ConfigMapGeneratorV1) ParamNames() []generate.GeneratorParam

                          ParamNames returns the set of supported input parameters when using the parameter injection generator pattern.

                          func (ConfigMapGeneratorV1) StructuredGenerate

                          func (s ConfigMapGeneratorV1) StructuredGenerate() (runtime.Object, error)

                            StructuredGenerate outputs a configMap object using the configured fields.

                            type CronJobV1Beta1

                            type CronJobV1Beta1 struct{}

                            func (CronJobV1Beta1) Generate

                            func (CronJobV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                            func (CronJobV1Beta1) ParamNames

                            func (CronJobV1Beta1) ParamNames() []generate.GeneratorParam

                            type CronJobV2Alpha1

                            type CronJobV2Alpha1 struct{}

                            func (CronJobV2Alpha1) Generate

                            func (CronJobV2Alpha1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                            func (CronJobV2Alpha1) ParamNames

                            func (CronJobV2Alpha1) ParamNames() []generate.GeneratorParam

                            type DeploymentAppsV1

                            type DeploymentAppsV1 struct{}

                            func (DeploymentAppsV1) Generate

                            func (DeploymentAppsV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                            func (DeploymentAppsV1) ParamNames

                            func (DeploymentAppsV1) ParamNames() []generate.GeneratorParam

                            type DeploymentAppsV1Beta1

                            type DeploymentAppsV1Beta1 struct{}

                            func (DeploymentAppsV1Beta1) Generate

                            func (DeploymentAppsV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                            func (DeploymentAppsV1Beta1) ParamNames

                            type DeploymentBasicAppsGeneratorV1

                            type DeploymentBasicAppsGeneratorV1 struct {
                            	BaseDeploymentGenerator
                            }

                              DeploymentBasicAppsGeneratorV1 supports stable generation of a deployment under apps/v1 endpoint

                              func (*DeploymentBasicAppsGeneratorV1) StructuredGenerate

                              func (s *DeploymentBasicAppsGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                StructuredGenerate outputs a deployment object using the configured fields

                                type DeploymentBasicAppsGeneratorV1Beta1

                                type DeploymentBasicAppsGeneratorV1Beta1 struct {
                                	BaseDeploymentGenerator
                                }

                                  DeploymentBasicAppsGeneratorV1Beta1 supports stable generation of a deployment under apps/v1beta1 endpoint

                                  func (*DeploymentBasicAppsGeneratorV1Beta1) StructuredGenerate

                                  func (s *DeploymentBasicAppsGeneratorV1Beta1) StructuredGenerate() (runtime.Object, error)

                                    StructuredGenerate outputs a deployment object using the configured fields

                                    type DeploymentBasicGeneratorV1

                                    type DeploymentBasicGeneratorV1 struct {
                                    	BaseDeploymentGenerator
                                    }

                                      DeploymentBasicGeneratorV1 supports stable generation of a deployment

                                      func (*DeploymentBasicGeneratorV1) StructuredGenerate

                                      func (s *DeploymentBasicGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                        StructuredGenerate outputs a deployment object using the configured fields

                                        type DeploymentV1Beta1

                                        type DeploymentV1Beta1 struct{}

                                        func (DeploymentV1Beta1) Generate

                                        func (DeploymentV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                        func (DeploymentV1Beta1) ParamNames

                                        func (DeploymentV1Beta1) ParamNames() []generate.GeneratorParam

                                        type DockerConfig

                                        type DockerConfig map[string]DockerConfigEntry

                                          DockerConfig represents the config file used by the docker CLI. This config that represents the credentials that should be used when pulling images from specific image repositories.

                                          type DockerConfigEntry

                                          type DockerConfigEntry struct {
                                          	Username string `json:"username,omitempty"`
                                          	Password string `json:"password,omitempty"`
                                          	Email    string `json:"email,omitempty"`
                                          	Auth     string `json:"auth,omitempty"`
                                          }

                                          type DockerConfigJSON

                                          type DockerConfigJSON struct {
                                          	Auths DockerConfig `json:"auths"`
                                          	// +optional
                                          	HttpHeaders map[string]string `json:"HttpHeaders,omitempty"`
                                          }

                                            DockerConfigJSON represents a local docker auth config file for pulling images.

                                            type HorizontalPodAutoscalerGeneratorV1

                                            type HorizontalPodAutoscalerGeneratorV1 struct {
                                            	Name               string
                                            	ScaleRefKind       string
                                            	ScaleRefName       string
                                            	ScaleRefAPIVersion string
                                            	MinReplicas        int32
                                            	MaxReplicas        int32
                                            	CPUPercent         int32
                                            }

                                              HorizontalPodAutoscalerGeneratorV1 supports stable generation of a horizontal pod autoscaler.

                                              func (*HorizontalPodAutoscalerGeneratorV1) StructuredGenerate

                                              func (s *HorizontalPodAutoscalerGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                StructuredGenerate outputs a horizontal pod autoscaler object using the configured fields.

                                                type JobV1

                                                type JobV1 struct{}

                                                func (JobV1) Generate

                                                func (JobV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                                func (JobV1) ParamNames

                                                func (JobV1) ParamNames() []generate.GeneratorParam

                                                type NamespaceGeneratorV1

                                                type NamespaceGeneratorV1 struct {
                                                	// Name of namespace
                                                	Name string
                                                }

                                                  NamespaceGeneratorV1 supports stable generation of a namespace

                                                  func (NamespaceGeneratorV1) Generate

                                                  func (g NamespaceGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                                    Generate returns a namespace using the specified parameters

                                                    func (NamespaceGeneratorV1) ParamNames

                                                    func (g NamespaceGeneratorV1) ParamNames() []generate.GeneratorParam

                                                      ParamNames returns the set of supported input parameters when using the parameter injection generator pattern

                                                      func (*NamespaceGeneratorV1) StructuredGenerate

                                                      func (g *NamespaceGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                        StructuredGenerate outputs a namespace object using the configured fields

                                                        type PodDisruptionBudgetV1Generator

                                                        type PodDisruptionBudgetV1Generator struct {
                                                        	Name         string
                                                        	MinAvailable string
                                                        	Selector     string
                                                        }

                                                          PodDisruptionBudgetV1Generator supports stable generation of a pod disruption budget.

                                                          func (PodDisruptionBudgetV1Generator) Generate

                                                          func (s PodDisruptionBudgetV1Generator) Generate(params map[string]interface{}) (runtime.Object, error)

                                                          func (PodDisruptionBudgetV1Generator) ParamNames

                                                          func (*PodDisruptionBudgetV1Generator) StructuredGenerate

                                                          func (s *PodDisruptionBudgetV1Generator) StructuredGenerate() (runtime.Object, error)

                                                            StructuredGenerate outputs a pod disruption budget object using the configured fields.

                                                            type PodDisruptionBudgetV2Generator

                                                            type PodDisruptionBudgetV2Generator struct {
                                                            	Name           string
                                                            	MinAvailable   string
                                                            	MaxUnavailable string
                                                            	Selector       string
                                                            }

                                                              PodDisruptionBudgetV2Generator supports stable generation of a pod disruption budget.

                                                              func (PodDisruptionBudgetV2Generator) Generate

                                                              func (s PodDisruptionBudgetV2Generator) Generate(params map[string]interface{}) (runtime.Object, error)

                                                              func (PodDisruptionBudgetV2Generator) ParamNames

                                                              func (*PodDisruptionBudgetV2Generator) StructuredGenerate

                                                              func (s *PodDisruptionBudgetV2Generator) StructuredGenerate() (runtime.Object, error)

                                                                StructuredGenerate outputs a pod disruption budget object using the configured fields.

                                                                type PriorityClassV1Generator

                                                                type PriorityClassV1Generator struct {
                                                                	Name          string
                                                                	Value         int32
                                                                	GlobalDefault bool
                                                                	Description   string
                                                                }

                                                                  PriorityClassV1Generator supports stable generation of a priorityClass.

                                                                  func (PriorityClassV1Generator) Generate

                                                                  func (s PriorityClassV1Generator) Generate(params map[string]interface{}) (runtime.Object, error)

                                                                  func (PriorityClassV1Generator) ParamNames

                                                                  func (*PriorityClassV1Generator) StructuredGenerate

                                                                  func (s *PriorityClassV1Generator) StructuredGenerate() (runtime.Object, error)

                                                                    StructuredGenerate outputs a priorityClass object using the configured fields.

                                                                    type ResourceQuotaGeneratorV1

                                                                    type ResourceQuotaGeneratorV1 struct {
                                                                    	// The name of a quota object.
                                                                    	Name string
                                                                    
                                                                    	// The hard resource limit string before parsing.
                                                                    	Hard string
                                                                    
                                                                    	// The scopes of a quota object before parsing.
                                                                    	Scopes string
                                                                    }

                                                                      ResourceQuotaGeneratorV1 supports stable generation of a resource quota

                                                                      func (ResourceQuotaGeneratorV1) Generate

                                                                      func (g ResourceQuotaGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                                                      func (ResourceQuotaGeneratorV1) ParamNames

                                                                        ParamNames returns the set of supported input parameters when using the parameter injection generator pattern

                                                                        func (*ResourceQuotaGeneratorV1) StructuredGenerate

                                                                        func (g *ResourceQuotaGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                                          StructuredGenerate outputs a ResourceQuota object using the configured fields

                                                                          type RoleBindingGeneratorV1

                                                                          type RoleBindingGeneratorV1 struct {
                                                                          	// Name of roleBinding (required)
                                                                          	Name string
                                                                          	// ClusterRole for the roleBinding
                                                                          	ClusterRole string
                                                                          	// Role for the roleBinding
                                                                          	Role string
                                                                          	// Users to derive the roleBinding from (optional)
                                                                          	Users []string
                                                                          	// Groups to derive the roleBinding from (optional)
                                                                          	Groups []string
                                                                          	// ServiceAccounts to derive the roleBinding from in namespace:name format(optional)
                                                                          	ServiceAccounts []string
                                                                          }

                                                                            RoleBindingGeneratorV1 supports stable generation of a roleBinding.

                                                                            func (RoleBindingGeneratorV1) Generate

                                                                            func (s RoleBindingGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                                                              Generate returns a roleBinding using the specified parameters.

                                                                              func (RoleBindingGeneratorV1) ParamNames

                                                                                ParamNames returns the set of supported input parameters when using the parameter injection generator pattern.

                                                                                func (RoleBindingGeneratorV1) StructuredGenerate

                                                                                func (s RoleBindingGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                                                  StructuredGenerate outputs a roleBinding object using the configured fields.

                                                                                  type SecretForDockerRegistryGeneratorV1

                                                                                  type SecretForDockerRegistryGeneratorV1 struct {
                                                                                  	// Name of secret (required)
                                                                                  	Name string
                                                                                  	// FileSources to derive the secret from (optional)
                                                                                  	FileSources []string
                                                                                  	// Username for registry (required)
                                                                                  	Username string
                                                                                  	// Email for registry (optional)
                                                                                  	Email string
                                                                                  	// Password for registry (required)
                                                                                  	Password string
                                                                                  	// Server for registry (required)
                                                                                  	Server string
                                                                                  	// AppendHash; if true, derive a hash from the Secret and append it to the name
                                                                                  	AppendHash bool
                                                                                  }

                                                                                    SecretForDockerRegistryGeneratorV1 supports stable generation of a docker registry secret

                                                                                    func (SecretForDockerRegistryGeneratorV1) Generate

                                                                                    func (s SecretForDockerRegistryGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                                                                      Generate returns a secret using the specified parameters

                                                                                      func (SecretForDockerRegistryGeneratorV1) ParamNames

                                                                                        ParamNames returns the set of supported input parameters when using the parameter injection generator pattern

                                                                                        func (SecretForDockerRegistryGeneratorV1) StructuredGenerate

                                                                                        func (s SecretForDockerRegistryGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                                                          StructuredGenerate outputs a secret object using the configured fields

                                                                                          type SecretForTLSGeneratorV1

                                                                                          type SecretForTLSGeneratorV1 struct {
                                                                                          	// Name is the name of this TLS secret.
                                                                                          	Name string
                                                                                          	// Key is the path to the user's private key.
                                                                                          	Key string
                                                                                          	// Cert is the path to the user's public key certificate.
                                                                                          	Cert string
                                                                                          	// AppendHash; if true, derive a hash from the Secret and append it to the name
                                                                                          	AppendHash bool
                                                                                          }

                                                                                            SecretForTLSGeneratorV1 supports stable generation of a TLS secret.

                                                                                            func (SecretForTLSGeneratorV1) Generate

                                                                                            func (s SecretForTLSGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                                                                              Generate returns a secret using the specified parameters

                                                                                              func (SecretForTLSGeneratorV1) ParamNames

                                                                                                ParamNames returns the set of supported input parameters when using the parameter injection generator pattern

                                                                                                func (SecretForTLSGeneratorV1) StructuredGenerate

                                                                                                func (s SecretForTLSGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                                                                  StructuredGenerate outputs a secret object using the configured fields

                                                                                                  type SecretGeneratorV1

                                                                                                  type SecretGeneratorV1 struct {
                                                                                                  	// Name of secret (required)
                                                                                                  	Name string
                                                                                                  	// Type of secret (optional)
                                                                                                  	Type string
                                                                                                  	// FileSources to derive the secret from (optional)
                                                                                                  	FileSources []string
                                                                                                  	// LiteralSources to derive the secret from (optional)
                                                                                                  	LiteralSources []string
                                                                                                  	// EnvFileSource to derive the secret from (optional)
                                                                                                  	EnvFileSource string
                                                                                                  	// AppendHash; if true, derive a hash from the Secret data and type and append it to the name
                                                                                                  	AppendHash bool
                                                                                                  }

                                                                                                    SecretGeneratorV1 supports stable generation of an opaque secret

                                                                                                    func (SecretGeneratorV1) Generate

                                                                                                    func (s SecretGeneratorV1) Generate(genericParams map[string]interface{}) (runtime.Object, error)

                                                                                                      Generate returns a secret using the specified parameters

                                                                                                      func (SecretGeneratorV1) ParamNames

                                                                                                      func (s SecretGeneratorV1) ParamNames() []generate.GeneratorParam

                                                                                                        ParamNames returns the set of supported input parameters when using the parameter injection generator pattern

                                                                                                        func (SecretGeneratorV1) StructuredGenerate

                                                                                                        func (s SecretGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                                                                          StructuredGenerate outputs a secret object using the configured fields

                                                                                                          type ServiceAccountGeneratorV1

                                                                                                          type ServiceAccountGeneratorV1 struct {
                                                                                                          	// Name of service account
                                                                                                          	Name string
                                                                                                          }

                                                                                                            ServiceAccountGeneratorV1 supports stable generation of a service account

                                                                                                            func (*ServiceAccountGeneratorV1) StructuredGenerate

                                                                                                            func (g *ServiceAccountGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                                                                              StructuredGenerate outputs a service account object using the configured fields

                                                                                                              type ServiceClusterIPGeneratorV1

                                                                                                              type ServiceClusterIPGeneratorV1 struct {
                                                                                                              	ServiceCommonGeneratorV1
                                                                                                              }

                                                                                                              func (ServiceClusterIPGeneratorV1) Generate

                                                                                                              func (s ServiceClusterIPGeneratorV1) Generate(params map[string]interface{}) (runtime.Object, error)

                                                                                                              func (ServiceClusterIPGeneratorV1) ParamNames

                                                                                                              type ServiceCommonGeneratorV1

                                                                                                              type ServiceCommonGeneratorV1 struct {
                                                                                                              	Name         string
                                                                                                              	TCP          []string
                                                                                                              	Type         v1.ServiceType
                                                                                                              	ClusterIP    string
                                                                                                              	NodePort     int
                                                                                                              	ExternalName string
                                                                                                              }

                                                                                                              func (ServiceCommonGeneratorV1) GenerateCommon

                                                                                                              func (s ServiceCommonGeneratorV1) GenerateCommon(params map[string]interface{}) error

                                                                                                              func (ServiceCommonGeneratorV1) StructuredGenerate

                                                                                                              func (s ServiceCommonGeneratorV1) StructuredGenerate() (runtime.Object, error)

                                                                                                              type ServiceExternalNameGeneratorV1

                                                                                                              type ServiceExternalNameGeneratorV1 struct {
                                                                                                              	ServiceCommonGeneratorV1
                                                                                                              }

                                                                                                                TODO: is this really necessary?

                                                                                                                func (ServiceExternalNameGeneratorV1) Generate

                                                                                                                func (s ServiceExternalNameGeneratorV1) Generate(params map[string]interface{}) (runtime.Object, error)

                                                                                                                func (ServiceExternalNameGeneratorV1) ParamNames

                                                                                                                type ServiceGeneratorV1

                                                                                                                type ServiceGeneratorV1 struct{}

                                                                                                                  The only difference between ServiceGeneratorV1 and V2 is that the service port is named "default" in V1, while it is left unnamed in V2.

                                                                                                                  func (ServiceGeneratorV1) Generate

                                                                                                                  func (ServiceGeneratorV1) Generate(params map[string]interface{}) (runtime.Object, error)

                                                                                                                  func (ServiceGeneratorV1) ParamNames

                                                                                                                  type ServiceGeneratorV2

                                                                                                                  type ServiceGeneratorV2 struct{}

                                                                                                                  func (ServiceGeneratorV2) Generate

                                                                                                                  func (ServiceGeneratorV2) Generate(params map[string]interface{}) (runtime.Object, error)

                                                                                                                  func (ServiceGeneratorV2) ParamNames

                                                                                                                  type ServiceLoadBalancerGeneratorV1

                                                                                                                  type ServiceLoadBalancerGeneratorV1 struct {
                                                                                                                  	ServiceCommonGeneratorV1
                                                                                                                  }

                                                                                                                  func (ServiceLoadBalancerGeneratorV1) Generate

                                                                                                                  func (s ServiceLoadBalancerGeneratorV1) Generate(params map[string]interface{}) (runtime.Object, error)

                                                                                                                  func (ServiceLoadBalancerGeneratorV1) ParamNames

                                                                                                                  type ServiceNodePortGeneratorV1

                                                                                                                  type ServiceNodePortGeneratorV1 struct {
                                                                                                                  	ServiceCommonGeneratorV1
                                                                                                                  }

                                                                                                                  func (ServiceNodePortGeneratorV1) Generate

                                                                                                                  func (s ServiceNodePortGeneratorV1) Generate(params map[string]interface{}) (runtime.Object, error)

                                                                                                                  func (ServiceNodePortGeneratorV1) ParamNames