Merge pull request #285 from batikanu/deploy-file-backend

Deploy file

Author: bryk

src/app/backend/apihandler.go

@@ -86,6 +86,17 @@ func CreateHttpApiHandler(client *client.Client, heapsterClient *unversioned.RES
 			Writes(Protocols{}))
 	wsContainer.Add(deployWs)
 
+	deployFromFileWs := new(restful.WebService)
+	deployFromFileWs.Path("/api/appdeploymentfromfile").
+	Consumes(restful.MIME_JSON).
+	Produces(restful.MIME_JSON)
+	deployFromFileWs.Route(
+		deployFromFileWs.POST("").
+		To(apiHandler.handleDeployFromFile).
+		Reads(AppDeploymentFromFileSpec{}).
+		Writes(AppDeploymentFromFileSpec{}))
+	wsContainer.Add(deployFromFileWs)
+
 	replicaSetWs := new(restful.WebService)
 	replicaSetWs.Filter(wsLogger)
 	replicaSetWs.Path("/api/replicasets").
@@ -188,6 +199,21 @@ func (apiHandler *ApiHandler) handleDeploy(request *restful.Request, response *r
 	response.WriteHeaderAndEntity(http.StatusCreated, appDeploymentSpec)
 }
 
+// Handles deploy from file API call.
+func (apiHandler *ApiHandler) handleDeployFromFile(request *restful.Request, response *restful.Response) {
+	deploymentSpec := new(AppDeploymentFromFileSpec)
+	if err := request.ReadEntity(deploymentSpec); err != nil {
+		handleInternalError(response, err)
+		return
+	}
+	if err := DeployAppFromFile(deploymentSpec); err != nil {
+		handleInternalError(response, err)
+		return
+	}
+
+	response.WriteHeaderAndEntity(http.StatusCreated, deploymentSpec)
+}
+
 // Handles app name validation API call.
 func (apiHandler *ApiHandler) handleNameValidity(request *restful.Request, response *restful.Response) {
 	spec := new(AppNameValiditySpec)

src/app/backend/deploy.go

@@ -22,6 +22,8 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	kubectlResource "k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/util/intstr"
 )
 
@@ -76,6 +78,15 @@ type AppDeploymentSpec struct {
 	RunAsPrivileged bool `json:"runAsPrivileged"`
 }
 
+// Specification for deployment from file
+type AppDeploymentFromFileSpec struct {
+	// Name of the file
+	Name string `json:"name"`
+
+	// File content
+	Content string `json:"content"`
+}
+
 // Port mapping for an application deployment.
 type PortMapping struct {
 	// Port that will be exposed on the service.
@@ -231,3 +242,38 @@ func getLabelsMap(labels []Label) map[string]string {
 
 	return result
 }
+
+// Deploys an app based on the given yaml or json file.
+func DeployAppFromFile(spec *AppDeploymentFromFileSpec) error {
+	const (
+		validate      = true
+		emptyCacheDir = ""
+	)
+
+	factory := cmdutil.NewFactory(nil)
+	schema, err := factory.Validator(validate, emptyCacheDir)
+	if err != nil {
+		return err
+	}
+
+	mapper, typer := factory.Object()
+	reader := strings.NewReader(spec.Content)
+
+	r := kubectlResource.NewBuilder(mapper, typer, factory.ClientMapperForCommand()).
+		Schema(schema).
+		NamespaceParam(api.NamespaceDefault).DefaultNamespace().
+		Stream(reader, spec.Name).
+		Flatten().
+		Do()
+
+	return r.Visit(func(info *kubectlResource.Info, err error) error {
+		// creates an object from input info
+		_, err = kubectlResource.NewHelper(info.Client, info.Mapping).Create(info.Namespace, true, info.Object)
+		if err != nil {
+			return err
+		}
+		log.Printf("%s is deployed", info.Name)
+		return nil
+	})
+}
+

src/app/externs/backendapi.js

@@ -60,6 +60,14 @@ backendApi.Label;
  */
 backendApi.AppDeploymentSpec;
 
+/**
+ * @typedef {{
+ *   name: string,
+ *   content: string
+ * }}
+ */
+backendApi.AppDeploymentFromFileSpec;
+
 /**
  * @typedef {{
  *   namespace: string,

src/app/frontend/deploy/deployfromfile_controller.js

@@ -12,14 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import {stateName as replicasetliststate} from 'replicasetlist/replicasetlist_state';
+
 /**
  * Controller for the deploy from file directive.
  *
  * @final
  */
 export default class DeployFromFileController {
-  /** @ngInject */
-  constructor() {
+  /**
+   * @param {!angular.$log} $log
+   * @param {!ui.router.$state} $state
+   * @param {!angular.$resource} $resource
+   * @param {!angular.$q} $q
+   * @ngInject */
+  constructor($log, $state, $resource, $q, errorDialog) {
     /**
      * It initializes the scope output parameter
      *
@@ -33,5 +40,55 @@ export default class DeployFromFileController {
      * @export {{name:string, content:string}}
      */
     this.file = {name: '', content: ''};
+
+    /** @private {!angular.$q} */
+    this.q_ = $q;
+
+    /** @private {!angular.$resource} */
+    this.resource_ = $resource;
+
+    /** @private {!angular.$log} */
+    this.log_ = $log;
+
+    /** @private {!ui.router.$state} */
+    this.state_ = $state;
+
+    /**
+     * TODO (cheld) Set correct type after fixing issue #159
+     * @private {!Object}
+     */
+    this.errorDialog_ = errorDialog;
+  }
+
+  /**
+   * Deploys the application based on the state of the controller.
+   *
+   * @export
+   * @return {angular.$q.Promise}
+   */
+  deploy() {
+    /** @type {!backendApi.AppDeploymentFromFileSpec} */
+    let deploymentSpec = {
+      name: this.file.name,
+      content: this.file.content,
+    };
+
+    let defer = this.q_.defer();
+
+    /** @type {!angular.Resource<!backendApi.AppDeploymentFromFileSpec>} */
+    let resource = this.resource_('api/appdeploymentfromfile');
+    resource.save(
+        deploymentSpec,
+        (savedConfig) => {
+          defer.resolve(savedConfig);  // Progress ends
+          this.log_.info('Successfully deployed application: ', savedConfig);
+          this.state_.go(replicasetliststate);
+        },
+        (err) => {
+          defer.reject(err);  // Progress ends
+          this.log_.error('Error deploying application:', err);
+          this.errorDialog_.open('Deploying file has failed', err.data);
+        });
+    return defer.promise;
   }
 }

src/test/backend/deploy_test.go

@@ -159,3 +159,35 @@ func TestGetAvailableProtocols(t *testing.T) {
 			expected, actual)
 	}
 }
+
+func TestDeployAppFromFileWithValidContent(t *testing.T) {
+	validContent := "{\"kind\": \"Namespace\"," +
+		"\"apiVersion\": \"v1\"," +
+		"\"metadata\": {" +
+		"\"name\": \"development\"," +
+		"\"labels\": {\"name\": \"development\"}}}"
+
+	spec := &AppDeploymentFromFileSpec{
+		Name:    "foo-name",
+		Content: validContent,
+	}
+
+	err := DeployAppFromFile(spec)
+
+	if err != nil {
+		t.Errorf("Expected return value to be %#v but got %#v", nil, err)
+	}
+}
+
+func TestDeployAppFromFileWithInvalidContent(t *testing.T) {
+	spec := &AppDeploymentFromFileSpec{
+		Name:    "foo-name",
+		Content: "foo-content-invalid",
+	}
+
+	err := DeployAppFromFile(spec)
+
+	if err == nil {
+		t.Errorf("Expected return value to be an error but got %#v", nil)
+	}
+}

src/test/frontend/deploy/deployfromfile_controller_test.js

@@ -0,0 +1,55 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import DeployFromFileController from 'deploy/deployfromfile_controller';
+import deployModule from 'deploy/deploy_module';
+
+describe('DeployFromFile controller', () => {
+  /** @type {!DeployFromFileController} */
+  let ctrl;
+  /** @type {!angular.$resource} */
+  let mockResource;
+  /** @type {!angular.FormController} */
+  let form;
+
+  beforeEach(() => {
+    angular.mock.module(deployModule.name);
+
+    angular.mock.inject(($controller) => {
+      mockResource = jasmine.createSpy('$resource');
+      ctrl = $controller(DeployFromFileController, {$resource: mockResource}, {form: form});
+    });
+  });
+
+  it('should deploy with file name and content', () => {
+    // given
+    let resourceObject = {
+      save: jasmine.createSpy('save'),
+    };
+    ctrl.file.name = "test.yaml";
+    ctrl.file.content = "test_content";
+    mockResource.and.returnValue(resourceObject);
+    resourceObject.save.and.callFake((spec) => {
+      // then
+      expect(spec.name).toBe("test.yaml");
+      expect(spec.content).toBe('test_content');
+    });
+    // when
+    ctrl.deploy();
+
+    // then
+    expect(resourceObject.save).toHaveBeenCalled();
+  });
+
+});