kubernetes: k8s.io/kubernetes/pkg/kubectl/generate/versioned Index | Files

package versioned

import "k8s.io/kubernetes/pkg/kubectl/generate/versioned"

Index

Package Files

autoscale.go clusterrolebinding.go configmap.go deployment.go env_file.go generator.go namespace.go pdb.go priorityclass.go quota.go rolebinding.go run.go secret.go secret_for_docker_registry.go secret_for_tls.go service.go service_basic.go serviceaccount.go

Constants

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"
    PriorityClassV1Beta1GeneratorName       = "priorityclass/v1beta1"
    PriorityClassV1GeneratorName            = "priorityclass/v1"
)

Variables

var GeneratorFn generate.GeneratorFunc = DefaultGenerators

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

func DefaultGenerators Uses

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

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

func FallbackGeneratorNameIfNecessary Uses

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 Uses

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

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

func HasResource Uses

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

type BaseDeploymentGenerator Uses

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 Uses

type BasicPod struct{}

func (BasicPod) Generate Uses

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

func (BasicPod) ParamNames Uses

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

type BasicReplicationController Uses

type BasicReplicationController struct{}

func (BasicReplicationController) Generate Uses

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

func (BasicReplicationController) ParamNames Uses

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

type ClusterRoleBindingGeneratorV1 Uses

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 Uses

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

Generate returns a clusterRoleBinding using the specified parameters.

func (ClusterRoleBindingGeneratorV1) ParamNames Uses

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

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

func (ClusterRoleBindingGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a clusterRoleBinding object using the configured fields.

type ConfigMapGeneratorV1 Uses

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 Uses

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

Generate returns a configMap using the specified parameters.

func (ConfigMapGeneratorV1) ParamNames Uses

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

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

func (ConfigMapGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a configMap object using the configured fields.

type CronJobV1Beta1 Uses

type CronJobV1Beta1 struct{}

func (CronJobV1Beta1) Generate Uses

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

func (CronJobV1Beta1) ParamNames Uses

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

type CronJobV2Alpha1 Uses

type CronJobV2Alpha1 struct{}

func (CronJobV2Alpha1) Generate Uses

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

func (CronJobV2Alpha1) ParamNames Uses

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

type DeploymentAppsV1 Uses

type DeploymentAppsV1 struct{}

func (DeploymentAppsV1) Generate Uses

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

func (DeploymentAppsV1) ParamNames Uses

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

type DeploymentAppsV1Beta1 Uses

type DeploymentAppsV1Beta1 struct{}

func (DeploymentAppsV1Beta1) Generate Uses

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

func (DeploymentAppsV1Beta1) ParamNames Uses

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

type DeploymentBasicAppsGeneratorV1 Uses

type DeploymentBasicAppsGeneratorV1 struct {
    BaseDeploymentGenerator
}

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

func (*DeploymentBasicAppsGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a deployment object using the configured fields

type DeploymentBasicAppsGeneratorV1Beta1 Uses

type DeploymentBasicAppsGeneratorV1Beta1 struct {
    BaseDeploymentGenerator
}

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

func (*DeploymentBasicAppsGeneratorV1Beta1) StructuredGenerate Uses

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

StructuredGenerate outputs a deployment object using the configured fields

type DeploymentBasicGeneratorV1 Uses

type DeploymentBasicGeneratorV1 struct {
    BaseDeploymentGenerator
}

DeploymentBasicGeneratorV1 supports stable generation of a deployment

func (*DeploymentBasicGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a deployment object using the configured fields

type DeploymentV1Beta1 Uses

type DeploymentV1Beta1 struct{}

func (DeploymentV1Beta1) Generate Uses

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

func (DeploymentV1Beta1) ParamNames Uses

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

type DockerConfig Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

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

type JobV1 Uses

type JobV1 struct{}

func (JobV1) Generate Uses

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

func (JobV1) ParamNames Uses

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

type NamespaceGeneratorV1 Uses

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

NamespaceGeneratorV1 supports stable generation of a namespace

func (NamespaceGeneratorV1) Generate Uses

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

Generate returns a namespace using the specified parameters

func (NamespaceGeneratorV1) ParamNames Uses

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

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

func (*NamespaceGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a namespace object using the configured fields

type PodDisruptionBudgetV1Generator Uses

type PodDisruptionBudgetV1Generator struct {
    Name         string
    MinAvailable string
    Selector     string
}

PodDisruptionBudgetV1Generator supports stable generation of a pod disruption budget.

func (PodDisruptionBudgetV1Generator) Generate Uses

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

func (PodDisruptionBudgetV1Generator) ParamNames Uses

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

func (*PodDisruptionBudgetV1Generator) StructuredGenerate Uses

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

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

type PodDisruptionBudgetV2Generator Uses

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

PodDisruptionBudgetV2Generator supports stable generation of a pod disruption budget.

func (PodDisruptionBudgetV2Generator) Generate Uses

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

func (PodDisruptionBudgetV2Generator) ParamNames Uses

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

func (*PodDisruptionBudgetV2Generator) StructuredGenerate Uses

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

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

type PriorityClassV1Generator Uses

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

PriorityClassV1Generator supports stable generation of a priorityClass.

func (PriorityClassV1Generator) Generate Uses

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

func (PriorityClassV1Generator) ParamNames Uses

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

func (*PriorityClassV1Generator) StructuredGenerate Uses

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

StructuredGenerate outputs a priorityClass object using the configured fields.

type ResourceQuotaGeneratorV1 Uses

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 Uses

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

func (ResourceQuotaGeneratorV1) ParamNames Uses

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

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

func (*ResourceQuotaGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a ResourceQuota object using the configured fields

type RoleBindingGeneratorV1 Uses

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 Uses

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

Generate returns a roleBinding using the specified parameters.

func (RoleBindingGeneratorV1) ParamNames Uses

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

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

func (RoleBindingGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a roleBinding object using the configured fields.

type SecretForDockerRegistryGeneratorV1 Uses

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 Uses

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

Generate returns a secret using the specified parameters

func (SecretForDockerRegistryGeneratorV1) ParamNames Uses

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

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

func (SecretForDockerRegistryGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a secret object using the configured fields

type SecretForTLSGeneratorV1 Uses

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 Uses

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

Generate returns a secret using the specified parameters

func (SecretForTLSGeneratorV1) ParamNames Uses

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

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

func (SecretForTLSGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a secret object using the configured fields

type SecretGeneratorV1 Uses

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 Uses

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

Generate returns a secret using the specified parameters

func (SecretGeneratorV1) ParamNames Uses

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

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

func (SecretGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a secret object using the configured fields

type ServiceAccountGeneratorV1 Uses

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

ServiceAccountGeneratorV1 supports stable generation of a service account

func (*ServiceAccountGeneratorV1) StructuredGenerate Uses

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

StructuredGenerate outputs a service account object using the configured fields

type ServiceClusterIPGeneratorV1 Uses

type ServiceClusterIPGeneratorV1 struct {
    ServiceCommonGeneratorV1
}

func (ServiceClusterIPGeneratorV1) Generate Uses

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

func (ServiceClusterIPGeneratorV1) ParamNames Uses

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

type ServiceCommonGeneratorV1 Uses

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

func (ServiceCommonGeneratorV1) GenerateCommon Uses

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

func (ServiceCommonGeneratorV1) StructuredGenerate Uses

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

type ServiceExternalNameGeneratorV1 Uses

type ServiceExternalNameGeneratorV1 struct {
    ServiceCommonGeneratorV1
}

TODO: is this really necessary?

func (ServiceExternalNameGeneratorV1) Generate Uses

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

func (ServiceExternalNameGeneratorV1) ParamNames Uses

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

type ServiceGeneratorV1 Uses

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 Uses

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

func (ServiceGeneratorV1) ParamNames Uses

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

type ServiceGeneratorV2 Uses

type ServiceGeneratorV2 struct{}

func (ServiceGeneratorV2) Generate Uses

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

func (ServiceGeneratorV2) ParamNames Uses

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

type ServiceLoadBalancerGeneratorV1 Uses

type ServiceLoadBalancerGeneratorV1 struct {
    ServiceCommonGeneratorV1
}

func (ServiceLoadBalancerGeneratorV1) Generate Uses

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

func (ServiceLoadBalancerGeneratorV1) ParamNames Uses

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

type ServiceNodePortGeneratorV1 Uses

type ServiceNodePortGeneratorV1 struct {
    ServiceCommonGeneratorV1
}

func (ServiceNodePortGeneratorV1) Generate Uses

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

func (ServiceNodePortGeneratorV1) ParamNames Uses

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

Package versioned imports 38 packages (graph) and is imported by 48 packages. Updated 2019-06-29. Refresh now. Tools for package owners.