deis doctor includes lots of k8s data (#81)

* basic data structure in place

* fix(misc): err responses, code cleanup, light optimizations

* chore(cleanup): err response, enumeration, log optimizations

* chore(err): `if err :=` is preferred over `if err =`

Author: jackfrancis

api/swagger-spec/swagger.yml

@@ -311,13 +311,72 @@ definitions:
         type: array
         items:
           $ref: "#/definitions/componentVersion"
+  k8sResource:
+    type: object
+    required:
+      - data
+    properties:
+      data:
+        type: object
+  namespace:
+    type: object
+    required:
+      - name
+      - daemonSets
+      - deployments
+      - events
+      - pods
+      - replicaSets
+      - replicationControllers
+      - services
+    properties:
+      name:
+        type: string
+      daemonSets:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
+      deployments:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
+      events:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
+      pods:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
+      replicaSets:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
+      replicationControllers:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
+      services:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
   doctorInfo:
     type: object
     required:
-      - cluster
+      - workflow
+      - nodes
+      - namespaces
     properties:
-      cluster:
+      workflow:
         $ref: "#/definitions/cluster"
+      nodes:
+        type: array
+        items:
+          $ref: "#/definitions/k8sResource"
+      namespaces:
+        type: array
+        items:
+          $ref: "#/definitions/namespace"
   componentVersion:
     type: object
     properties:

boot.go

@@ -10,6 +10,7 @@ import (
 	"github.com/deis/workflow-manager/data"
 	"github.com/deis/workflow-manager/handlers"
 	"github.com/deis/workflow-manager/jobs"
+	"github.com/deis/workflow-manager/k8s"
 	"github.com/gorilla/mux"
 	kcl "k8s.io/kubernetes/pkg/client/unversioned"
 )
@@ -23,25 +24,20 @@ func main() {
 	if err != nil {
 		log.Fatalf("Error creating new swagger api client (%s)", err)
 	}
-	secretInterface := kubeClient.Secrets(config.Spec.DeisNamespace)
-	rcInterface := kubeClient.ReplicationControllers(config.Spec.DeisNamespace)
-	clusterID := data.NewClusterIDFromPersistentStorage(secretInterface)
-	installedDeisData := data.NewInstalledDeisData(rcInterface)
+	deisK8sResources := k8s.NewResourceInterfaceNamespaced(kubeClient, config.Spec.DeisNamespace)
+	clusterID := data.NewClusterIDFromPersistentStorage(deisK8sResources.Secrets())
+	installedDeisData := data.NewInstalledDeisData(deisK8sResources)
 	availableVersion := data.NewAvailableVersionsFromAPI(
 		apiClient,
 		config.Spec.VersionsAPIURL,
-		secretInterface,
-		rcInterface,
 	)
-	availableComponentVersion := data.NewLatestReleasedComponent(secretInterface, rcInterface, availableVersion)
+	availableComponentVersion := data.NewLatestReleasedComponent(deisK8sResources, availableVersion)
 
 	pollDur := time.Duration(config.Spec.Polling) * time.Second
 	// we want to do the following jobs according to our remote API interval:
 	// 1. get latest stable deis component versions
 	// 2. send diagnostic data, if appropriate
 	glvdPeriodic := jobs.NewGetLatestVersionDataPeriodic(
-		secretInterface,
-		rcInterface,
 		installedDeisData,
 		clusterID,
 		availableVersion,
@@ -51,8 +47,7 @@ func main() {
 
 	svPeriodic := jobs.NewSendVersionsPeriodic(
 		apiClient,
-		secretInterface,
-		rcInterface,
+		deisK8sResources,
 		availableVersion,
 		pollDur,
 	)
@@ -62,7 +57,7 @@ func main() {
 	defer close(ch)
 
 	// Get a new router, with handler functions
-	r := handlers.RegisterRoutes(mux.NewRouter(), secretInterface, rcInterface, availableVersion)
+	r := handlers.RegisterRoutes(mux.NewRouter(), availableVersion, deisK8sResources)
 	// Bind to a port and pass our router in
 	hostStr := fmt.Sprintf(":%s", config.Spec.Port)
 	log.Printf("Serving on %s", hostStr)

boot_test.go

@@ -23,16 +23,15 @@ func newServer(apiClient *apiclient.WorkflowManager) *httptest.Server {
 		mocks.InstalledMockData{},
 		&mocks.ClusterIDMockData{},
 		mocks.LatestMockData{},
-		data.NewFakeKubeSecretGetterCreator(nil, nil),
 	)
 	r.Handle("/components", compHdl)
 	idHdl := handlers.IDHandler(&mocks.ClusterIDMockData{})
 	r.Handle("/id", idHdl)
 	docHdl := handlers.DoctorHandler(
 		mocks.InstalledMockData{},
+		mocks.RunningK8sMockData{}, // TODO: mock k8s node data
 		&mocks.ClusterIDMockData{},
 		mocks.LatestMockData{},
-		data.NewFakeKubeSecretGetterCreator(nil, nil),
 		apiClient,
 	)
 	r.Handle("/doctor", docHdl).Methods("POST")

data/available_component_versions.go

@@ -1,7 +1,7 @@
 package data
 
 import (
-	"github.com/arschles/kubeapp/api/rc"
+	"github.com/deis/workflow-manager/k8s"
 	"github.com/deis/workflow-manager/pkg/swagger/models"
 )
 
@@ -13,30 +13,25 @@ type AvailableComponentVersion interface {
 
 // latestReleasedComponent fulfills the AvailableComponentVersion interface
 type latestReleasedComponent struct {
-	secretGetterCreator KubeSecretGetterCreator
-	rcLister            rc.Lister
-	availableVersions   AvailableVersions
+	k8sResources *k8s.ResourceInterfaceNamespaced
+	availableVersions AvailableVersions
 }
 
 // NewLatestReleasedComponent creates a new AvailableComponentVersion that gets the latest released component using sgc as the implementation to get and create secrets
 func NewLatestReleasedComponent(
-	sgc KubeSecretGetterCreator,
-	rcl rc.Lister,
+	ri *k8s.ResourceInterfaceNamespaced,
 	availableVersions AvailableVersions,
 ) AvailableComponentVersion {
 	return &latestReleasedComponent{
-		secretGetterCreator: sgc,
-		rcLister:            rcl,
-		availableVersions:   availableVersions,
+		k8sResources: ri,
+		availableVersions: availableVersions,
 	}
 }
 
 // Get method for LatestReleasedComponent
 func (c *latestReleasedComponent) Get(component string, cluster models.Cluster) (models.Version, error) {
 	version, err := GetLatestVersion(
 		component,
-		c.secretGetterCreator,
-		c.rcLister,
 		cluster,
 		c.availableVersions,
 	)

data/available_versions.go

@@ -3,7 +3,6 @@ package data
 import (
 	"sync"
 
-	"github.com/arschles/kubeapp/api/rc"
 	"github.com/deis/workflow-manager/config"
 	apiclient "github.com/deis/workflow-manager/pkg/swagger/client"
 	"github.com/deis/workflow-manager/pkg/swagger/client/operations"
@@ -31,8 +30,6 @@ type availableVersionsFromAPI struct {
 func NewAvailableVersionsFromAPI(
 	apiClient *apiclient.WorkflowManager,
 	baseVersionsURL string,
-	secretGetterCreator KubeSecretGetterCreator,
-	rcLister rc.Lister,
 ) AvailableVersions {
 	if baseVersionsURL == "" {
 		baseVersionsURL = config.Spec.VersionsAPIURL

data/available_versions_test.go

@@ -2,6 +2,7 @@ package data
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"sync"
@@ -13,6 +14,73 @@ import (
 	"github.com/deis/workflow-manager/pkg/swagger/models"
 )
 
+// Creating a novel mock struct that fulfills the AvailableVersions interface
+type testAvailableVersions struct{}
+
+func (a testAvailableVersions) Refresh(cluster models.Cluster) ([]models.ComponentVersion, error) {
+	data := getMockComponentVersions()
+	var componentVersions []models.ComponentVersion
+	if err := json.Unmarshal(data, &componentVersions); err != nil {
+		return nil, err
+	}
+	return componentVersions, nil
+}
+
+func (a testAvailableVersions) Store(c []models.ComponentVersion) {
+	return
+}
+
+func (a testAvailableVersions) Cached() []models.ComponentVersion {
+	return nil
+}
+
+// Creating another mock struct that fulfills the AvailableVersions interface
+type shouldBypassAvailableVersions struct{}
+
+func (a shouldBypassAvailableVersions) Refresh(cluster models.Cluster) ([]models.ComponentVersion, error) {
+	var componentVersions []models.ComponentVersion
+	data := []byte(fmt.Sprintf(`[{
+	  "components": [
+	    {
+	      "component": {
+	        "name": "bypass me",
+	        "description": "bypass me"
+	      },
+	      "version": {
+	        "version": "v2-bypass"
+	      }
+	    }
+	  ]
+	}]`))
+	if err := json.Unmarshal(data, &componentVersions); err != nil {
+		return nil, err
+	}
+	return componentVersions, nil
+}
+
+func (a shouldBypassAvailableVersions) Store(c []models.ComponentVersion) {
+	return
+}
+
+func (a shouldBypassAvailableVersions) Cached() []models.ComponentVersion {
+	return nil
+}
+
+// Calls GetAvailableVersions twice, the first time we expect our passed-in struct w/ Refresh() method
+// to be invoked, the 2nd time we expect to receive the same value back (cached in memory)
+// and for the passed-in Refresh() method to be ignored
+func TestGetAvailableVersions(t *testing.T) {
+	mock := getMockComponentVersions()
+	var mockVersions []models.ComponentVersion
+	assert.NoErr(t, json.Unmarshal(mock, &mockVersions))
+	versions, err := GetAvailableVersions(testAvailableVersions{}, models.Cluster{})
+	assert.NoErr(t, err)
+	assert.Equal(t, versions, mockVersions, "component versions data")
+	versions, err = GetAvailableVersions(shouldBypassAvailableVersions{}, models.Cluster{})
+	assert.NoErr(t, err)
+	assert.Equal(t, versions, mockVersions, "component versions data")
+}
+
 func TestRefreshAvailableVersions(t *testing.T) {
 	desc := "this is test1"
 	updAvail := "nothing"

data/cluster_id.go

@@ -3,6 +3,7 @@ package data
 import (
 	"sync"
 
+	"github.com/deis/workflow-manager/k8s"
 	"github.com/satori/go.uuid"
 	"k8s.io/kubernetes/pkg/api"
 	apierrors "k8s.io/kubernetes/pkg/api/errors"
@@ -36,11 +37,11 @@ func GetID(id ClusterID) (string, error) {
 type clusterIDFromPersistentStorage struct {
 	rwm                 *sync.RWMutex
 	cache               string
-	secretGetterCreator KubeSecretGetterCreator
+	secretGetterCreator k8s.KubeSecretGetterCreator
 }
 
 // NewClusterIDFromPersistentStorage returns a new ClusterID implementation that uses the kubernetes API to get its cluster information
-func NewClusterIDFromPersistentStorage(sgc KubeSecretGetterCreator) ClusterID {
+func NewClusterIDFromPersistentStorage(sgc k8s.KubeSecretGetterCreator) ClusterID {
 	return &clusterIDFromPersistentStorage{
 		rwm:                 new(sync.RWMutex),
 		cache:               "",