github.com/jonaz/heapster@v1.3.0-beta.0.0.20170208112634-cd3c15ca3d29/metrics/cmd/heapster-apiserver/app/server.go (about)

     1  // Copyright 2016 Google Inc. All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // Package app does all of the work necessary to create a Heapster
    16  // APIServer by binding together the Master Metrics API.
    17  // It can be configured and called directly or via the hyperkube framework.
    18  package app
    19  
    20  import (
    21  	"strings"
    22  	"time"
    23  
    24  	"github.com/golang/glog"
    25  	"github.com/pborman/uuid"
    26  	"github.com/spf13/cobra"
    27  	"github.com/spf13/pflag"
    28  
    29  	"k8s.io/heapster/metrics/options"
    30  	metricsink "k8s.io/heapster/metrics/sinks/metric"
    31  	"k8s.io/kubernetes/pkg/admission"
    32  	"k8s.io/kubernetes/pkg/api"
    33  	"k8s.io/kubernetes/pkg/api/unversioned"
    34  	"k8s.io/kubernetes/pkg/apiserver/authenticator"
    35  	"k8s.io/kubernetes/pkg/client/cache"
    36  	"k8s.io/kubernetes/pkg/controller/informers"
    37  	"k8s.io/kubernetes/pkg/genericapiserver"
    38  	genericauthorizer "k8s.io/kubernetes/pkg/genericapiserver/authorizer"
    39  	genericoptions "k8s.io/kubernetes/pkg/genericapiserver/options"
    40  	"k8s.io/kubernetes/pkg/registry/cachesize"
    41  )
    42  
    43  // NewAPIServerCommand creates a *cobra.Command object with default parameters
    44  func NewAPIServerCommand() *cobra.Command {
    45  	s := genericoptions.NewServerRunOptions()
    46  	s.AddUniversalFlags(pflag.CommandLine)
    47  	cmd := &cobra.Command{
    48  		Use:  "heapster-apiserver",
    49  		Long: `heapster apiserver`,
    50  		Run: func(cmd *cobra.Command, args []string) {
    51  		},
    52  	}
    53  
    54  	return cmd
    55  }
    56  
    57  type HeapsterAPIServer struct {
    58  	*genericapiserver.GenericAPIServer
    59  	options    *options.HeapsterRunOptions
    60  	metricSink *metricsink.MetricSink
    61  	nodeLister *cache.StoreToNodeLister
    62  }
    63  
    64  // Run runs the specified APIServer. This should never exit.
    65  func (h *HeapsterAPIServer) RunServer() error {
    66  	h.Run(h.options.ServerRunOptions)
    67  	return nil
    68  }
    69  
    70  func NewHeapsterApiServer(s *options.HeapsterRunOptions, metricSink *metricsink.MetricSink,
    71  	nodeLister *cache.StoreToNodeLister, podLister *cache.StoreToPodLister) (*HeapsterAPIServer, error) {
    72  
    73  	server, err := newAPIServer(s.ServerRunOptions)
    74  	if err != nil {
    75  		return &HeapsterAPIServer{}, err
    76  	}
    77  
    78  	installMetricsAPIs(s.ServerRunOptions, server, metricSink, nodeLister, podLister)
    79  
    80  	return &HeapsterAPIServer{
    81  		GenericAPIServer: server,
    82  		options:          s,
    83  		metricSink:       metricSink,
    84  		nodeLister:       nodeLister,
    85  	}, nil
    86  }
    87  
    88  func newAPIServer(s *genericoptions.ServerRunOptions) (*genericapiserver.GenericAPIServer, error) {
    89  	genericapiserver.DefaultAndValidateRunOptions(s)
    90  
    91  	resourceConfig := genericapiserver.NewResourceConfig()
    92  
    93  	storageGroupsToEncodingVersion, err := s.StorageGroupsToEncodingVersion()
    94  	if err != nil {
    95  		glog.Fatalf("error generating storage version map: %s", err)
    96  	}
    97  	storageFactory, err := genericapiserver.BuildDefaultStorageFactory(
    98  		s.StorageConfig, s.DefaultStorageMediaType, api.Codecs,
    99  		genericapiserver.NewDefaultResourceEncodingConfig(), storageGroupsToEncodingVersion,
   100  		[]unversioned.GroupVersionResource{}, resourceConfig, s.RuntimeConfig)
   101  	if err != nil {
   102  		glog.Fatalf("error in initializing storage factory: %s", err)
   103  	}
   104  
   105  	authn, err := authenticator.New(authenticator.AuthenticatorConfig{
   106  		BasicAuthFile:     s.BasicAuthFile,
   107  		ClientCAFile:      s.ClientCAFile,
   108  		TokenAuthFile:     s.TokenAuthFile,
   109  		OIDCIssuerURL:     s.OIDCIssuerURL,
   110  		OIDCClientID:      s.OIDCClientID,
   111  		OIDCCAFile:        s.OIDCCAFile,
   112  		OIDCUsernameClaim: s.OIDCUsernameClaim,
   113  		OIDCGroupsClaim:   s.OIDCGroupsClaim,
   114  		KeystoneURL:       s.KeystoneURL,
   115  	})
   116  	if err != nil {
   117  		glog.Fatalf("Invalid Authentication Config: %v", err)
   118  	}
   119  
   120  	authorizationModeNames := strings.Split(s.AuthorizationMode, ",")
   121  	authorizationConfig := genericauthorizer.AuthorizationConfig{
   122  		PolicyFile:                  s.AuthorizationPolicyFile,
   123  		WebhookConfigFile:           s.AuthorizationWebhookConfigFile,
   124  		WebhookCacheAuthorizedTTL:   s.AuthorizationWebhookCacheAuthorizedTTL,
   125  		WebhookCacheUnauthorizedTTL: s.AuthorizationWebhookCacheUnauthorizedTTL,
   126  		RBACSuperUser:               s.AuthorizationRBACSuperUser,
   127  	}
   128  	authorizer, err := genericauthorizer.NewAuthorizerFromAuthorizationConfig(authorizationModeNames, authorizationConfig)
   129  	if err != nil {
   130  		glog.Fatalf("Invalid Authorization Config: %v", err)
   131  	}
   132  
   133  	admissionControlPluginNames := strings.Split(s.AdmissionControl, ",")
   134  	privilegedLoopbackToken := uuid.NewRandom().String()
   135  
   136  	client, err := s.NewSelfClient(privilegedLoopbackToken)
   137  	if err != nil {
   138  		glog.Errorf("Failed to create clientset: %v", err)
   139  	}
   140  
   141  	sharedInformers := informers.NewSharedInformerFactory(client, 10*time.Minute)
   142  	pluginInitializer := admission.NewPluginInitializer(sharedInformers)
   143  
   144  	admissionController, err := admission.NewFromPlugins(client, admissionControlPluginNames, s.AdmissionControlConfigFile, pluginInitializer)
   145  	if err != nil {
   146  		glog.Errorf("Failed to create admission Controller: %v", err)
   147  	}
   148  
   149  	genericConfig := genericapiserver.NewConfig(s)
   150  	// TODO: Move the following to generic api server as well.
   151  	genericConfig.Authenticator = authn
   152  	genericConfig.SupportsBasicAuth = len(s.BasicAuthFile) > 0
   153  	genericConfig.Authorizer = authorizer
   154  	genericConfig.AdmissionControl = admissionController
   155  	genericConfig.APIResourceConfigSource = storageFactory.APIResourceConfigSource
   156  	genericConfig.MasterServiceNamespace = s.MasterServiceNamespace
   157  	genericConfig.Serializer = api.Codecs
   158  
   159  	// TODO: Move this to generic api server (Need to move the command line flag).
   160  	if s.EnableWatchCache {
   161  		cachesize.SetWatchCacheSizes(s.WatchCacheSizes)
   162  	}
   163  
   164  	return genericConfig.New()
   165  }