// ClientForVersion initializes or reuses a client for the specified version, or returns an
// error if that is not possible
func (c *ClientCache) ClientForVersion(version *unversioned.GroupVersion) (*client.Client, error) {
if version != nil {
if client, ok := c.clients[*version]; ok {
return client, nil
}
}
config, err := c.ClientConfigForVersion(version)
if err != nil {
return nil, err
}
kubeclient, err := client.New(config)
if err != nil {
return nil, err
}
c.clients[*config.GroupVersion] = kubeclient
// `version` does not necessarily equal `config.Version`. However, we know that if we call this method again with
// `version`, we should get a client based on the same config we just found. There's no guarantee that a client
// is copiable, so create a new client and save it in the cache.
if version != nil {
configCopy := *config
kubeclient, err := client.New(&configCopy)
if err != nil {
return nil, err
}
c.clients[*version] = kubeclient
}
return kubeclient, nil
}
func getKubeClient() (string, *kclient.Client, error) {
c, err := kclientcmd.LoadFromFile(*kubeConfig)
if err != nil {
return "", nil, fmt.Errorf("error loading kubeConfig: %v", err.Error())
}
if c.CurrentContext == "" || len(c.Clusters) == 0 {
return "", nil, fmt.Errorf("invalid kubeConfig: %+v", *c)
}
config, err := kclientcmd.NewDefaultClientConfig(
*c,
&kclientcmd.ConfigOverrides{
ClusterInfo: kclientcmdkapi.Cluster{
APIVersion: "v1",
},
}).ClientConfig()
if err != nil {
return "", nil, fmt.Errorf("error parsing kubeConfig: %v", err.Error())
}
kubeClient, err := kclient.New(config)
if err != nil {
return "", nil, fmt.Errorf("error creating client - %q", err)
}
return c.Clusters[c.CurrentContext].Server, kubeClient, nil
}
func main() {
clientConfig := kubectl_util.DefaultClientConfig(flags)
flags.Parse(os.Args)
cfg := parseCfg(*config, *lbDefAlgorithm)
var kubeClient *unversioned.Client
var err error
defErrorPage := newStaticPageHandler(*errorPage, defaultErrorPage)
if defErrorPage == nil {
glog.Fatalf("Failed to load the default error page")
}
go registerHandlers(defErrorPage)
var tcpSvcs map[string]int
if *tcpServices != "" {
tcpSvcs = parseTCPServices(*tcpServices)
} else {
glog.Infof("No tcp/https services specified")
}
if *startSyslog {
cfg.startSyslog = true
_, err = newSyslogServer("/var/run/haproxy.log.socket")
if err != nil {
glog.Fatalf("Failed to start syslog server: %v", err)
}
}
if *cluster {
if kubeClient, err = unversioned.NewInCluster(); err != nil {
glog.Fatalf("Failed to create client: %v", err)
}
} else {
config, err := clientConfig.ClientConfig()
if err != nil {
glog.Fatalf("error connecting to the client: %v", err)
}
kubeClient, err = unversioned.New(config)
}
namespace, specified, err := clientConfig.Namespace()
if err != nil {
glog.Fatalf("unexpected error: %v", err)
}
if !specified {
namespace = api.NamespaceAll
}
// TODO: Handle multiple namespaces
lbc := newLoadBalancerController(cfg, kubeClient, namespace, tcpSvcs)
go lbc.epController.Run(util.NeverStop)
go lbc.svcController.Run(util.NeverStop)
if *dry {
dryRun(lbc)
} else {
lbc.cfg.reload()
util.Until(lbc.worker, time.Second, util.NeverStop)
}
}
// Run runs the specified KubeletExecutorServer.
func (s *KubeletExecutorServer) Run(hks hyperkube.Interface, _ []string) error {
// create shared channels
kubeletFinished := make(chan struct{})
execUpdates := make(chan kubetypes.PodUpdate, 1)
nodeInfos := make(chan executor.NodeInfo, 1)
// create static pods directory
staticPodsConfigPath := filepath.Join(s.RootDirectory, "static-pods")
err := os.Mkdir(staticPodsConfigPath, 0750)
if err != nil {
return err
}
// create apiserver client
var apiclient *client.Client
clientConfig, err := s.CreateAPIServerClientConfig()
if err == nil {
apiclient, err = client.New(clientConfig)
}
if err != nil {
// required for k8sm since we need to send api.Binding information back to the apiserver
return fmt.Errorf("cannot create API client: %v", err)
}
// start executor
err = s.runExecutor(execUpdates, nodeInfos, kubeletFinished, staticPodsConfigPath, apiclient)
if err != nil {
return err
}
// start kubelet, blocking
return s.runKubelet(execUpdates, nodeInfos, kubeletFinished, staticPodsConfigPath, apiclient)
}
func GetScopedClientForUser(adminClient *client.Client, clientConfig restclient.Config, username string, scopes []string) (*client.Client, *kclient.Client, *restclient.Config, error) {
// make sure the user exists
if _, _, _, err := GetClientForUser(clientConfig, username); err != nil {
return nil, nil, nil, err
}
user, err := adminClient.Users().Get(username)
if err != nil {
return nil, nil, nil, err
}
token := &oauthapi.OAuthAccessToken{
ObjectMeta: kapi.ObjectMeta{Name: fmt.Sprintf("%s-token-plus-some-padding-here-to-make-the-limit-%d", username, rand.Int())},
ClientName: origin.OpenShiftCLIClientID,
ExpiresIn: 86400,
Scopes: scopes,
RedirectURI: "https://127.0.0.1:12000/oauth/token/implicit",
UserName: user.Name,
UserUID: string(user.UID),
}
if _, err := adminClient.OAuthAccessTokens().Create(token); err != nil {
return nil, nil, nil, err
}
scopedConfig := clientcmd.AnonymousClientConfig(&clientConfig)
scopedConfig.BearerToken = token.Name
kubeClient, err := kclient.New(&scopedConfig)
if err != nil {
return nil, nil, nil, err
}
osClient, err := client.New(&scopedConfig)
if err != nil {
return nil, nil, nil, err
}
return osClient, kubeClient, &scopedConfig, nil
}
// Creates new Kubernetes Apiserver client. When apiserverHost param is empty string the function
// assumes that it is running inside a Kubernetes cluster and attempts to discover the Apiserver.
// Otherwise, it connects to the Apiserver specified.
//
// apiserverHost param is in the format of protocol://address:port/pathPrefix, e.g.,
// http://localhost:8001.
//
// Returns created client and its configuration.
func CreateApiserverClient(apiserverHost string) (*client.Client, clientcmd.ClientConfig, error) {
overrides := &clientcmd.ConfigOverrides{}
if apiserverHost != "" {
overrides.ClusterInfo = clientcmdapi.Cluster{Server: apiserverHost}
}
clientConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
&clientcmd.ClientConfigLoadingRules{}, overrides)
cfg, err := clientConfig.ClientConfig()
if err != nil {
return nil, nil, err
}
log.Printf("Creating API server client for %s", cfg.Host)
client, err := client.New(cfg)
if err != nil {
return nil, nil, err
}
return client, clientConfig, nil
}
func newKubeClient() (*kclient.Client, error) {
var (
config *restclient.Config
err error
masterURL string
)
*argKubecfgFile = os.Getenv("KUBE_CFG_FILE")
logrus.Print("kubeconfig: ", argKubecfgFile)
if *argKubeMasterURL != "" {
masterURL, err = expandKubeMasterURL()
if err != nil {
return nil, err
}
}
if masterURL != "" && *argKubecfgFile == "" {
config = &restclient.Config{
Host: masterURL,
}
} else {
overrides := &kclientcmd.ConfigOverrides{}
overrides.ClusterInfo.Server = masterURL
rules := &kclientcmd.ClientConfigLoadingRules{ExplicitPath: *argKubecfgFile}
if config, err = kclientcmd.NewNonInteractiveDeferredLoadingClientConfig(rules, overrides).ClientConfig(); err != nil {
return nil, err
}
}
logrus.Print("Using ", config.Host, " for kubernetes master")
return kclient.New(config)
}
// NewCluster returns a usable cluster. Host should be of the form
// "http://hostname:8080".
func NewCluster(config *restclient.Config, kubectl string, logger log.Logger) (*Cluster, error) {
client, err := k8sclient.New(config)
if err != nil {
return nil, err
}
extclient, err := k8sclient.NewExtensions(config)
if err != nil {
return nil, err
}
if kubectl == "" {
kubectl, err = exec.LookPath("kubectl")
if err != nil {
return nil, err
}
} else {
if _, err := os.Stat(kubectl); err != nil {
return nil, err
}
}
logger.Log("kubectl", kubectl)
c := &Cluster{
config: config,
client: extendedClient{client, extclient},
kubectl: kubectl,
status: newStatusMap(),
actionc: make(chan func()),
logger: logger,
}
go c.loop()
return c, nil
}
func (m *NetworkManager) init(args []string) {
configFile := m.parseConfig()
defer func() {
if configFile != nil {
configFile.Close()
}
}()
loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
if m.config.KubeConfig != "" {
loadingRules.ExplicitPath = m.config.KubeConfig
}
configOverrides := &clientcmd.ConfigOverrides{}
if m.config.KubeUrl != "" {
configOverrides.ClusterInfo.Server = m.config.KubeUrl
}
kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
config, err := kubeConfig.ClientConfig()
if err != nil {
glog.Fatal(err)
}
m.Client, err = client.New(config)
if err != nil {
glog.Fatalf("Invalid API configuratin: %v", err)
}
m.Controller = network.NewNetworkFactory().Create(m.Client, args)
m.Controller.Init(&m.config, configFile)
}
func (p *kubernetesProvisioner) AddNode(opts provision.AddNodeOptions) error {
coll, err := nodeAddrCollection()
if err != nil {
return err
}
defer coll.Close()
token, err := config.GetString("kubernetes:token")
if err != nil {
return err
}
_, err = client.New(&restclient.Config{
Host: opts.Address,
Insecure: true,
BearerToken: token,
})
if err != nil {
return err
}
addrs := []string{opts.Address}
_, err = coll.UpsertId(uniqueDocumentID, bson.M{"$set": bson.M{"addresses": addrs}})
if err != nil {
return errors.WithStack(err)
}
return nil
}
/**
Initialize a kubernetes API client
*/
func newKubeClient(apiserverURLString string) (*kubeClient.Client, error) {
var u *url.URL
var err error
if u, err = url.Parse(os.ExpandEnv(apiserverURLString)); err != nil {
return nil, fmt.Errorf("Could not parse Kubernetes apiserver URL: %v. Error: %v", apiserverURLString, err)
}
if u.Scheme == "" || u.Host == "" || u.Host == ":" || u.Path != "" {
return nil, fmt.Errorf("Invalid URL provided for Kubernetes API server: %v.", u)
}
loadingRules := kubeClientCmd.NewDefaultClientConfigLoadingRules()
configOverrides := &kubeClientCmd.ConfigOverrides{}
kubeConfig := kubeClientCmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
config, err := kubeConfig.ClientConfig()
if err != nil {
return nil, err
}
config.Host = apiserverURLString
config.Version = "v1"
log.WithFields(log.Fields{"host": config.Host, "apiVersion": config.Version}).Debug("Creating kubernetes API client")
return kubeClient.New(config)
}
func (k8scc *K8sClientConfig) UnversionedClient() *unversioned.Client {
config := clientcmdapi.NewConfig()
config.Clusters[k8scc.ClusterID] = &clientcmdapi.Cluster{
InsecureSkipTLSVerify: k8scc.InsecureSkipTLSVerify,
Server: k8scc.Server,
CertificateAuthority: k8scc.CertificateAuthority,
CertificateAuthorityData: k8scc.CertificateAuthorityData,
}
config.AuthInfos[k8scc.ClusterID] = &clientcmdapi.AuthInfo{
ClientCertificate: k8scc.ClientCertificate,
ClientKey: k8scc.ClientKey,
ClientCertificateData: k8scc.ClientCertificateData,
ClientKeyData: k8scc.ClientKeyData,
}
config.Contexts[k8scc.ClusterID] = &clientcmdapi.Context{
Cluster: k8scc.ClusterID,
AuthInfo: k8scc.ClusterID,
}
config.CurrentContext = k8scc.ClusterID
clientBuilder := clientcmd.NewNonInteractiveClientConfig(*config, k8scc.ClusterID, &clientcmd.ConfigOverrides{})
clientConfig, err := clientBuilder.ClientConfig()
if err != nil {
log.Fatalf("Unexpected error: %v", err)
}
client, err := unversioned.New(clientConfig)
if err != nil {
log.Fatalf("Unexpected error: %v", err)
}
return client
}
// Clients returns an OpenShift and Kubernetes client with the credentials of the named service account
// TODO: change return types to client.Interface/kclient.Interface to allow auto-reloading credentials
func Clients(config restclient.Config, tokenRetriever TokenRetriever, namespace, name string) (*restclient.Config, *client.Client, *kclient.Client, error) {
// Clear existing auth info
config.Username = ""
config.Password = ""
config.CertFile = ""
config.CertData = []byte{}
config.KeyFile = ""
config.KeyData = []byte{}
config.BearerToken = ""
if len(config.UserAgent) > 0 {
config.UserAgent += " "
}
config.UserAgent += fmt.Sprintf("system:serviceaccount:%s:%s", namespace, name)
// For now, just initialize the token once
// TODO: refetch the token if the client encounters 401 errors
token, err := tokenRetriever.GetToken(namespace, name)
if err != nil {
return nil, nil, nil, err
}
config.BearerToken = token
c, err := client.New(&config)
if err != nil {
return nil, nil, nil, err
}
kc, err := kclient.New(&config)
if err != nil {
return nil, nil, nil, err
}
return &config, c, kc, nil
}
func main() {
config := HollowNodeConfig{}
config.addFlags(pflag.CommandLine)
flag.InitFlags()
if !knownMorphs.Has(config.Morph) {
glog.Fatalf("Unknown morph: %v. Allowed values: %v", config.Morph, knownMorphs.List())
}
// create a client to communicate with API server.
clientConfig, err := config.createClientConfigFromFile()
if err != nil {
glog.Fatalf("Failed to create a ClientConfig: %v. Exiting.", err)
}
cl, err := client.New(clientConfig)
if err != nil {
glog.Fatalf("Failed to create a Client: %v. Exiting.", err)
}
clientset, err := internalclientset.NewForConfig(clientConfig)
if err != nil {
glog.Fatalf("Failed to create a ClientSet: %v. Exiting.", err)
}
if config.Morph == "kubelet" {
cadvisorInterface := new(cadvisortest.Fake)
containerManager := cm.NewStubContainerManager()
fakeDockerClient := dockertools.NewFakeDockerClient()
fakeDockerClient.EnableSleep = true
hollowKubelet := kubemark.NewHollowKubelet(
config.NodeName,
clientset,
cadvisorInterface,
fakeDockerClient,
config.KubeletPort,
config.KubeletReadOnlyPort,
containerManager,
maxPods,
podsPerCore,
)
hollowKubelet.Run()
}
if config.Morph == "proxy" {
eventBroadcaster := record.NewBroadcaster()
recorder := eventBroadcaster.NewRecorder(api.EventSource{Component: "kube-proxy", Host: config.NodeName})
iptInterface := fakeiptables.NewFake()
serviceConfig := proxyconfig.NewServiceConfig()
serviceConfig.RegisterHandler(&kubemark.FakeProxyHandler{})
endpointsConfig := proxyconfig.NewEndpointsConfig()
endpointsConfig.RegisterHandler(&kubemark.FakeProxyHandler{})
hollowProxy := kubemark.NewHollowProxyOrDie(config.NodeName, cl, endpointsConfig, serviceConfig, iptInterface, eventBroadcaster, recorder)
hollowProxy.Run()
}
}
func GetClientForUser(clientConfig kclient.Config, username string) (*client.Client, *kclient.Client, *kclient.Config, error) {
token, err := tokencmd.RequestToken(&clientConfig, nil, username, "password")
if err != nil {
return nil, nil, nil, err
}
userClientConfig := clientConfig
userClientConfig.BearerToken = token
userClientConfig.Username = ""
userClientConfig.Password = ""
userClientConfig.TLSClientConfig.CertFile = ""
userClientConfig.TLSClientConfig.KeyFile = ""
userClientConfig.TLSClientConfig.CertData = nil
userClientConfig.TLSClientConfig.KeyData = nil
kubeClient, err := kclient.New(&userClientConfig)
if err != nil {
return nil, nil, nil, err
}
osClient, err := client.New(&userClientConfig)
if err != nil {
return nil, nil, nil, err
}
return osClient, kubeClient, &userClientConfig, nil
}
// Complete verifies command line arguments and loads data from the command environment
func (app *App) Complete(clientConfig clientcmd.ClientConfig) error {
p := app.ExecOptions
// Let kubectl exec follow rules for `--`, see #13004 issue
if len(p.PodName) == 0 {
return fmt.Errorf("POD is required for exec")
}
if len(p.Command) < 1 {
return fmt.Errorf("COMMAND is required for exec")
}
if clientConfig == nil {
return fmt.Errorf("kubeconfig is required for exec")
}
namespace, _, err := clientConfig.Namespace() //f.DefaultNamespace()
if err != nil {
return err
}
p.Namespace = namespace
config, err := clientConfig.ClientConfig() //f.ClientConfig()
if err != nil {
return err
}
p.Config = config
client, err := kclient.New(config) //f.Client()
if err != nil {
return err
}
p.Client = client
return nil
}
// NewClient returns a usable Client. Don't forget to Stop it.
func NewClient(addr string, resyncPeriod time.Duration) (Client, error) {
c, err := unversioned.New(&unversioned.Config{Host: addr})
if err != nil {
return nil, err
}
podListWatch := cache.NewListWatchFromClient(c, "pods", api.NamespaceAll, fields.Everything())
podStore := cache.NewStore(cache.MetaNamespaceKeyFunc)
podReflector := cache.NewReflector(podListWatch, &api.Pod{}, podStore, resyncPeriod)
serviceListWatch := cache.NewListWatchFromClient(c, "services", api.NamespaceAll, fields.Everything())
serviceStore := cache.NewStore(cache.MetaNamespaceKeyFunc)
serviceReflector := cache.NewReflector(serviceListWatch, &api.Service{}, serviceStore, resyncPeriod)
quit := make(chan struct{})
podReflector.RunUntil(quit)
serviceReflector.RunUntil(quit)
return &client{
quit: quit,
client: c,
podReflector: podReflector,
podStore: &cache.StoreToPodLister{Store: podStore},
serviceReflector: serviceReflector,
serviceStore: &cache.StoreToServiceLister{Store: serviceStore},
}, nil
}
// negotiateVersion queries the server's supported api versions to find a version that both client and server support.
// - If no version is provided, try registered client versions in order of preference.
// - If version is provided, but not default config (explicitly requested via
// commandline flag), and is unsupported by the server, print a warning to
// stderr and try client's registered versions in order of preference.
// - If version is config default, and the server does not support it, return an error.
func negotiateVersion(client *kclient.Client, config *restclient.Config, requestedGV *unversioned.GroupVersion, clientGVs []unversioned.GroupVersion) (*unversioned.GroupVersion, error) {
// Ensure we have a client
var err error
if client == nil {
client, err = kclient.New(config)
if err != nil {
return nil, err
}
}
// Get server versions
serverGVs, err := serverAPIVersions(client, "/oapi")
if err != nil {
return nil, err
}
// Determine our preferred version
preferredGV := copyGroupVersion(requestedGV)
if preferredGV == nil {
preferredGV = copyGroupVersion(config.GroupVersion)
}
// Find a version we can all agree on
matchedGV, err := matchAPIVersion(preferredGV, clientGVs, serverGVs)
if err != nil {
return nil, err
}
// Enforce a match if the preferredGV is the config default
if config.GroupVersion != nil && (*preferredGV == *config.GroupVersion) && (*matchedGV != *config.GroupVersion) {
return nil, fmt.Errorf("server does not support API version %q", config.GroupVersion.String())
}
return matchedGV, err
}
// Clients returns an OpenShift and Kubernetes client with the credentials of the named service account
// TODO: change return types to client.Interface/kclient.Interface to allow auto-reloading credentials
func Clients(config kclient.Config, tokenRetriever TokenRetriever, namespace, name string) (*client.Client, *kclient.Client, error) {
// Clear existing auth info
config.Username = ""
config.Password = ""
config.CertFile = ""
config.CertData = []byte{}
config.KeyFile = ""
config.KeyData = []byte{}
// For now, just initialize the token once
// TODO: refetch the token if the client encounters 401 errors
token, err := tokenRetriever.GetToken(namespace, name)
if err != nil {
return nil, nil, err
}
config.BearerToken = token
c, err := client.New(&config)
if err != nil {
return nil, nil, err
}
kc, err := kclient.New(&config)
if err != nil {
return nil, nil, err
}
return c, kc, nil
}
// TODO(jdef): hacked from kubelet/server/server.go
// TODO(k8s): replace this with clientcmd
func (s *SchedulerServer) createAPIServerClient() (*client.Client, error) {
authInfo, err := clientauth.LoadFromFile(s.AuthPath)
if err != nil {
log.Warningf("Could not load kubernetes auth path: %v. Continuing with defaults.", err)
}
if authInfo == nil {
// authInfo didn't load correctly - continue with defaults.
authInfo = &clientauth.Info{}
}
clientConfig, err := authInfo.MergeWithConfig(client.Config{})
if err != nil {
return nil, err
}
if len(s.APIServerList) < 1 {
return nil, fmt.Errorf("no api servers specified")
}
// TODO: adapt Kube client to support LB over several servers
if len(s.APIServerList) > 1 {
log.Infof("Multiple api servers specified. Picking first one")
}
clientConfig.Host = s.APIServerList[0]
c, err := client.New(&clientConfig)
if err != nil {
return nil, err
}
return c, nil
}
func runTest(cmd *cobra.Command, args []string) error {
if localProxy == "" {
return fmt.Errorf("please set env variable LOCAL_PROXY. ex: LOCAL_PROXY=\"http://localhost:8080\". Setup proxy as \"kubectl proxy --port 8080 &\" ")
}
config := &client.Config{
Host: localProxy,
Insecure: true,
}
cli, err := client.New(config)
if err != nil {
return fmt.Errorf("unable to connect k8s api server: %v", err)
}
labelSelector, err := labels.Parse(influxSelectors)
if err != nil {
return fmt.Errorf("unable to parse labels: %v", err)
}
fieldSelector := fields.Everything()
if podIPs, err := podIps(cli, labelSelector, fieldSelector); err != nil {
return err
} else {
hostIP, _ := externalIP()
peers := influxdbPeers(hostIP, podIPs)
iOpts := influxdOpts(hostIP, peers)
fmt.Println("Content of /etc/default/influxdb : ", iOpts)
}
return nil
}
func main() {
var kubeClient *unversioned.Client
flags.AddGoFlagSet(flag.CommandLine)
flags.Parse(os.Args)
clientConfig := kubectl_util.DefaultClientConfig(flags)
glog.Infof("Using build: %v - %v", gitRepo, version)
if *buildCfg {
fmt.Printf("Example of ConfigMap to customize NGINX configuration:\n%v", nginx.ConfigMapAsString())
os.Exit(0)
}
if *defaultSvc == "" {
glog.Fatalf("Please specify --default-backend-service")
}
var err error
if *inCluster {
kubeClient, err = unversioned.NewInCluster()
} else {
config, connErr := clientConfig.ClientConfig()
if connErr != nil {
glog.Fatalf("error connecting to the client: %v", err)
}
kubeClient, err = unversioned.New(config)
}
if err != nil {
glog.Fatalf("failed to create client: %v", err)
}
runtimePodInfo := &podInfo{NodeIP: "127.0.0.1"}
if *inCluster {
runtimePodInfo, err = getPodDetails(kubeClient)
if err != nil {
glog.Fatalf("unexpected error getting runtime information: %v", err)
}
}
if err := isValidService(kubeClient, *defaultSvc); err != nil {
glog.Fatalf("no service with name %v found: %v", *defaultSvc, err)
}
glog.Infof("Validated %v as the default backend", *defaultSvc)
lbc, err := newLoadBalancerController(kubeClient, *resyncPeriod, *defaultSvc, *watchNamespace, *nxgConfigMap, *tcpConfigMapName, *udpConfigMapName, runtimePodInfo)
if err != nil {
glog.Fatalf("%v", err)
}
go registerHandlers(lbc)
go handleSigterm(lbc)
lbc.Run()
for {
glog.Infof("Handled quit, awaiting pod deletion")
time.Sleep(30 * time.Second)
}
}
func main() {
flag.Parse()
var err error
var clone cloner
sourceConfig := &kclient.Config{
Host: *argSourceUrl,
Version: "v1",
}
sinkConfig := &kclient.Config{
Host: *argSinkUrl,
Version: "v1",
}
clone.source, err = kclient.New(sourceConfig)
if err != nil {
return
}
clone.sink, err = kclient.New(sinkConfig)
if err != nil {
return
}
if *argNamespace != "" {
CloneNamespace(&clone, *argNamespace)
} else {
ns, err := clone.source.Namespaces().List(labels.Everything(), fields.Everything())
if err != nil {
glog.Fatal("Unable to list all namespaces")
}
for _, item := range ns.Items {
CloneNamespace(&clone, item.ObjectMeta.Name)
}
//Doing system directly since it is not returned in the enum
CloneNamespace(&clone, "kube-system")
}
glog.Info("Clonned")
}
func clientForUserAgentOrDie(config client.Config, userAgent string) *client.Client {
fullUserAgent := client.DefaultKubernetesUserAgent() + "/" + userAgent
config.UserAgent = fullUserAgent
kubeClient, err := client.New(&config)
if err != nil {
glog.Fatalf("Invalid API configuration: %v", err)
}
return kubeClient
}
func main() {
flags.AddGoFlagSet(flag.CommandLine)
flags.Parse(os.Args)
clientConfig := kubectl_util.DefaultClientConfig(flags)
glog.Infof("Using build: %v - %v", gitRepo, version)
if *defaultSvc == "" {
glog.Fatalf("Please specify --default-backend-service")
}
kubeClient, err := unversioned.NewInCluster()
if err != nil {
config, err := clientConfig.ClientConfig()
if err != nil {
glog.Fatalf("error configuring the client: %v", err)
}
kubeClient, err = unversioned.New(config)
if err != nil {
glog.Fatalf("failed to create client: %v", err)
}
}
runtimePodInfo, err := getPodDetails(kubeClient)
if err != nil {
runtimePodInfo = &podInfo{NodeIP: "127.0.0.1"}
glog.Warningf("unexpected error getting runtime information: %v", err)
}
if err := isValidService(kubeClient, *defaultSvc); err != nil {
glog.Fatalf("no service with name %v found: %v", *defaultSvc, err)
}
glog.Infof("Validated %v as the default backend", *defaultSvc)
if *nxgConfigMap != "" {
_, _, err = parseNsName(*nxgConfigMap)
if err != nil {
glog.Fatalf("configmap error: %v", err)
}
}
lbc, err := newLoadBalancerController(kubeClient, *resyncPeriod,
*defaultSvc, *watchNamespace, *nxgConfigMap, *tcpConfigMapName,
*udpConfigMapName, *defSSLCertificate, *defHealthzURL, runtimePodInfo)
if err != nil {
glog.Fatalf("%v", err)
}
go registerHandlers(lbc)
go handleSigterm(lbc)
lbc.Run()
for {
glog.Infof("Handled quit, awaiting pod deletion")
time.Sleep(30 * time.Second)
}
}
// RunScheduledJobController starts the Kubernetes scheduled job controller sync loop
func (c *MasterConfig) RunScheduledJobController(config *restclient.Config) {
// TODO: this is a temp fix for allowing kubeClient list v2alpha1 jobs, should switch to using clientset
config.ContentConfig.GroupVersion = &unversioned.GroupVersion{Group: batch.GroupName, Version: "v2alpha1"}
client, err := kclient.New(config)
if err != nil {
glog.Fatalf("Unable to configure scheduled job controller: %v", err)
}
go scheduledjob.NewScheduledJobController(client).Run(utilwait.NeverStop)
}
func main() {
clientConfig := kubectl_util.DefaultClientConfig(flags)
flags.Parse(os.Args)
var err error
var kubeClient *unversioned.Client
if *cluster {
if kubeClient, err = unversioned.NewInCluster(); err != nil {
glog.Fatalf("Failed to create client: %v", err)
}
} else {
config, err := clientConfig.ClientConfig()
if err != nil {
glog.Fatalf("error connecting to the client: %v", err)
}
kubeClient, err = unversioned.New(config)
}
namespace, specified, err := clientConfig.Namespace()
if err != nil {
glog.Fatalf("unexpected error: %v", err)
}
if !specified {
namespace = ""
}
err = loadIPVModule()
if err != nil {
glog.Fatalf("Terminating execution: %v", err)
}
err = changeSysctl()
if err != nil {
glog.Fatalf("Terminating execution: %v", err)
}
err = resetIPVS()
if err != nil {
glog.Fatalf("Terminating execution: %v", err)
}
glog.Info("starting LVS configuration")
if *useUnicast {
glog.Info("keepalived will use unicast to sync the nodes")
}
ipvsc := newIPVSController(kubeClient, namespace, *useUnicast, *password)
go ipvsc.epController.Run(wait.NeverStop)
go ipvsc.svcController.Run(wait.NeverStop)
go wait.Until(ipvsc.worker, time.Second, wait.NeverStop)
time.Sleep(5 * time.Second)
glog.Info("starting keepalived to announce VIPs")
ipvsc.keepalived.Start()
}
// Run runs the specified SchedulerServer. This should never exit.
func (s *SchedulerServer) Run(_ []string) error {
if s.Kubeconfig == "" && s.Master == "" {
glog.Warningf("Neither --kubeconfig nor --master was specified. Using default API client. This might not work.")
}
// This creates a client, first loading any specified kubeconfig
// file, and then overriding the Master flag, if non-empty.
kubeconfig, err := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
&clientcmd.ClientConfigLoadingRules{ExplicitPath: s.Kubeconfig},
&clientcmd.ConfigOverrides{ClusterInfo: clientcmdapi.Cluster{Server: s.Master}}).ClientConfig()
if err != nil {
return err
}
// Override kubeconfig qps/burst settings from flags
kubeconfig.QPS = s.KubeAPIQPS
kubeconfig.Burst = s.KubeAPIBurst
kubeClient, err := client.New(kubeconfig)
if err != nil {
glog.Fatalf("Invalid API configuration: %v", err)
}
go func() {
mux := http.NewServeMux()
healthz.InstallHandler(mux)
if s.EnableProfiling {
mux.HandleFunc("/debug/pprof/", pprof.Index)
mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
}
mux.Handle("/metrics", prometheus.Handler())
server := &http.Server{
Addr: net.JoinHostPort(s.Address.String(), strconv.Itoa(s.Port)),
Handler: mux,
}
glog.Fatal(server.ListenAndServe())
}()
configFactory := factory.NewConfigFactory(kubeClient, util.NewTokenBucketRateLimiter(s.BindPodsQPS, s.BindPodsBurst))
config, err := s.createConfig(configFactory)
if err != nil {
glog.Fatalf("Failed to create scheduler configuration: %v", err)
}
eventBroadcaster := record.NewBroadcaster()
config.Recorder = eventBroadcaster.NewRecorder(api.EventSource{Component: "scheduler"})
eventBroadcaster.StartLogging(glog.Infof)
eventBroadcaster.StartRecordingToSink(kubeClient.Events(""))
sched := scheduler.New(config)
sched.Run()
select {}
}
func kubeClient() *kubeclient.Client {
config := &kuberest.Config{
Host: "http://localhost:8080", // TODO: Make configurable
}
client, err := kubeclient.New(config)
if err != nil {
panic(err)
}
return client
}
func getKubernetesClient() (*unversioned.Client, error) {
loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
configOverrides := &clientcmd.ConfigOverrides{}
kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, configOverrides)
config, err := kubeConfig.ClientConfig()
if err != nil {
return nil, fmt.Errorf("Error creating kubeConfig: %s", err)
}
return unversioned.New(config)
}