Merge "Optimize flags and logs."

cmd/stackube-controller/stackube-controller.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"flag"
 	"fmt"
 	"os"
 	"os/signal"
@@ -15,38 +14,29 @@ import (
 	"git.openstack.org/openstack/stackube/pkg/util"
 
 	"github.com/golang/glog"
+	"github.com/spf13/pflag"
 	"golang.org/x/sync/errgroup"
 	"k8s.io/client-go/kubernetes"
 )
 
 var (
-	cfg tenant.Config
+	kubeconfig = pflag.String("kubeconfig", "/etc/kubernetes/admin.conf",
+		"path to kubernetes admin config file")
+	cloudconfig = pflag.String("cloudconfig", "/etc/stackube.conf",
+		"path to stackube config file")
 )
 
-func init() {
+func startControllers(cfg tenant.Config) error {
-	flag.StringVar(&cfg.KubeConfig, "kubeconfig", "/etc/kubernetes/admin.conf", "- path to kubeconfig")
-	flag.StringVar(&cfg.CloudConfig, "cloudconfig", "/etc/kubestack.conf", "- path to cloudconfig")
-	flag.Parse()
-}
-
-func startControllers() int {
-	// Verify client setting at the beginning and fail early if there are errors.
-	err := verifyClientSetting()
-	if err != nil {
-		glog.Error(err)
-		return 1
-	}
 	// Creates a new tenant controller
 	tc, err := tenant.New(cfg)
 	if err != nil {
-		glog.Error(err)
+		return err
-		return 1
 	}
+
 	// Creates a new RBAC controller
 	rm, err := rbacmanager.New(cfg)
 	if err != nil {
-		glog.Error(err)
+		return err
-		return 1
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -61,8 +51,7 @@ func startControllers() int {
 		cfg.CloudConfig,
 	)
 	if err != nil {
-		glog.Error(err)
+		return err
-		return 1
 	}
 
 	// start network controller
@@ -80,28 +69,48 @@ func startControllers() int {
 	cancel()
 	if err := wg.Wait(); err != nil {
 		glog.Errorf("Unhandled error received: %v", err)
-		return 1
+		return err
 	}
 
-	return 0
+	return nil
 }
 
 func verifyClientSetting() error {
-	config, err := util.NewClusterConfig(cfg.KubeConfig)
+	config, err := util.NewClusterConfig(*kubeconfig)
 	if err != nil {
-		return fmt.Errorf("Init cluster config failed: %v", err)
+		return fmt.Errorf("Init kubernetes cluster failed: %v", err)
 	}
+
 	_, err = kubernetes.NewForConfig(config)
 	if err != nil {
 		return fmt.Errorf("Init kubernetes clientset failed: %v", err)
 	}
-	_, err = openstack.NewClient(cfg.CloudConfig)
+
+	_, err = openstack.NewClient(*cloudconfig)
 	if err != nil {
 		return fmt.Errorf("Init openstack client failed: %v", err)
 	}
+
 	return nil
 }
 
 func main() {
-	os.Exit(startControllers())
+	util.InitFlags()
+	util.InitLogs()
+	defer util.FlushLogs()
+
+	// Verify client setting at the beginning and fail early if there are errors.
+	err := verifyClientSetting()
+	if err != nil {
+		glog.Fatal(err)
+	}
+
+	// Start stackube controllers.
+	cfg := tenant.Config{
+		KubeConfig:  *kubeconfig,
+		CloudConfig: *cloudconfig,
+	}
+	if err := startControllers(cfg); err != nil {
+		glog.Fatal(err)
+	}
 }

doc/source/developer.rst

@@ -27,7 +27,16 @@ Start
 
 ::
 
-   ./_output/stackube-controller -v=5 -alsologtostderr=true -logtostderr=true
+   cat >/etc/stackube.conf <<EOF
+   [Global]
+   auth-url=https://x.x.x.x/identity_admin/v2.0
+   username=admin
+   password=password
+   tenant-name=admin
+   region=RegionOne
+   ext-net-id=x-x-x-x-x
+   EOF
+   ./_output/stackube-controller --v=5
 
 
 

pkg/openstack/client.go

@@ -15,6 +15,7 @@ import (
 	"github.com/gophercloud/gophercloud/openstack/networking/v2/subnets"
 	"github.com/gophercloud/gophercloud/pagination"
 
+	"fmt"
 	drivertypes "git.openstack.org/openstack/stackube/pkg/openstack/types"
 	gcfg "gopkg.in/gcfg.v1"
 )
@@ -79,6 +80,12 @@ func NewClient(config string) (*Client, error) {
 		opts = toAuthOptions(cfg)
 	}
 
+	glog.V(1).Infof("Initializing openstack client with config %v", cfg)
+
+	if cfg.Global.ExtNetID == "" {
+		return nil, fmt.Errorf("external network ID not set")
+	}
+
 	provider, err := openstack.AuthenticatedClient(opts)
 	if err != nil {
 		return nil, err

pkg/util/flags.go

@@ -0,0 +1,42 @@
+package util
+
+import (
+	goflag "flag"
+	"os"
+	"strings"
+
+	"github.com/golang/glog"
+	"github.com/spf13/pflag"
+)
+
+// WordSepNormalizeFunc changes all flags that contain "_" separators
+func WordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
+	if strings.Contains(name, "_") {
+		return pflag.NormalizedName(strings.Replace(name, "_", "-", -1))
+	}
+	return pflag.NormalizedName(name)
+}
+
+// WarnWordSepNormalizeFunc changes and warns for flags that contain "_" separators
+func WarnWordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
+	if strings.Contains(name, "_") {
+		nname := strings.Replace(name, "_", "-", -1)
+		glog.Warningf("%s is DEPRECATED and will be removed in a future version. Use %s instead.", name, nname)
+
+		return pflag.NormalizedName(nname)
+	}
+	return pflag.NormalizedName(name)
+}
+
+// InitFlags normalizes and parses the command line flags
+func InitFlags() {
+	pflag.CommandLine.SetNormalizeFunc(WordSepNormalizeFunc)
+	pflag.CommandLine.AddGoFlagSet(goflag.CommandLine)
+
+	pflag.Parse()
+
+	path := pflag.Lookup("log-dir").Value.String()
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		os.MkdirAll(path, 0755)
+	}
+}

pkg/util/logs.go

@@ -0,0 +1,44 @@
+package util
+
+import (
+	"flag"
+	"log"
+	"time"
+
+	"github.com/golang/glog"
+	"github.com/spf13/pflag"
+	"k8s.io/apimachinery/pkg/util/wait"
+)
+
+var logFlushFreq = pflag.Duration("log-flush-frequency", 5*time.Second, "Maximum number of seconds between log flushes")
+
+func init() {
+	flag.Set("logtostderr", "true")
+}
+
+// GlogWriter serves as a bridge between the standard log package and the glog package.
+type GlogWriter struct{}
+
+// Write implements the io.Writer interface.
+func (writer GlogWriter) Write(data []byte) (n int, err error) {
+	glog.Info(string(data))
+	return len(data), nil
+}
+
+// InitLogs initializes logs the way we want for kubernetes.
+func InitLogs() {
+	log.SetOutput(GlogWriter{})
+	log.SetFlags(0)
+	// The default glog flush interval is 30 seconds, which is frighteningly long.
+	go wait.Until(glog.Flush, *logFlushFreq, wait.NeverStop)
+}
+
+// FlushLogs flushes logs immediately.
+func FlushLogs() {
+	glog.Flush()
+}
+
+// NewLogger creates a new log.Logger which sends logs to glog.Info.
+func NewLogger(prefix string) *log.Logger {
+	return log.New(GlogWriter{}, prefix, 0)
+}