Fix generic delete: make it work with extension resources

src/app/backend/handler/apihandler.go

@@ -85,7 +85,7 @@ func FormatResponseLog(resp *restful.Response, req *restful.Request) string {
 func CreateHttpApiHandler(client *client.Client, heapsterClient HeapsterClient,
 	clientConfig clientcmd.ClientConfig) http.Handler {
 
-	verber := common.NewResourceVerber(client.RESTClient)
+	verber := common.NewResourceVerber(client.RESTClient, client.ExtensionsClient.RESTClient)
 	apiHandler := ApiHandler{client, heapsterClient, clientConfig, verber}
 	wsContainer := restful.NewContainer()
 
@@ -194,8 +194,8 @@ func CreateHttpApiHandler(client *client.Client, heapsterClient HeapsterClient,
 			Writes(pod.PodList{}))
 	podsWs.Route(
 		podsWs.GET("/{namespace}/{pod}").
-		To(apiHandler.handleGetPodDetail).
-		Writes(pod.PodDetail{}))
+			To(apiHandler.handleGetPodDetail).
+			Writes(pod.PodDetail{}))
 	wsContainer.Add(podsWs)
 
 	deploymentsWs := new(restful.WebService)

src/app/backend/resource/common/types.go

@@ -100,14 +100,19 @@ const (
 // Mapping from resource kind to K8s apiserver API path. This is mostly pluralization, because
 // K8s apiserver uses plural paths and this project singular.
 // Must be kept in sync with the list of supported kinds.
-var kindToAPIPathMapping = map[string]string{
-	ResourceKindService:               "services",
-	ResourceKindPod:                   "pods",
-	ResourceKindEvent:                 "events",
-	ResourceKindReplicationController: "replicationcontrollers",
-	ResourceKindDeployment:            "deployments",
-	ResourceKindReplicaSet:            "replicasets",
-	ResourceKindDaemonSet:             "daemonsets",
+var kindToAPIMapping = map[string]struct {
+	// K8s resource name
+	Resource string
+	// Whether extensions client should be used. True for extensions client, false for normal.
+	Extension bool
+}{
+	ResourceKindService:               {"services", false},
+	ResourceKindPod:                   {"pods", false},
+	ResourceKindEvent:                 {"events", false},
+	ResourceKindReplicationController: {"replicationcontrollers", false},
+	ResourceKindDeployment:            {"deployments", true},
+	ResourceKindReplicaSet:            {"replicasets", true},
+	ResourceKindDaemonSet:             {"daemonsets", false},
 }
 
 // IsSelectorMatching returns true when an object with the given

src/app/backend/resource/common/verber.go

@@ -15,7 +15,6 @@
 package common
 
 import (
-	"errors"
 	"fmt"
 
 	"k8s.io/kubernetes/pkg/client/restclient"
@@ -24,29 +23,38 @@ import (
 // ResourceVerber is a struct responsible for doing common verb operations on resources, like
 // DELETE, PUT, UPDATE.
 type ResourceVerber struct {
-	client RESTClient
+	client           RESTClient
+	extensionsClient RESTClient
 }
 
+// RESTClient is an interface for REST operations used in this file.
 type RESTClient interface {
 	Delete() *restclient.Request
 }
 
 // NewResourceVerber creates a new resource verber that uses the given client for performing
 // operations.
-func NewResourceVerber(client RESTClient) ResourceVerber {
-	return ResourceVerber{client}
+func NewResourceVerber(client RESTClient, extensionsClient RESTClient) ResourceVerber {
+	return ResourceVerber{client, extensionsClient}
 }
 
 // Delete deletes the resource of the given kind in the given namespace with the given name.
 func (verber *ResourceVerber) Delete(kind string, namespace string, name string) error {
-	apiPath, ok := kindToAPIPathMapping[kind]
+	resourceSpec, ok := kindToAPIMapping[kind]
 	if !ok {
-		return errors.New(fmt.Sprintf("Unknown resource kind: %s", kind))
+		return fmt.Errorf("Unknown resource kind: %s", kind)
 	}
 
-	return verber.client.Delete().
+	var client RESTClient
+	if resourceSpec.Extension {
+		client = verber.extensionsClient
+	} else {
+		client = verber.client
+	}
+
+	return client.Delete().
 		Namespace(namespace).
-		Resource(apiPath).
+		Resource(resourceSpec.Resource).
 		Name(name).
 		Do().
 		Error()

src/test/backend/resource/common/verber_test.go

@@ -26,11 +26,20 @@ func (c *FakeRESTClient) Delete() *restclient.Request {
 	}), "DELETE", nil, "/api/v1", restclient.ContentConfig{}, nil, nil)
 }
 
-func TestDeleteShouldPropagateErrors(t *testing.T) {
-	verber := ResourceVerber{client: &FakeRESTClient{err: errors.New("err")}}
+func TestDeleteShouldPropagateErrorsAndChoseClient(t *testing.T) {
+	verber := ResourceVerber{
+		client:           &FakeRESTClient{err: errors.New("err")},
+		extensionsClient: &FakeRESTClient{err: errors.New("err from extensions")},
+	}
 
 	err := verber.Delete("replicaset", "bar", "baz")
 
+	if !reflect.DeepEqual(err, errors.New("err from extensions")) {
+		t.Fatalf("Expected error on verber delete but got %#v", err)
+	}
+
+	err = verber.Delete("service", "bar", "baz")
+
 	if !reflect.DeepEqual(err, errors.New("err")) {
 		t.Fatalf("Expected error on verber delete but got %#v", err)
 	}