@@ -479,6 +479,9 @@ func (c *KubeConfig) executeControllerRequest(method string, client *kubeclient.

 // executeTemplateRequest transform the JSON file with Config template into a

 // valid Config JSON.

+//

+// TODO: Print the output for each resource on success, as "create" method

+//       does in the executeAPIRequest().

 func (c *KubeConfig) executeTemplateRequest(method string, client *osclient.Client) bool {

 	if method != "process" {

 		return false

@@ -5,80 +5,82 @@ import (

 	"fmt"

 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

 	clientapi "github.com/openshift/origin/pkg/cmd/client/api"

 )

-// configJSON stores the raw Config JSON representation

-// TODO: Replace this with configapi.Config when it handles the unregistred types.

-type configJSON struct {

-	Items []interface{} `json:"items" yaml:"items"`

-}

-

 // Apply creates and manages resources defined in the Config. It wont stop on

 // error, but it will finish the job and then return list of errors.

+//

+// TODO: Return the output for each resource on success, so the client can

+//       print it out.

 func Apply(data []byte, storage clientapi.ClientMappings) (errs errors.ErrorList) {

-	// Unmarshal the Config JSON using default json package instead of

-	// api.Decode()

-	conf := configJSON{}

+	// Unmarshal the Config JSON manually instead of using runtime.Decode()

+	conf := struct {

+		Items []json.RawMessage `json:"items" yaml:"items"`

+	}{}

 	if err := json.Unmarshal(data, &conf); err != nil {

 		return append(errs, fmt.Errorf("Unable to parse Config: %v", err))

 	}

-	for _, item := range conf.Items {

-		kind, itemID, parseErrs := parseKindAndID(item)

-		if len(parseErrs) != 0 {

-			errs = append(errs, parseErrs...)

+	if len(conf.Items) == 0 {

+		return append(errs, fmt.Errorf("Config.items is empty"))

+	}

+

+	for i, item := range conf.Items {

+		if item == nil || (len(item) == 4 && string(item) == "null") {

+			errs = append(errs, fmt.Errorf("Config.items[%v] is null", i))

 			continue

 		}

-		client, path := getClientAndPath(kind, storage)

+		_, kind, err := runtime.VersionAndKind(item)

+		if err != nil {

+			errs = append(errs, fmt.Errorf("Config.items[%v]: %v", i, err))

+			continue

+		}

+

+		if kind == "" {

+			errs = append(errs, fmt.Errorf("Config.items[%v] has an empty 'kind'", i))

+			continue

+		}

+

+		client, path, err := getClientAndPath(kind, storage)

+		if err != nil {

+			errs = append(errs, fmt.Errorf("Config.items[%v]: %v", i, err))

+			continue

+		}

 		if client == nil {

-			errs = append(errs, fmt.Errorf("The resource %s is not a known type - unable to create %s", kind, itemID))

+			errs = append(errs, fmt.Errorf("Config.items[%v]: Invalid client for 'kind=%v'", i, kind))

 			continue

 		}

-		// Serialize the single Config item back into JSON

-		itemJSON, _ := json.Marshal(item)

+		jsonResource, err := item.MarshalJSON()

+		if err != nil {

+			errs = append(errs, err)

+			continue

+		}

-		request := client.Verb("POST").Path(path).Body(itemJSON)

-		_, err := request.Do().Get()

+		request := client.Verb("POST").Path(path).Body(jsonResource)

+		_, err = request.Do().Get()

 		if err != nil {

-			errs = append(errs, fmt.Errorf("[%s#%s] Failed to create: %v", kind, itemID, err))

+			errs = append(errs, fmt.Errorf("Failed to create Config.items[%v] of 'kind=%v': %v", i, kind, err))

 		}

 	}

 	return

 }

-// getClientAndPath returns the RESTClient and path defined for given resource

-// kind.

-func getClientAndPath(kind string, mappings clientapi.ClientMappings) (client clientapi.RESTClient, path string) {

+// getClientAndPath returns the RESTClient and path defined for a given

+// resource kind. Returns an error when no RESTClient is found.

+func getClientAndPath(kind string, mappings clientapi.ClientMappings) (clientapi.RESTClient, string, error) {

 	for k, m := range mappings {

 		if m.Kind == kind {

-			return m.Client, k

+			return m.Client, k, nil

 		}

 	}

-	return

-}

-

-// parseKindAndID extracts the 'kind' and 'id' fields from the Config item JSON

-// and report errors if these fields are missing.

-func parseKindAndID(item interface{}) (kind, id string, errs errors.ErrorList) {

-	itemMap := item.(map[string]interface{})

-

-	kind, ok := itemMap["kind"].(string)

-	if !ok {

-		errs = append(errs, reportError(item, "Missing 'kind' field for Config item"))

-	}

-

-	id, ok = itemMap["id"].(string)

-	if !ok {

-		errs = append(errs, reportError(item, "Missing 'id' field for Config item"))

-	}

-

-	return

+	return nil, "", fmt.Errorf("No client found for 'kind=%v'", kind)

 }

 // reportError provides a human-readable error message that include the Config

@@ -1,43 +1,74 @@

 package config

 import (

-	"encoding/json"

 	"io/ioutil"

+	"net/http"

+	"net/http/httptest"

 	"testing"

+	kubeapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

 	klatest "github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"

 	kubeclient "github.com/GoogleCloudPlatform/kubernetes/pkg/client"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

 	clientapi "github.com/openshift/origin/pkg/cmd/client/api"

 )

-func TestParseKindAndItem(t *testing.T) {

-	data, _ := ioutil.ReadFile("config_test.json")

-	conf := configJSON{}

-	if err := json.Unmarshal(data, &conf); err != nil {

-		t.Errorf("Failed to parse Config: %v", err)

+func TestApplyInvalidConfig(t *testing.T) {

+	clients := clientapi.ClientMappings{

+		"InvalidClientMapping": {"InvalidClientResource", nil, nil},

 	}

-

-	kind, itemID, err := parseKindAndID(conf.Items[0])

-	if len(err) != 0 {

-		t.Errorf("Failed to parse kind and id from the Config item: %v", err)

+	invalidConfigs := []string{

+		`{}`,

+		`{ "foo": "bar" }`,

+		`{ "items": null }`,

+		`{ "items": "bar" }`,

+		`{ "items": [ null ] }`,

+		`{ "items": [ { "foo": "bar" } ] }`,

+		`{ "items": [ { "kind": "", "apiVersion": "v1beta1" } ] }`,

+		`{ "items": [ { "kind": "UnknownResource", "apiVersion": "v1beta1" } ] }`,

+		`{ "items": [ { "kind": "InvalidClientResource", "apiVersion": "v1beta1" } ] }`,

 	}

-

-	if kind != "Service" && itemID != "frontend" {

-		t.Errorf("Invalid kind and id, should be Service and frontend: %s, %s", kind, itemID)

+	for _, invalidConfig := range invalidConfigs {

+		errs := Apply([]byte(invalidConfig), clients)

+		if len(errs) == 0 {

+			t.Errorf("Expected error while applying invalid Config '%v'", invalidConfig)

+		}

 	}

 }

-func TestApply(t *testing.T) {

-	clients := clientapi.ClientMappings{}

-	invalidData := []byte(`{"items": [ { "foo": "bar" } ]}`)

-	errs := Apply(invalidData, clients)

-	if len(errs) == 0 {

-		t.Errorf("Expected missing kind field for Config item, got %v", errs)

+type FakeResource struct {

+	kubeapi.JSONBase `json:",inline" yaml:",inline"`

+}

+

+func (*FakeResource) IsAnAPIObject() {}

+

+func TestApplySendsData(t *testing.T) {

+	fakeScheme := runtime.NewScheme()

+	// TODO: The below should work with "FakeResource" name instead.

+	fakeScheme.AddKnownTypeWithName("", "", &FakeResource{})

+	fakeScheme.AddKnownTypeWithName("v1beta1", "", &FakeResource{})

+	fakeCodec := runtime.CodecFor(fakeScheme, "v1beta1")

+

+	received := make(chan bool, 1)

+	fakeServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

+		received <- true

+		if r.RequestURI != "/api/v1beta1/FakeMapping" {

+			t.Errorf("Unexpected RESTClient RequestURI. Expected: %v, got: %v.", "/api/v1beta1/FakeMapping", r.RequestURI)

+		}

+	}))

+

+	fakeClient, _ := kubeclient.NewRESTClient(fakeServer.URL, nil, "/api/v1beta1/", fakeCodec)

+	clients := clientapi.ClientMappings{

+		"FakeMapping": {"FakeResource", fakeClient, fakeCodec},

 	}

-	uErrs := Apply([]byte(`{ "foo": }`), clients)

-	if len(uErrs) == 0 {

-		t.Errorf("Expected unmarshal error, got nothing")

+	config := `{ "apiVersion": "v1beta1", "items": [ { "kind": "FakeResource", "apiVersion": "v1beta1" } ] }`

+

+	errs := Apply([]byte(config), clients)

+	if len(errs) != 0 {

+		t.Errorf("Unexpected error while applying valid Config '%v': %v", config, errs)

 	}

+

+	<-received

 }

 func TestGetClientAndPath(t *testing.T) {

@@ -46,7 +77,7 @@ func TestGetClientAndPath(t *testing.T) {

 		"pods":     {"Pod", kubeClient.RESTClient, klatest.Codec},

 		"services": {"Service", kubeClient.RESTClient, klatest.Codec},

 	}

-	client, path := getClientAndPath("Service", testClientMappings)

+	client, path, _ := getClientAndPath("Service", testClientMappings)

 	if client != kubeClient.RESTClient {

 		t.Errorf("Failed to get client for Service")

 	}