diff --git a/cmd/stackube-controller/stackube-controller.go b/cmd/stackube-controller/stackube-controller.go
index e545490..e539ea7 100644
--- a/cmd/stackube-controller/stackube-controller.go
+++ b/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() {
-	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
-	}
+func startControllers(cfg tenant.Config) error {
 	// Creates a new tenant controller
 	tc, err := tenant.New(cfg)
 	if err != nil {
-		glog.Error(err)
-		return 1
+		return err
 	}
+
 	// Creates a new RBAC controller
 	rm, err := rbacmanager.New(cfg)
 	if err != nil {
-		glog.Error(err)
-		return 1
+		return err
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -61,8 +51,7 @@ func startControllers() int {
 		cfg.CloudConfig,
 	)
 	if err != nil {
-		glog.Error(err)
-		return 1
+		return err
 	}
 
 	// 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)
+	}
 }
diff --git a/doc/source/developer.rst b/doc/source/developer.rst
index 297f4d3..22eab43 100644
--- a/doc/source/developer.rst
+++ b/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
 
 
 
diff --git a/pkg/openstack/client.go b/pkg/openstack/client.go
index fbc3fbf..4d6b6e2 100644
--- a/pkg/openstack/client.go
+++ b/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
diff --git a/pkg/util/flags.go b/pkg/util/flags.go
new file mode 100644
index 0000000..4e4342b
--- /dev/null
+++ b/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)
+	}
+}
diff --git a/pkg/util/logs.go b/pkg/util/logs.go
new file mode 100644
index 0000000..1c8b9d9
--- /dev/null
+++ b/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)
+}