Add RemoteTemplate resource to fetch remote templates

pkg/cmd/server/origin/master.go

@@ -213,6 +213,7 @@ func (c *MasterConfig) InstallProtectedAPI(container *restful.Container) []strin
 
 		"templateConfigs": templateregistry.NewREST(),
 		"templates":       templateetcd.NewREST(c.EtcdHelper),
+		"remoteTemplates": templateregistry.NewRemoteREST(v1beta1.Codec),
 
 		"routes": routeregistry.NewREST(routeEtcd),
 

pkg/template/api/register.go

@@ -8,8 +8,10 @@ func init() {
 	api.Scheme.AddKnownTypes("",
 		&Template{},
 		&TemplateList{},
+		&RemoteTemplate{},
 	)
 }
 
-func (*Template) IsAnAPIObject()     {}
-func (*TemplateList) IsAnAPIObject() {}
+func (*Template) IsAnAPIObject()       {}
+func (*TemplateList) IsAnAPIObject()   {}
+func (*RemoteTemplate) IsAnAPIObject() {}

pkg/template/api/types.go

@@ -53,3 +53,12 @@ type Parameter struct {
 	// Optional: From is an input value for the generator.
 	From string
 }
+
+// RemoteTemplate is a resource that points to a URL-accessible template
+type RemoteTemplate struct {
+	kapi.TypeMeta
+	kapi.ObjectMeta
+
+	// URL for the remote template
+	RemoteURL string
+}

pkg/template/api/v1beta1/register.go

@@ -10,7 +10,9 @@ func init() {
 		&TemplateList{},
 	)
 	api.Scheme.AddKnownTypeWithName("v1beta1", "TemplateConfig", &Template{})
+	api.Scheme.AddKnownTypeWithName("v1beta1", "RemoteTemplate", &RemoteTemplate{})
 }
 
-func (*Template) IsAnAPIObject()     {}
-func (*TemplateList) IsAnAPIObject() {}
+func (*Template) IsAnAPIObject()       {}
+func (*TemplateList) IsAnAPIObject()   {}
+func (*RemoteTemplate) IsAnAPIObject() {}

pkg/template/api/v1beta1/types.go

@@ -54,3 +54,12 @@ type Parameter struct {
 	// Optional: From is an input value for the generator.
 	From string `json:"from,omitempty"`
 }
+
+// RemoteTemplate is a resource that points to a template accessible via URL
+type RemoteTemplate struct {
+	kapi.TypeMeta
+	kapi.ObjectMeta
+
+	// URL for the remote template
+	RemoteURL string
+}

pkg/template/api/validation/validation.go

@@ -51,3 +51,10 @@ func validateTemplateBody(template *api.Template) (errs errors.ValidationErrorLi
 	errs = append(errs, validation.ValidateLabels(template.ObjectLabels, "labels")...)
 	return
 }
+
+func ValidateRemoteTemplate(remote *api.RemoteTemplate) (errs errors.ValidationErrorList) {
+	if len(remote.RemoteURL) == 0 {
+		errs = append(errs, errors.NewFieldRequired("RemoteURL", ""))
+	}
+	return
+}

pkg/template/api/validation/validation_test.go

@@ -190,3 +190,19 @@ func TestValidateTemplate(t *testing.T) {
 		}
 	}
 }
+
+func TestValidateRemoteTemplate(t *testing.T) {
+	valid := &api.RemoteTemplate{
+		RemoteURL: "http://a.test.url/test",
+	}
+	invalid := &api.RemoteTemplate{}
+
+	errs := ValidateRemoteTemplate(valid)
+	if len(errs) > 0 {
+		t.Errorf("Unexpected error on valid remote template: %v", errors.NewAggregate(errs))
+	}
+	errs = ValidateRemoteTemplate(invalid)
+	if len(errs) == 0 {
+		t.Errorf("Did not validate remote template properly. Error expected.")
+	}
+}

pkg/template/registry/rest.go

@@ -2,7 +2,9 @@ package registry
 
 import (
 	"fmt"
+	"io/ioutil"
 	"math/rand"
+	"net/http"
 	"time"
 
 	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
@@ -106,3 +108,69 @@ func (s *REST) Create(ctx kapi.Context, obj runtime.Object) (runtime.Object, err
 	}
 	return cfg, nil
 }
+
+// retrieveFunc is a function that fetches the contents of a given URL
+
+type fetcher interface {
+	Fetch(URL string) ([]byte, error)
+}
+
+// RemoteREST implements RESTStorage interface for fetching remote Templates
+type RemoteREST struct {
+	codec   runtime.Codec
+	fetcher fetcher
+}
+
+// NewRemoteREST creates a new RESTStorage interface for fetching remote Template objects
+func NewRemoteREST(codec runtime.Codec) *RemoteREST {
+	remoteREST := &RemoteREST{
+		codec: codec,
+	}
+	remoteREST.fetcher = remoteREST
+	return remoteREST
+}
+
+// New creates a new empty remote template
+func (r *RemoteREST) New() runtime.Object {
+	return &api.RemoteTemplate{}
+}
+
+// Create fetches a remote template and ensures it is a valid template
+func (r *RemoteREST) Create(ctx kapi.Context, obj runtime.Object) (runtime.Object, error) {
+	remote, ok := obj.(*api.RemoteTemplate)
+	if !ok {
+		return nil, errors.NewBadRequest("not a remote template")
+	}
+	body, err := r.fetcher.Fetch(remote.RemoteURL)
+	if err != nil {
+		return nil, err
+	}
+	templateObject, err := r.codec.Decode(body)
+	if err != nil {
+		return nil, errors.NewInternalError(fmt.Errorf("error decoding template from %s: %v",
+			remote.RemoteURL, err))
+	}
+	template, ok := templateObject.(*api.Template)
+	if !ok {
+		return nil, errors.NewInternalError(fmt.Errorf("resource at %s is not a template."))
+	}
+	if errs := validation.ValidateProcessedTemplate(template); len(errs) > 0 {
+		return nil, errors.NewInvalid("template", template.Name, errs)
+	}
+	return template, nil
+}
+
+func (r *RemoteREST) Fetch(remoteURL string) ([]byte, error) {
+	resp, err := http.Get(remoteURL)
+	if err != nil {
+		return nil, errors.NewInternalError(fmt.Errorf("error retrieving template from %s: %v",
+			remoteURL, err))
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, errors.NewInternalError(fmt.Errorf("error reading data from %s: %v",
+			remoteURL, err))
+	}
+	return body, nil
+}

pkg/template/registry/rest_test.go

@@ -1,11 +1,13 @@
 package registry
 
 import (
+	"fmt"
 	"testing"
 
 	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
 
+	"github.com/openshift/origin/pkg/api/v1beta1"
 	config "github.com/openshift/origin/pkg/config/api"
 	template "github.com/openshift/origin/pkg/template/api"
 )
@@ -79,3 +81,61 @@ func TestNewRESTTemplateLabels(t *testing.T) {
 		}
 	}
 }
+
+func TestRemoteRESTCreate(t *testing.T) {
+	codec := v1beta1.Codec
+
+	templateName := "testTemplate"
+	tpl := &template.Template{
+		ObjectMeta: kapi.ObjectMeta{
+			Name: templateName,
+		},
+		Objects: []runtime.Object{
+			&kapi.Service{
+				ObjectMeta: kapi.ObjectMeta{
+					Name: "test-service",
+				},
+				Spec: kapi.ServiceSpec{
+					Port:            80,
+					Protocol:        kapi.ProtocolTCP,
+					SessionAffinity: kapi.AffinityTypeNone,
+				},
+			},
+		},
+	}
+
+	r := RemoteREST{
+		codec: codec,
+		fetcher: &testFetcher{
+			response: []byte(runtime.EncodeOrDie(codec, tpl)),
+		},
+	}
+
+	remote := &template.RemoteTemplate{
+		RemoteURL: "http://test.url/test",
+	}
+
+	obj, err := r.Create(nil, remote)
+	if err != nil {
+		t.Errorf("Unexpected error creating remoteTemplate: %v", err)
+	}
+	resultTpl, ok := obj.(*template.Template)
+	if !ok {
+		t.Errorf("Unexpected object %#v", obj)
+	}
+	if resultTpl.Name != templateName {
+		t.Errorf("Unexpected template name: %s", resultTpl.Name)
+	}
+}
+
+type testFetcher struct {
+	response []byte
+	isErr    bool
+}
+
+func (f *testFetcher) Fetch(URL string) ([]byte, error) {
+	if f.isErr {
+		return nil, fmt.Errorf("Error")
+	}
+	return f.response, nil
+}