Refactor CLI initialization (#562)

This cleans up the CLI code significantly.
Also makes some of this re-usable for providers who want to do so.

This also removes the main.go from the top of the tree of the repro,
instead moving it into cmd/virtual-kubelet.
This allows us to better utilize the package namespace (and e.g. mv the
`vkubelet` package to the top of the tree).

virtual-kubelet/commands/providers/provider.go

@@ -0,0 +1,54 @@
+// Copyright © 2017 The virtual-kubelet 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 providers
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/virtual-kubelet/virtual-kubelet/providers/register"
+)
+
+// NewCommand creates a new providers subcommand
+// This subcommand is used to determine which providers are registered.
+func NewCommand() *cobra.Command {
+	return &cobra.Command{
+		Use:   "providers",
+		Short: "Show the list of supported providers",
+		Long:  "Show the list of supported providers",
+		Args:  cobra.MaximumNArgs(2),
+		Run: func(cmd *cobra.Command, args []string) {
+			switch len(args) {
+			case 0:
+				ls := register.List()
+				for _, p := range ls {
+					fmt.Fprintln(cmd.OutOrStdout(), p)
+				}
+			case 1:
+				if !register.Exists(args[0]) {
+					fmt.Fprintln(cmd.OutOrStderr(), "no such provider", args[0])
+
+					// TODO(@cpuuy83): would be nice to not short-circuit the exit here
+					// But at the momemt this seems to be the only way to exit non-zero and
+					// handle our own error output
+					os.Exit(1)
+				}
+				fmt.Fprintln(cmd.OutOrStdout(), args[0])
+			}
+			return
+		},
+	}
+}

virtual-kubelet/commands/root/flag.go

@@ -0,0 +1,90 @@
+// Copyright © 2017 The virtual-kubelet 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 root
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/pflag"
+	"github.com/virtual-kubelet/virtual-kubelet/trace/opencensus"
+)
+
+type mapVar map[string]string
+
+func (mv mapVar) String() string {
+	var s string
+	for k, v := range mv {
+		if s == "" {
+			s = fmt.Sprintf("%s=%v", k, v)
+		} else {
+			s += fmt.Sprintf(", %s=%v", k, v)
+		}
+	}
+	return s
+}
+
+func (mv mapVar) Set(s string) error {
+	split := strings.SplitN(s, "=", 2)
+	if len(split) != 2 {
+		return errors.Errorf("invalid format, must be `key=value`: %s", s)
+	}
+
+	_, ok := mv[split[0]]
+	if ok {
+		return errors.Errorf("duplicate key: %s", split[0])
+	}
+	mv[split[0]] = split[1]
+	return nil
+}
+
+func (mv mapVar) Type() string {
+	return "map"
+}
+
+func installFlags(flags *pflag.FlagSet, c *Opts) {
+	flags.StringVar(&c.KubeConfigPath, "kubeconfig", c.KubeConfigPath, "kube config file to use for connecting to the Kubernetes API server")
+	flags.StringVar(&c.KubeNamespace, "namespace", c.KubeNamespace, "kubernetes namespace (default is 'all')")
+	flags.StringVar(&c.NodeName, "nodename", c.NodeName, "kubernetes node name")
+	flags.StringVar(&c.OperatingSystem, "os", c.OperatingSystem, "Operating System (Linux/Windows)")
+	flags.StringVar(&c.Provider, "provider", c.Provider, "cloud provider")
+	flags.StringVar(&c.ProviderConfigPath, "provider-config", c.ProviderConfigPath, "cloud provider configuration file")
+	flags.StringVar(&c.MetricsAddr, "metrics-addr", c.MetricsAddr, "address to listen for metrics/stats requests")
+
+	flags.StringVar(&c.TaintKey, "taint", c.TaintKey, "Set node taint key")
+	flags.BoolVar(&c.DisableTaint, "disable-taint", c.DisableTaint, "disable the virtual-kubelet node taint")
+	flags.MarkDeprecated("taint", "Taint key should now be configured using the VK_TAINT_KEY environment variable")
+
+	flags.IntVar(&c.PodSyncWorkers, "pod-sync-workers", c.PodSyncWorkers, `set the number of pod synchronization workers`)
+	flags.BoolVar(&c.EnableNodeLease, "enable-node-lease", c.EnableNodeLease, `use node leases (1.13) for node heartbeats`)
+
+	flags.StringSliceVar(&c.TraceExporters, "trace-exporter", c.TraceExporters, fmt.Sprintf("sets the tracing exporter to use, available exporters: %s", opencensus.AvailableTraceExporters()))
+	flags.StringVar(&c.TraceConfig.ServiceName, "trace-service-name", c.TraceConfig.ServiceName, "sets the name of the service used to register with the trace exporter")
+	flags.Var(mapVar(c.TraceConfig.Tags), "trace-tag", "add tags to include with traces in key=value form")
+	flags.StringVar(&c.TraceSampleRate, "trace-sample-rate", c.TraceSampleRate, "set probability of tracing samples")
+
+	flags.DurationVar(&c.InformerResyncPeriod, "full-resync-period", c.InformerResyncPeriod, "how often to perform a full resync of pods between kubernetes and the provider")
+
+}
+
+func getEnv(key, defaultValue string) string {
+	value, found := os.LookupEnv(key)
+	if found {
+		return value
+	}
+	return defaultValue
+}

virtual-kubelet/commands/root/http.go

@@ -0,0 +1,147 @@
+// Copyright © 2017 The virtual-kubelet 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 root
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"os"
+
+	"github.com/pkg/errors"
+	"github.com/virtual-kubelet/virtual-kubelet/log"
+	"github.com/virtual-kubelet/virtual-kubelet/providers"
+	"github.com/virtual-kubelet/virtual-kubelet/vkubelet"
+)
+
+// AcceptedCiphers is the list of accepted TLS ciphers, with known weak ciphers elided
+// Note this list should be a moving target.
+var AcceptedCiphers = []uint16{
+	tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+	tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+	tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+	tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+
+	tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+	tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+	tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+	tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+}
+
+func loadTLSConfig(certPath, keyPath string) (*tls.Config, error) {
+	cert, err := tls.LoadX509KeyPair(certPath, keyPath)
+	if err != nil {
+		return nil, errors.Wrap(err, "error loading tls certs")
+	}
+
+	return &tls.Config{
+		Certificates:             []tls.Certificate{cert},
+		MinVersion:               tls.VersionTLS12,
+		PreferServerCipherSuites: true,
+		CipherSuites:             AcceptedCiphers,
+	}, nil
+}
+
+func setupHTTPServer(ctx context.Context, p providers.Provider, cfg *apiServerConfig) (cancel func(), retErr error) {
+	var closers []io.Closer
+	cancel = func() {
+		for _, c := range closers {
+			c.Close()
+		}
+	}
+	defer func() {
+		if retErr != nil {
+			cancel()
+		}
+	}()
+
+	if cfg.CertPath == "" || cfg.KeyPath == "" {
+		log.G(ctx).
+			WithField("certPath", cfg.CertPath).
+			WithField("keyPath", cfg.KeyPath).
+			Error("TLS certificates not provided, not setting up pod http server")
+	} else {
+		tlsCfg, err := loadTLSConfig(cfg.CertPath, cfg.KeyPath)
+		if err != nil {
+			return nil, err
+		}
+		l, err := tls.Listen("tcp", cfg.Addr, tlsCfg)
+		if err != nil {
+			return nil, errors.Wrap(err, "error setting up listener for pod http server")
+		}
+
+		mux := http.NewServeMux()
+		vkubelet.AttachPodRoutes(p, mux)
+
+		s := &http.Server{
+			Handler:   mux,
+			TLSConfig: tlsCfg,
+		}
+		go serveHTTP(ctx, s, l, "pods")
+		closers = append(closers, s)
+	}
+
+	if cfg.MetricsAddr == "" {
+		log.G(ctx).Info("Pod metrics server not setup due to empty metrics address")
+	} else {
+		l, err := net.Listen("tcp", cfg.MetricsAddr)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not setup listener for pod metrics http server")
+		}
+
+		mux := http.NewServeMux()
+		vkubelet.AttachMetricsRoutes(p, mux)
+		s := &http.Server{
+			Handler: mux,
+		}
+		go serveHTTP(ctx, s, l, "pod metrics")
+		closers = append(closers, s)
+	}
+
+	return cancel, nil
+}
+
+func serveHTTP(ctx context.Context, s *http.Server, l net.Listener, name string) {
+	if err := s.Serve(l); err != nil {
+		select {
+		case <-ctx.Done():
+		default:
+			log.G(ctx).WithError(err).Errorf("Error setting up %s http server", name)
+		}
+	}
+	l.Close()
+}
+
+type apiServerConfig struct {
+	CertPath    string
+	KeyPath     string
+	Addr        string
+	MetricsAddr string
+}
+
+func getAPIConfig(c Opts) (*apiServerConfig, error) {
+	config := apiServerConfig{
+		CertPath: os.Getenv("APISERVER_CERT_LOCATION"),
+		KeyPath:  os.Getenv("APISERVER_KEY_LOCATION"),
+	}
+
+	config.Addr = fmt.Sprintf(":%d", c.ListenPort)
+	config.MetricsAddr = c.MetricsAddr
+
+	return &config, nil
+}

virtual-kubelet/commands/root/node.go

@@ -0,0 +1,111 @@
+// Copyright © 2017 The virtual-kubelet 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 root
+
+import (
+	"context"
+	"strings"
+
+	"github.com/cpuguy83/strongerrors"
+	"github.com/pkg/errors"
+	"github.com/virtual-kubelet/virtual-kubelet/providers"
+	"github.com/virtual-kubelet/virtual-kubelet/version"
+	corev1 "k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var (
+	// vkVersion is a concatenation of the Kubernetes version the VK is built against, the string "vk" and the VK release version.
+	// TODO @pires revisit after VK 1.0 is released as agreed in https://github.com/virtual-kubelet/virtual-kubelet/pull/446#issuecomment-448423176.
+	vkVersion = strings.Join([]string{"v1.13.1", "vk", version.Version}, "-")
+)
+
+// NodeFromProvider builds a kubernetes node object from a provider
+// This is a temporary solution until node stuff actually split off from the provider interface itself.
+func NodeFromProvider(ctx context.Context, name string, taint *v1.Taint, p providers.Provider) *v1.Node {
+	taints := make([]v1.Taint, 0)
+
+	if taint != nil {
+		taints = append(taints, *taint)
+	}
+
+	node := &v1.Node{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: name,
+			Labels: map[string]string{
+				"type":                   "virtual-kubelet",
+				"kubernetes.io/role":     "agent",
+				"beta.kubernetes.io/os":  strings.ToLower(p.OperatingSystem()),
+				"kubernetes.io/hostname": name,
+				"alpha.service-controller.kubernetes.io/exclude-balancer": "true",
+			},
+		},
+		Spec: v1.NodeSpec{
+			Taints: taints,
+		},
+		Status: v1.NodeStatus{
+			NodeInfo: v1.NodeSystemInfo{
+				OperatingSystem: p.OperatingSystem(),
+				Architecture:    "amd64",
+				KubeletVersion:  vkVersion,
+			},
+			Capacity:        p.Capacity(ctx),
+			Allocatable:     p.Capacity(ctx),
+			Conditions:      p.NodeConditions(ctx),
+			Addresses:       p.NodeAddresses(ctx),
+			DaemonEndpoints: *p.NodeDaemonEndpoints(ctx),
+		},
+	}
+	return node
+}
+
+// getTaint creates a taint using the provided key/value.
+// Taint effect is read from the environment
+// The taint key/value may be overwritten by the environment.
+func getTaint(c Opts) (*corev1.Taint, error) {
+	value := c.Provider
+
+	key := c.TaintKey
+	if key == "" {
+		key = DefaultTaintKey
+	}
+
+	if c.TaintEffect == "" {
+		c.TaintEffect = DefaultTaintEffect
+	}
+
+	key = getEnv("VKUBELET_TAINT_KEY", key)
+	value = getEnv("VKUBELET_TAINT_VALUE", value)
+	effectEnv := getEnv("VKUBELET_TAINT_EFFECT", string(c.TaintEffect))
+
+	var effect corev1.TaintEffect
+	switch effectEnv {
+	case "NoSchedule":
+		effect = corev1.TaintEffectNoSchedule
+	case "NoExecute":
+		effect = corev1.TaintEffectNoExecute
+	case "PreferNoSchedule":
+		effect = corev1.TaintEffectPreferNoSchedule
+	default:
+		return nil, strongerrors.InvalidArgument(errors.Errorf("taint effect %q is not supported", effectEnv))
+	}
+
+	return &corev1.Taint{
+		Key:    key,
+		Value:  value,
+		Effect: effect,
+	}, nil
+}

virtual-kubelet/commands/root/opts.go

@@ -0,0 +1,143 @@
+// Copyright © 2017 The virtual-kubelet 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 root
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"time"
+
+	"github.com/mitchellh/go-homedir"
+	"github.com/pkg/errors"
+	"github.com/virtual-kubelet/virtual-kubelet/trace/opencensus"
+	corev1 "k8s.io/api/core/v1"
+)
+
+// Defaults for root command options
+const (
+	DefaultNodeName             = "virtual-kubelet"
+	DefaultOperatingSystem      = "Linux"
+	DefaultInformerResyncPeriod = 1 * time.Minute
+	DefaultMetricsAddr          = ":10255"
+	DefaultListenPort           = 10250 // TODO(cpuguy83)(VK1.0): Change this to an addr instead of just a port.. we should not be listening on all interfaces.
+	DefaultPodSyncWorkers       = 10
+	DefaultKubeNamespace        = corev1.NamespaceAll
+
+	DefaultTaintEffect = string(corev1.TaintEffectNoSchedule)
+	DefaultTaintKey    = "virtual-kubelet.io/provider"
+)
+
+// Opts stores all the options for configuring the root virtual-kubelet command.
+// It is used for setting flag values.
+//
+// You can set the default options by creating a new `Opts` struct and passing
+// it into `SetDefaultOpts`
+type Opts struct {
+	// Path to the kubeconfig to use to connect to the Kubernetes API server.
+	KubeConfigPath string
+	// Namespace to watch for pods and other resources
+	KubeNamespace string
+	// Sets the port to listen for requests from the Kubernetes API server
+	ListenPort int32
+
+	// Node name to use when creating a node in Kubernetes
+	NodeName string
+
+	// Operating system to run pods for
+	OperatingSystem string
+
+	Provider           string
+	ProviderConfigPath string
+
+	TaintKey     string
+	TaintEffect  string
+	DisableTaint bool
+
+	MetricsAddr string
+
+	// Number of workers to use to handle pod notifications
+	PodSyncWorkers       int
+	InformerResyncPeriod time.Duration
+
+	// Use node leases when supported by Kubernetes (instead of node status updates)
+	EnableNodeLease bool
+
+	TraceExporters  []string
+	TraceSampleRate string
+	TraceConfig     opencensus.TracingExporterOptions
+}
+
+// SetDefaultOpts sets default options for unset values on the passed in option struct.
+// Fields tht are already set will not be modified.
+func SetDefaultOpts(c *Opts) error {
+	if c.OperatingSystem == "" {
+		c.OperatingSystem = DefaultOperatingSystem
+	}
+
+	if c.NodeName == "" {
+		c.NodeName = getEnv("DEFAULT_NODE_NAME", DefaultNodeName)
+	}
+
+	if c.InformerResyncPeriod == 0 {
+		c.InformerResyncPeriod = DefaultInformerResyncPeriod
+	}
+
+	if c.MetricsAddr == "" {
+		c.MetricsAddr = DefaultMetricsAddr
+	}
+
+	if c.PodSyncWorkers == 0 {
+		c.PodSyncWorkers = DefaultPodSyncWorkers
+	}
+
+	if c.TraceConfig.ServiceName == "" {
+		c.TraceConfig.ServiceName = DefaultNodeName
+	}
+
+	if c.ListenPort == 0 {
+		if kp := os.Getenv("KUBELET_PORT"); kp != "" {
+			p, err := strconv.Atoi(kp)
+			if err != nil {
+				return errors.Wrap(err, "error parsing KUBELET_PORT environment variable")
+			}
+			c.ListenPort = int32(p)
+		}
+		c.ListenPort = DefaultListenPort
+	}
+
+	if c.KubeNamespace == "" {
+		c.KubeNamespace = DefaultKubeNamespace
+	}
+
+	if c.TaintKey == "" {
+		c.TaintKey = DefaultTaintKey
+	}
+	if c.TaintEffect == "" {
+		c.TaintEffect = DefaultTaintEffect
+	}
+
+	if c.KubeConfigPath == "" {
+		c.KubeConfigPath = os.Getenv("KUBECONFIG")
+		if c.KubeConfigPath == "" {
+			home, _ := homedir.Dir()
+			if home != "" {
+				c.KubeConfigPath = filepath.Join(home, ".kube", "config")
+			}
+		}
+	}
+
+	return nil
+}

virtual-kubelet/commands/root/root.go

@@ -0,0 +1,204 @@
+// Copyright © 2017 The virtual-kubelet 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 root
+
+import (
+	"context"
+	"os"
+
+	"github.com/cpuguy83/strongerrors"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/virtual-kubelet/virtual-kubelet/log"
+	"github.com/virtual-kubelet/virtual-kubelet/manager"
+	"github.com/virtual-kubelet/virtual-kubelet/providers"
+	"github.com/virtual-kubelet/virtual-kubelet/providers/register"
+	"github.com/virtual-kubelet/virtual-kubelet/vkubelet"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/fields"
+	kubeinformers "k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+)
+
+// NewCommand creates a new top-level command.
+// This command is used to start the virtual-kubelet daemon
+func NewCommand(ctx context.Context, name string, c Opts) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   name,
+		Short: name + " provides a virtual kubelet interface for your kubernetes cluster.",
+		Long: name + ` implements the Kubelet interface with a pluggable
+backend implementation allowing users to create kubernetes nodes without running the kubelet.
+This allows users to schedule kubernetes workloads on nodes that aren't running Kubernetes.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runRootCommand(ctx, c)
+		},
+	}
+
+	installFlags(cmd.Flags(), &c)
+	return cmd
+}
+
+func runRootCommand(ctx context.Context, c Opts) error {
+	if ok := providers.ValidOperatingSystems[c.OperatingSystem]; !ok {
+		return strongerrors.InvalidArgument(errors.Errorf("operating system %q is not supported", c.OperatingSystem))
+	}
+
+	if c.PodSyncWorkers == 0 {
+		return strongerrors.InvalidArgument(errors.New("pod sync workers must be greater than 0"))
+	}
+
+	var taint *corev1.Taint
+	if !c.DisableTaint {
+		var err error
+		taint, err = getTaint(c)
+		if err != nil {
+			return err
+		}
+	}
+
+	client, err := newClient(c.KubeConfigPath)
+	if err != nil {
+		return err
+	}
+
+	// Create a shared informer factory for Kubernetes pods in the current namespace (if specified) and scheduled to the current node.
+	podInformerFactory := kubeinformers.NewSharedInformerFactoryWithOptions(
+		client,
+		c.InformerResyncPeriod,
+		kubeinformers.WithNamespace(c.KubeNamespace),
+		kubeinformers.WithTweakListOptions(func(options *metav1.ListOptions) {
+			options.FieldSelector = fields.OneTermEqualSelector("spec.nodeName", c.NodeName).String()
+		}))
+	// Create a pod informer so we can pass its lister to the resource manager.
+	podInformer := podInformerFactory.Core().V1().Pods()
+
+	// Create another shared informer factory for Kubernetes secrets and configmaps (not subject to any selectors).
+	scmInformerFactory := kubeinformers.NewSharedInformerFactoryWithOptions(client, c.InformerResyncPeriod)
+	// Create a secret informer and a config map informer so we can pass their listers to the resource manager.
+	secretInformer := scmInformerFactory.Core().V1().Secrets()
+	configMapInformer := scmInformerFactory.Core().V1().ConfigMaps()
+	serviceInformer := scmInformerFactory.Core().V1().Services()
+
+	go podInformerFactory.Start(ctx.Done())
+	go scmInformerFactory.Start(ctx.Done())
+
+	rm, err := manager.NewResourceManager(podInformer.Lister(), secretInformer.Lister(), configMapInformer.Lister(), serviceInformer.Lister())
+	if err != nil {
+		return errors.Wrap(err, "could not create resource manager")
+	}
+
+	apiConfig, err := getAPIConfig(c)
+	if err != nil {
+		return err
+	}
+
+	if err := setupTracing(ctx, c); err != nil {
+		return err
+	}
+
+	initConfig := register.InitConfig{
+		ConfigPath:      c.ProviderConfigPath,
+		NodeName:        c.NodeName,
+		OperatingSystem: c.OperatingSystem,
+		ResourceManager: rm,
+		DaemonPort:      int32(c.ListenPort),
+		InternalIP:      os.Getenv("VKUBELET_POD_IP"),
+	}
+
+	p, err := register.GetProvider(c.Provider, initConfig)
+	if err != nil {
+		return err
+	}
+
+	ctx = log.WithLogger(ctx, log.G(ctx).WithFields(log.Fields{
+		"provider":         c.Provider,
+		"operatingSystem":  c.OperatingSystem,
+		"node":             c.NodeName,
+		"watchedNamespace": c.KubeNamespace,
+	}))
+
+	pNode := NodeFromProvider(ctx, c.NodeName, taint, p)
+	node, err := vkubelet.NewNode(
+		vkubelet.NaiveNodeProvider{},
+		pNode,
+		client.Coordination().Leases(corev1.NamespaceNodeLease),
+		client.CoreV1().Nodes(),
+		vkubelet.WithNodeDisableLease(!c.EnableNodeLease),
+	)
+	if err != nil {
+		log.G(ctx).Fatal(err)
+	}
+
+	vk := vkubelet.New(vkubelet.Config{
+		Client:          client,
+		Namespace:       c.KubeNamespace,
+		NodeName:        pNode.Name,
+		Provider:        p,
+		ResourceManager: rm,
+		PodSyncWorkers:  c.PodSyncWorkers,
+		PodInformer:     podInformer,
+	})
+
+	cancelHTTP, err := setupHTTPServer(ctx, p, apiConfig)
+	if err != nil {
+		return err
+	}
+	defer cancelHTTP()
+
+	go func() {
+		if err := vk.Run(ctx); err != nil && errors.Cause(err) != context.Canceled {
+			log.G(ctx).Fatal(err)
+		}
+	}()
+
+	go func() {
+		if err := node.Run(ctx); err != nil {
+			log.G(ctx).Fatal(err)
+		}
+	}()
+
+	log.G(ctx).Info("Initialized")
+
+	<-ctx.Done()
+	return nil
+}
+
+func newClient(configPath string) (*kubernetes.Clientset, error) {
+	var config *rest.Config
+
+	// Check if the kubeConfig file exists.
+	if _, err := os.Stat(configPath); !os.IsNotExist(err) {
+		// Get the kubeconfig from the filepath.
+		config, err = clientcmd.BuildConfigFromFlags("", configPath)
+		if err != nil {
+			return nil, errors.Wrap(err, "error building client config")
+		}
+	} else {
+		// Set to in-cluster config.
+		config, err = rest.InClusterConfig()
+		if err != nil {
+			return nil, errors.Wrap(err, "error building in cluster config")
+		}
+	}
+
+	if masterURI := os.Getenv("MASTER_URI"); masterURI != "" {
+		config.Host = masterURI
+	}
+
+	return kubernetes.NewForConfig(config)
+}

virtual-kubelet/commands/root/tracing.go

@@ -0,0 +1,102 @@
+// Copyright © 2017 The virtual-kubelet 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 root
+
+import (
+	"context"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/cpuguy83/strongerrors"
+	"github.com/pkg/errors"
+	"github.com/virtual-kubelet/virtual-kubelet/log"
+	"github.com/virtual-kubelet/virtual-kubelet/trace/opencensus"
+	octrace "go.opencensus.io/trace"
+	"go.opencensus.io/zpages"
+)
+
+var (
+	reservedTagNames = map[string]bool{
+		"operatingSystem": true,
+		"provider":        true,
+		"nodeName":        true,
+	}
+)
+
+func setupTracing(ctx context.Context, c Opts) error {
+	for k := range c.TraceConfig.Tags {
+		if reservedTagNames[k] {
+			return strongerrors.InvalidArgument(errors.Errorf("invalid trace tag %q, must not use a reserved tag key"))
+		}
+	}
+	if c.TraceConfig.Tags == nil {
+		c.TraceConfig.Tags = make(map[string]string, 3)
+	}
+	c.TraceConfig.Tags["operatingSystem"] = c.OperatingSystem
+	c.TraceConfig.Tags["provider"] = c.Provider
+	c.TraceConfig.Tags["nodeName"] = c.NodeName
+	for _, e := range c.TraceExporters {
+		if e == "zpages" {
+			go setupZpages(ctx)
+			continue
+		}
+		exporter, err := opencensus.GetTracingExporter(e, c.TraceConfig)
+		if err != nil {
+			return err
+		}
+		octrace.RegisterExporter(exporter)
+	}
+	if len(c.TraceExporters) > 0 {
+		var s octrace.Sampler
+		switch strings.ToLower(c.TraceSampleRate) {
+		case "":
+		case "always":
+			s = octrace.AlwaysSample()
+		case "never":
+			s = octrace.NeverSample()
+		default:
+			rate, err := strconv.Atoi(c.TraceSampleRate)
+			if err != nil {
+				return strongerrors.InvalidArgument(errors.Wrap(err, "unsupported trace sample rate"))
+			}
+			if rate < 0 || rate > 100 {
+				return strongerrors.InvalidArgument(errors.Wrap(err, "trace sample rate must be between 0 and 100"))
+			}
+			s = octrace.ProbabilitySampler(float64(rate) / 100)
+		}
+
+		if s != nil {
+			octrace.ApplyConfig(
+				octrace.Config{
+					DefaultSampler: s,
+				},
+			)
+		}
+	}
+
+	return nil
+}
+
+func setupZpages(ctx context.Context) {
+	p := os.Getenv("ZPAGES_PORT")
+	if p == "" {
+		log.G(ctx).Error("Missing ZPAGES_PORT env var, cannot setup zpages endpoint")
+	}
+	mux := http.NewServeMux()
+	zpages.Handle(mux, "/debug")
+	http.ListenAndServe(p, mux)
+}

virtual-kubelet/commands/version/version.go

@@ -0,0 +1,34 @@
+// Copyright © 2017 The virtual-kubelet 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 version
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/virtual-kubelet/virtual-kubelet/version"
+)
+
+// NewCommand creates a new version subcommand command
+func NewCommand() *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "Show the version of the program",
+		Long:  `Show the version of the program`,
+		Run: func(cmd *cobra.Command, args []string) {
+			fmt.Printf("Version: %s, Built: %s\n", version.Version, version.BuildTime)
+		},
+	}
+}