Create a global client variable

Pull together all the client split work by using a global variable
to pass around the clients.

pkg/apb/client.go

@@ -54,23 +54,15 @@ type Client struct {
 }
 
 func NewClient(log *logging.Logger) (*Client, error) {
-	dockerClient, err := clients.Docker(log)
-	if err != nil {
-		log.Error("Could not load docker client")
-		return nil, err
-	}
-
-	k8s, err := clients.Kubernetes(log)
-	if err != nil {
-		return nil, err
-	}
-
-	rest := k8s.CoreV1().RESTClient()
+	//TODO: This object gets created each provision, bind, deprovision,
+	// and unbind.  Instead, those functions should be using the global
+	// clients were needed and this class needs to be reworked.
+	k8s := clients.Clients.KubernetesClient
 
 	client := &Client{
-		dockerClient:  dockerClient,
+		dockerClient:  clients.Clients.DockerClient,
 		ClusterClient: k8s,
-		RESTClient:    rest,
+		RESTClient:    k8s.CoreV1().RESTClient(),
 		log:           log,
 	}
 
@@ -146,14 +138,14 @@ func (c *Client) RunImage(
 	}
 
 	c.log.Notice(fmt.Sprintf("Creating pod %q in the %s namespace", pod.Name, ns))
-	_, err = c.ClusterClient.CoreV1().Pods(ns).Create(pod)
+	_, err = clients.Clients.KubernetesClient.CoreV1().Pods(ns).Create(pod)
 
 	return apbId, err
 }
 
 func (c *Client) PullImage(imageName string) error {
 	// Under what circumstances does this error out?
-	c.dockerClient.PullImage(docker.PullImageOptions{
+	clients.Clients.DockerClient.PullImage(docker.PullImageOptions{
 		Repository:   imageName,
 		OutputStream: os.Stdout,
 	}, docker.AuthConfiguration{})

pkg/app/app.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/openshift/ansible-service-broker/pkg/apb"
 	"github.com/openshift/ansible-service-broker/pkg/broker"
+	"github.com/openshift/ansible-service-broker/pkg/clients"
 	"github.com/openshift/ansible-service-broker/pkg/dao"
 	"github.com/openshift/ansible-service-broker/pkg/handler"
 )
@@ -48,6 +49,8 @@ func CreateApp() App {
 	fmt.Println("==           Starting Ansible Service Broker...           ==")
 	fmt.Println("============================================================")
 
+	//TODO: Let's take all these validations and delegate them to the client
+	// pkg.
 	if app.config, err = CreateConfig(app.args.ConfigFile); err != nil {
 		os.Stderr.WriteString("ERROR: Failed to read config file\n")
 		os.Stderr.WriteString(err.Error())
@@ -60,12 +63,14 @@ func CreateApp() App {
 		os.Exit(1)
 	}
 
-	app.log.Debug("Connecting Dao")
-	if app.dao, err = dao.NewDao(app.config.Dao, app.log.Logger); err != nil {
-		app.log.Error("Failed to initialize Dao\n")
+	app.log.Debug("Creating Etcd Client")
+	if err = clients.NewEtcd(app.config.Dao, app.log.Logger); err != nil {
+		app.log.Error("Failed to initialize Etcd Client\n")
 		app.log.Error(err.Error())
 		os.Exit(1)
 	}
+
+	app.log.Debug("Connecting to Etcd")
 	serv, clust, err := app.dao.GetEtcdVersion(app.config.Dao)
 	if err != nil {
 		app.log.Error("Failed to connect to Etcd\n")
@@ -74,16 +79,18 @@ func CreateApp() App {
 	}
 	app.log.Info("Etcd Version [Server: %s, Cluster: %s]", serv, clust)
 
-	app.log.Debug("Creating Cluster Client")
-	client, err := apb.NewClient(app.log.Logger)
-	if err != nil {
+	app.log.Debug("Connecting Dao")
+	app.dao = dao.NewDao(app.config.Dao, app.log.Logger)
+
+	app.log.Debug("Creating Kubernetes Client")
+	if err = clients.NewKubernetes(app.log.Logger); err != nil {
 		app.log.Error(err.Error())
 		os.Exit(1)
 	}
-	app.log.Info("Cluster Client Created")
 
 	app.log.Debug("Connecting to Cluster")
-	body, err := client.RESTClient.Get().AbsPath("/version").Do().Raw()
+
+	body, err := clients.Clients.RESTClient.Get().AbsPath("/version").Do().Raw()
 	if err != nil {
 		app.log.Error(err.Error())
 		os.Exit(1)
@@ -103,6 +110,12 @@ func CreateApp() App {
 		os.Exit(1)
 	}
 
+	app.log.Debug("Creating Docker Client")
+	if err = clients.NewDocker(app.log.Logger); err != nil {
+		app.log.Error(err.Error())
+		os.Exit(1)
+	}
+
 	app.log.Debug("Connecting Registry")
 	if app.registry, err = apb.NewRegistry(
 		app.config.Registry, app.log.Logger,

pkg/clients/clients.go

@@ -0,0 +1,16 @@
+package clients
+
+import (
+	d "github.com/fsouza/go-dockerclient"
+
+	"github.com/coreos/etcd/client"
+	"k8s.io/client-go/rest"
+	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
+)
+
+var Clients struct {
+	EtcdClient       client.Client
+	KubernetesClient *clientset.Clientset
+	DockerClient     *d.Client
+	RESTClient       rest.Interface
+}

pkg/clients/docker.go

@@ -5,11 +5,13 @@ import (
 	logging "github.com/op/go-logging"
 )
 
-func Docker(log *logging.Logger) (*docker.Client, error) {
+func NewDocker(log *logging.Logger) error {
 	dockerClient, err := docker.NewClient(DockerSocket)
 	if err != nil {
 		log.Error("Could not load docker client")
-		return nil, err
+		return err
 	}
-	return dockerClient, nil
+
+	Clients.DockerClient = dockerClient
+	return nil
 }

pkg/clients/etcd.go

@@ -14,7 +14,7 @@ type EtcdConfig struct {
 	EtcdPort string `yaml:"etcd_port"`
 }
 
-func Etcd(config EtcdConfig, log *logging.Logger) (client.Client, error) {
+func NewEtcd(config EtcdConfig, log *logging.Logger) error {
 	// TODO: Config validation
 	endpoints := []string{etcdEndpoint(config.EtcdHost, config.EtcdPort)}
 
@@ -29,10 +29,11 @@ func Etcd(config EtcdConfig, log *logging.Logger) (client.Client, error) {
 		HeaderTimeoutPerRequest: time.Second,
 	})
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return etcdClient, nil
+	Clients.EtcdClient = etcdClient
+	return nil
 }
 
 func etcdEndpoint(host string, port string) string {

pkg/clients/kubernetes.go

@@ -22,7 +22,7 @@ func createClientConfigFromFile(configPath string) (*restclient.Config, error) {
 	return config, nil
 }
 
-func Kubernetes(log *logging.Logger) (*clientset.Clientset, error) {
+func NewKubernetes(log *logging.Logger) error {
 	// NOTE: Both the external and internal client object are using the same
 	// clientset library. Internal clientset normally uses a different
 	// library
@@ -34,15 +34,19 @@ func Kubernetes(log *logging.Logger) (*clientset.Clientset, error) {
 		clientConfig, err = createClientConfigFromFile(homedir.HomeDir() + "/.kube/config")
 		if err != nil {
 			log.Error("Failed to create LocalClientSet")
-			return nil, err
+			return err
 		}
 	}
 
 	clientset, err := clientset.NewForConfig(clientConfig)
 	if err != nil {
 		log.Error("Failed to create LocalClientSet")
-		return nil, err
+		return err
 	}
 
-	return clientset, nil
+	rest := clientset.CoreV1().RESTClient()
+
+	Clients.RESTClient = rest
+	Clients.KubernetesClient = clientset
+	return nil
 }

pkg/dao/dao.go

@@ -24,21 +24,15 @@ type Dao struct {
 }
 
 // NewDao - Create a new Dao object
-func NewDao(config clients.EtcdConfig, log *logging.Logger) (*Dao, error) {
-	var err error
+func NewDao(config clients.EtcdConfig, log *logging.Logger) *Dao {
 	dao := Dao{
 		config: config,
 		log:    log,
 	}
 
-	dao.client, err = clients.Etcd(config, log)
-	if err != nil {
-		return nil, err
-	}
-
+	dao.client = clients.Clients.EtcdClient
 	dao.kapi = client.NewKeysAPI(dao.client)
-
-	return &dao, nil
+	return &dao
 }
 
 // SetRaw - Allows the setting of the value json string to the key in the kvp API.