have a "real" external address

[github-actions[bot]]

have a "real" external address

https://github.com/pacoxu/kubernetes/blob/19f8624ecd4751bb1c5a01662c32364a0169337d/staging/src/k8s.io/sample-apiserver/pkg/cmd/server/start.go#L118

Copyright 2016 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package server

import (
    "fmt"
    "io"
    "net"

    "github.com/spf13/cobra"

    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/runtime/schema"
    utilerrors "k8s.io/apimachinery/pkg/util/errors"
    "k8s.io/apiserver/pkg/admission"
    "k8s.io/apiserver/pkg/endpoints/openapi"
    "k8s.io/apiserver/pkg/features"
    genericapiserver "k8s.io/apiserver/pkg/server"
    genericoptions "k8s.io/apiserver/pkg/server/options"
    utilfeature "k8s.io/apiserver/pkg/util/feature"
    "k8s.io/sample-apiserver/pkg/admission/plugin/banflunder"
    "k8s.io/sample-apiserver/pkg/admission/wardleinitializer"
    "k8s.io/sample-apiserver/pkg/apis/wardle/v1alpha1"
    "k8s.io/sample-apiserver/pkg/apiserver"
    clientset "k8s.io/sample-apiserver/pkg/generated/clientset/versioned"
    informers "k8s.io/sample-apiserver/pkg/generated/informers/externalversions"
    sampleopenapi "k8s.io/sample-apiserver/pkg/generated/openapi"
)

const defaultEtcdPathPrefix = "/registry/wardle.example.com"

// WardleServerOptions contains state for master/api server
type WardleServerOptions struct {
    RecommendedOptions *genericoptions.RecommendedOptions

    SharedInformerFactory informers.SharedInformerFactory
    StdOut                io.Writer
    StdErr                io.Writer
}

// NewWardleServerOptions returns a new WardleServerOptions
func NewWardleServerOptions(out, errOut io.Writer) *WardleServerOptions {
    o := &WardleServerOptions{
        RecommendedOptions: genericoptions.NewRecommendedOptions(
            defaultEtcdPathPrefix,
            apiserver.Codecs.LegacyCodec(v1alpha1.SchemeGroupVersion),
        ),

        StdOut: out,
        StdErr: errOut,
    }
    o.RecommendedOptions.Etcd.StorageConfig.EncodeVersioner = runtime.NewMultiGroupVersioner(v1alpha1.SchemeGroupVersion, schema.GroupKind{Group: v1alpha1.GroupName})
    return o
}

// NewCommandStartWardleServer provides a CLI handler for 'start master' command
// with a default WardleServerOptions.
func NewCommandStartWardleServer(defaults *WardleServerOptions, stopCh <-chan struct{}) *cobra.Command {
    o := *defaults
    cmd := &cobra.Command{
        Short: "Launch a wardle API server",
        Long:  "Launch a wardle API server",
        RunE: func(c *cobra.Command, args []string) error {
            if err := o.Complete(); err != nil {
                return err
            }
            if err := o.Validate(args); err != nil {
                return err
            }
            if err := o.RunWardleServer(stopCh); err != nil {
                return err
            }
            return nil
        },
    }

    flags := cmd.Flags()
    o.RecommendedOptions.AddFlags(flags)
    utilfeature.DefaultMutableFeatureGate.AddFlag(flags)

    return cmd
}

// Validate validates WardleServerOptions
func (o WardleServerOptions) Validate(args []string) error {
    errors := []error{}
    errors = append(errors, o.RecommendedOptions.Validate()...)
    return utilerrors.NewAggregate(errors)
}

// Complete fills in fields required to have valid data
func (o *WardleServerOptions) Complete() error {
    // register admission plugins
    banflunder.Register(o.RecommendedOptions.Admission.Plugins)

    // add admission plugins to the RecommendedPluginOrder
    o.RecommendedOptions.Admission.RecommendedPluginOrder = append(o.RecommendedOptions.Admission.RecommendedPluginOrder, "BanFlunder")

    return nil
}

// Config returns config for the api server given WardleServerOptions
func (o *WardleServerOptions) Config() (*apiserver.Config, error) {
    // TODO have a "real" external address
    if err := o.RecommendedOptions.SecureServing.MaybeDefaultWithSelfSignedCerts("localhost", nil, []net.IP{net.ParseIP("127.0.0.1")}); err != nil {
        return nil, fmt.Errorf("error creating self-signed certificates: %v", err)
    }

    o.RecommendedOptions.Etcd.StorageConfig.Paging = utilfeature.DefaultFeatureGate.Enabled(features.APIListChunking)

    o.RecommendedOptions.ExtraAdmissionInitializers = func(c *genericapiserver.RecommendedConfig) ([]admission.PluginInitializer, error) {
        client, err := clientset.NewForConfig(c.LoopbackClientConfig)
        if err != nil {
            return nil, err
        }
        informerFactory := informers.NewSharedInformerFactory(client, c.LoopbackClientConfig.Timeout)
        o.SharedInformerFactory = informerFactory
        return []admission.PluginInitializer{wardleinitializer.New(informerFactory)}, nil
    }

    serverConfig := genericapiserver.NewRecommendedConfig(apiserver.Codecs)

    serverConfig.OpenAPIConfig = genericapiserver.DefaultOpenAPIConfig(sampleopenapi.GetOpenAPIDefinitions, openapi.NewDefinitionNamer(apiserver.Scheme))
    serverConfig.OpenAPIConfig.Info.Title = "Wardle"
    serverConfig.OpenAPIConfig.Info.Version = "0.1"

    if err := o.RecommendedOptions.ApplyTo(serverConfig); err != nil {
        return nil, err
    }

    config := &apiserver.Config{
        GenericConfig: serverConfig,
        ExtraConfig:   apiserver.ExtraConfig{},
    }
    return config, nil
}

// RunWardleServer starts a new WardleServer given WardleServerOptions
func (o WardleServerOptions) RunWardleServer(stopCh <-chan struct{}) error {
    config, err := o.Config()
    if err != nil {
        return err
    }

    server, err := config.Complete().New()
    if err != nil {
        return err
    }

    server.GenericAPIServer.AddPostStartHookOrDie("start-sample-server-informers", func(context genericapiserver.PostStartHookContext) error {
        config.GenericConfig.SharedInformerFactory.Start(context.StopCh)
        o.SharedInformerFactory.Start(context.StopCh)
        return nil
    })

    return server.GenericAPIServer.PrepareRun().Run(stopCh)
}
ew file mode 100644
ndex 0000000000000..03e39d2319f9b
++ b/staging/src/k8s.io/sample-apiserver/pkg/generated/clientset/versioned/BUILD

9914f672ab7e53b2a357c07817ee3188f0f53060