Upgrade boilerplate to latest

The latest boilerplate comes with a lot of simplifications and helpers
that let us reduce the amount of code written.

cmd/adapter/adapter.go

@@ -18,26 +18,165 @@ package main
 
 import (
 	"flag"
+	"fmt"
+	"net/http"
+	"net/url"
 	"os"
-	"runtime"
+	"time"
 
+	"github.com/golang/glog"
+	basecmd "github.com/kubernetes-incubator/custom-metrics-apiserver/pkg/cmd"
+	"github.com/kubernetes-incubator/custom-metrics-apiserver/pkg/provider"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/apiserver/pkg/util/logs"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
 
-	"github.com/directxman12/k8s-prometheus-adapter/cmd/adapter/app"
+	prom "github.com/directxman12/k8s-prometheus-adapter/pkg/client"
+	mprom "github.com/directxman12/k8s-prometheus-adapter/pkg/client/metrics"
+	adaptercfg "github.com/directxman12/k8s-prometheus-adapter/pkg/config"
+	cmprov "github.com/directxman12/k8s-prometheus-adapter/pkg/custom-provider"
 )
 
+type PrometheusAdapter struct {
+	basecmd.AdapterBase
+
+	// PrometheusURL is the URL describing how to connect to Prometheus.  Query parameters configure connection options.
+	PrometheusURL string
+	// PrometheusAuthInCluster enables using the auth details from the in-cluster kubeconfig to connect to Prometheus
+	PrometheusAuthInCluster bool
+	// PrometheusAuthConf is the kubeconfig file that contains auth details used to connect to Prometheus
+	PrometheusAuthConf string
+	// AdapterConfigFile points to the file containing the metrics discovery configuration.
+	AdapterConfigFile string
+	// MetricsRelistInterval is the interval at which to relist the set of available metrics
+	MetricsRelistInterval time.Duration
+}
+
+func (cmd *PrometheusAdapter) makePromClient() (prom.Client, error) {
+	baseURL, err := url.Parse(cmd.PrometheusURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid Prometheus URL %q: %v", baseURL, err)
+	}
+	promHTTPClient, err := makeHTTPClient(cmd.PrometheusAuthInCluster, cmd.PrometheusAuthConf)
+	if err != nil {
+		return nil, err
+	}
+	genericPromClient := prom.NewGenericAPIClient(promHTTPClient, baseURL)
+	instrumentedGenericPromClient := mprom.InstrumentGenericAPIClient(genericPromClient, baseURL.String())
+	return prom.NewClientForAPI(instrumentedGenericPromClient), nil
+}
+
+func (cmd *PrometheusAdapter) addFlags() {
+	cmd.Flags().StringVar(&cmd.PrometheusURL, "prometheus-url", cmd.PrometheusURL,
+		"URL for connecting to Prometheus.")
+	cmd.Flags().BoolVar(&cmd.PrometheusAuthInCluster, "prometheus-auth-incluster", cmd.PrometheusAuthInCluster,
+		"use auth details from the in-cluster kubeconfig when connecting to prometheus.")
+	cmd.Flags().StringVar(&cmd.PrometheusAuthConf, "prometheus-auth-config", cmd.PrometheusAuthConf,
+		"kubeconfig file used to configure auth when connecting to Prometheus.")
+	cmd.Flags().StringVar(&cmd.AdapterConfigFile, "config", cmd.AdapterConfigFile,
+		"Configuration file containing details of how to transform between Prometheus metrics "+
+			"and custom metrics API resources")
+	cmd.Flags().DurationVar(&cmd.MetricsRelistInterval, "metrics-relist-interval", cmd.MetricsRelistInterval, ""+
+		"interval at which to re-list the set of all available metrics from Prometheus")
+}
+
+func (cmd *PrometheusAdapter) makeProvider(stopCh <-chan struct{}) (provider.CustomMetricsProvider, error) {
+	// load metrics discovery configuration
+	if cmd.AdapterConfigFile == "" {
+		return nil, fmt.Errorf("no metrics discovery configuration file specified (make sure to use --config)")
+	}
+	metricsConfig, err := adaptercfg.FromFile(cmd.AdapterConfigFile)
+	if err != nil {
+		return nil, fmt.Errorf("unable to load metrics discovery configuration: %v", err)
+	}
+
+	// make the prometheus client
+	promClient, err := cmd.makePromClient()
+	if err != nil {
+		return nil, fmt.Errorf("unable to construct Prometheus client: %v", err)
+	}
+
+	// grab the mapper and dynamic client
+	mapper, err := cmd.RESTMapper()
+	if err != nil {
+		return nil, fmt.Errorf("unable to construct RESTMapper: %v", err)
+	}
+	dynClient, err := cmd.DynamicClient()
+	if err != nil {
+		return nil, fmt.Errorf("unable to construct Kubernetes client: %v", err)
+	}
+
+	// extract the namers
+	namers, err := cmprov.NamersFromConfig(metricsConfig, mapper)
+	if err != nil {
+		return nil, fmt.Errorf("unable to construct naming scheme from metrics rules: %v", err)
+	}
+
+	// construct the provider and start it
+	cmProvider, runner := cmprov.NewPrometheusProvider(mapper, dynClient, promClient, namers, cmd.MetricsRelistInterval)
+	runner.RunUntil(stopCh)
+
+	return cmProvider, nil
+}
+
 func main() {
 	logs.InitLogs()
 	defer logs.FlushLogs()
 
-	if len(os.Getenv("GOMAXPROCS")) == 0 {
-		runtime.GOMAXPROCS(runtime.NumCPU())
+	// set up flags
+	cmd := &PrometheusAdapter{
+		PrometheusURL:         "https://localhost",
+		MetricsRelistInterval: 10 * time.Minute,
+	}
+	cmd.addFlags()
+	cmd.Flags().AddGoFlagSet(flag.CommandLine) // make sure we get the glog flags
+	cmd.Flags().Parse(os.Args)
+
+	// construct the provider
+	cmProvider, err := cmd.makeProvider(wait.NeverStop)
+	if err != nil {
+		glog.Fatalf("unable to construct custom metrics provider: %v", err)
 	}
 
-	cmd := app.NewCommandStartPrometheusAdapterServer(os.Stdout, os.Stderr, wait.NeverStop)
-	cmd.Flags().AddGoFlagSet(flag.CommandLine)
-	if err := cmd.Execute(); err != nil {
-		panic(err)
+	// attach the provider to the server and run it
+	cmd.WithCustomMetrics(cmProvider)
+	if err := cmd.Run(wait.NeverStop); err != nil {
+		glog.Fatalf("unable to run custom metrics adapter: %v", err)
 	}
 }
+
+// makeHTTPClient constructs an HTTP for connecting with the given auth options.
+func makeHTTPClient(inClusterAuth bool, kubeConfigPath string) (*http.Client, error) {
+	// make sure we're not trying to use two different sources of auth
+	if inClusterAuth && kubeConfigPath != "" {
+		return nil, fmt.Errorf("may not use both in-cluster auth and an explicit kubeconfig at the same time")
+	}
+
+	// return the default client if we're using no auth
+	if !inClusterAuth && kubeConfigPath == "" {
+		return http.DefaultClient, nil
+	}
+
+	var authConf *rest.Config
+	if kubeConfigPath != "" {
+		var err error
+		loadingRules := &clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeConfigPath}
+		loader := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, &clientcmd.ConfigOverrides{})
+		authConf, err = loader.ClientConfig()
+		if err != nil {
+			return nil, fmt.Errorf("unable to construct  auth configuration from %q for connecting to Prometheus: %v", kubeConfigPath, err)
+		}
+	} else {
+		var err error
+		authConf, err = rest.InClusterConfig()
+		if err != nil {
+			return nil, fmt.Errorf("unable to construct in-cluster auth configuration for connecting to Prometheus: %v", err)
+		}
+	}
+	tr, err := rest.TransportFor(authConf)
+	if err != nil {
+		return nil, fmt.Errorf("unable to construct client transport for connecting to Prometheus: %v", err)
+	}
+	return &http.Client{Transport: tr}, nil
+}