completion.go

Documentation: k8s.io/kubernetes/cmd/kube-apiserver/app/options

     1  /*
     2  Copyright 2014 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package options
    18  
    19  import (
    20  	"fmt"
    21  	"net"
    22  	"strings"
    23  
    24  	apiserveroptions "k8s.io/apiserver/pkg/server/options"
    25  	_ "k8s.io/component-base/metrics/prometheus/workqueue"
    26  	netutils "k8s.io/utils/net"
    27  
    28  	controlplane "k8s.io/kubernetes/pkg/controlplane/apiserver/options"
    29  	"k8s.io/kubernetes/pkg/kubeapiserver"
    30  	kubeoptions "k8s.io/kubernetes/pkg/kubeapiserver/options"
    31  )
    32  
    33  // completedOptions is a private wrapper that enforces a call of Complete() before Run can be invoked.
    34  type completedOptions struct {
    35  	controlplane.CompletedOptions
    36  	CloudProvider *kubeoptions.CloudProviderOptions
    37  
    38  	Extra
    39  }
    40  
    41  type CompletedOptions struct {
    42  	// Embed a private pointer that cannot be instantiated outside of this package.
    43  	*completedOptions
    44  }
    45  
    46  // Complete set default ServerRunOptions.
    47  // Should be called after kube-apiserver flags parsed.
    48  func (opts *ServerRunOptions) Complete() (CompletedOptions, error) {
    49  	if opts == nil {
    50  		return CompletedOptions{completedOptions: &completedOptions{}}, nil
    51  	}
    52  
    53  	// process opts.ServiceClusterIPRange from list to Primary and Secondary
    54  	// we process secondary only if provided by user
    55  	apiServerServiceIP, primaryServiceIPRange, secondaryServiceIPRange, err := getServiceIPAndRanges(opts.ServiceClusterIPRanges)
    56  	if err != nil {
    57  		return CompletedOptions{}, err
    58  	}
    59  	controlplane, err := opts.Options.Complete([]string{"kubernetes.default.svc", "kubernetes.default", "kubernetes"}, []net.IP{apiServerServiceIP})
    60  	if err != nil {
    61  		return CompletedOptions{}, err
    62  	}
    63  
    64  	completed := completedOptions{
    65  		CompletedOptions: controlplane,
    66  		CloudProvider:    opts.CloudProvider,
    67  
    68  		Extra: opts.Extra,
    69  	}
    70  
    71  	completed.PrimaryServiceClusterIPRange = primaryServiceIPRange
    72  	completed.SecondaryServiceClusterIPRange = secondaryServiceIPRange
    73  	completed.APIServerServiceIP = apiServerServiceIP
    74  
    75  	if completed.Etcd != nil && completed.Etcd.EnableWatchCache {
    76  		sizes := kubeapiserver.DefaultWatchCacheSizes()
    77  		// Ensure that overrides parse correctly.
    78  		userSpecified, err := apiserveroptions.ParseWatchCacheSizes(completed.Etcd.WatchCacheSizes)
    79  		if err != nil {
    80  			return CompletedOptions{}, err
    81  		}
    82  		for resource, size := range userSpecified {
    83  			sizes[resource] = size
    84  		}
    85  		completed.Etcd.WatchCacheSizes, err = apiserveroptions.WriteWatchCacheSizes(sizes)
    86  		if err != nil {
    87  			return CompletedOptions{}, err
    88  		}
    89  	}
    90  
    91  	return CompletedOptions{
    92  		completedOptions: &completed,
    93  	}, nil
    94  }
    95  
    96  func getServiceIPAndRanges(serviceClusterIPRanges string) (net.IP, net.IPNet, net.IPNet, error) {
    97  	serviceClusterIPRangeList := []string{}
    98  	if serviceClusterIPRanges != "" {
    99  		serviceClusterIPRangeList = strings.Split(serviceClusterIPRanges, ",")
   100  	}
   101  
   102  	var apiServerServiceIP net.IP
   103  	var primaryServiceIPRange net.IPNet
   104  	var secondaryServiceIPRange net.IPNet
   105  	var err error
   106  	// nothing provided by user, use default range (only applies to the Primary)
   107  	if len(serviceClusterIPRangeList) == 0 {
   108  		var primaryServiceClusterCIDR net.IPNet
   109  		primaryServiceIPRange, apiServerServiceIP, err = controlplane.ServiceIPRange(primaryServiceClusterCIDR)
   110  		if err != nil {
   111  			return net.IP{}, net.IPNet{}, net.IPNet{}, fmt.Errorf("error determining service IP ranges: %v", err)
   112  		}
   113  		return apiServerServiceIP, primaryServiceIPRange, net.IPNet{}, nil
   114  	}
   115  
   116  	_, primaryServiceClusterCIDR, err := netutils.ParseCIDRSloppy(serviceClusterIPRangeList[0])
   117  	if err != nil {
   118  		return net.IP{}, net.IPNet{}, net.IPNet{}, fmt.Errorf("service-cluster-ip-range[0] is not a valid cidr")
   119  	}
   120  
   121  	primaryServiceIPRange, apiServerServiceIP, err = controlplane.ServiceIPRange(*primaryServiceClusterCIDR)
   122  	if err != nil {
   123  		return net.IP{}, net.IPNet{}, net.IPNet{}, fmt.Errorf("error determining service IP ranges for primary service cidr: %v", err)
   124  	}
   125  
   126  	// user provided at least two entries
   127  	// note: validation asserts that the list is max of two dual stack entries
   128  	if len(serviceClusterIPRangeList) > 1 {
   129  		_, secondaryServiceClusterCIDR, err := netutils.ParseCIDRSloppy(serviceClusterIPRangeList[1])
   130  		if err != nil {
   131  			return net.IP{}, net.IPNet{}, net.IPNet{}, fmt.Errorf("service-cluster-ip-range[1] is not an ip net")
   132  		}
   133  		secondaryServiceIPRange = *secondaryServiceClusterCIDR
   134  	}
   135  	return apiServerServiceIP, primaryServiceIPRange, secondaryServiceIPRange, nil
   136  }
   137
View as plain text