Merge pull request #79 from delphi-hub/feature/add_delete_instance

Docker control functionalities with basic test cases

Author: bhermann

app/controllers/ApiRouter.scala

@@ -36,5 +36,12 @@ class ApiRouter @Inject()(irController: InstanceRegistryController, sysControlle
     case GET(p"/numberOfInstances" ? q"componentType=$componentType") => irController.numberOfInstances(componentType)
     case GET(p"/instances" ? q"componentType=$componentType") => irController.instances(componentType)
     case GET(p"/systemInfo") => sysController.getInfo()
+    case POST(p"/postInstance" ? q"componentType=$componentType"& q"name=$name") => irController.postInstance(componentType, name)
+    case POST(p"/startInstance" ? q"instanceID=$instanceID") => irController.handleRequest(action="/start", instanceID)
+    case POST(p"/stopInstance" ? q"instanceID=$instanceID") => irController.handleRequest(action="/stop", instanceID)
+    case POST(p"/pauseInstance" ? q"instanceID=$instanceID") => irController.handleRequest(action="/pause", instanceID)
+    case POST(p"/resumeInstance" ? q"instanceID=$instanceID") => irController.handleRequest(action="/resume", instanceID)
+    case POST(p"/deleteInstance" ? q"instanceID=$instanceID") => irController.handleRequest(action="/delete", instanceID)
+
   }
 }

app/controllers/InstanceRegistryController.scala

@@ -21,28 +21,31 @@ package controllers
 import akka.actor.{ActorRef, ActorSystem}
 import javax.inject.Inject
 import play.api.Configuration
-
-import scala.concurrent.ExecutionContext
 import play.api.libs.concurrent.CustomExecutionContext
+import play.api.libs.json._
 import play.api.libs.ws.WSClient
 import akka.stream.Materializer
 import play.api.libs.streams.ActorFlow
 import actors.{ClientSocketActor, PublishSocketMessageActor}
 import play.api.mvc._
 
+import scala.concurrent.ExecutionContext
+
 
 trait MyExecutionContext extends ExecutionContext
 
 /**
   * Custom execution context. Used to prevent overflowing of the thread pool,
   * which should be used to handle client connections.
+  *
   * @param system
   */
 class MyExecutionContextImpl @Inject()(implicit system: ActorSystem)
   extends CustomExecutionContext(system, "my.executor") with MyExecutionContext
 
 /**
   * Controller used to manage the requests regarding the instance registry.
+  *
   * @param myExecutionContext
   * @param controllerComponents
   * @param ws
@@ -91,4 +94,45 @@ class InstanceRegistryController @Inject()(implicit system: ActorSystem, mat: Ma
     }(myExecutionContext)
   }
 
+  /**
+  * This function is for handling all(start, stop, play, pause, resume) POST request.
+  * To control the instance State
+  * @param componentId
+  */
+
+
+  def handleRequest(action: String, instanceID: String): Action[AnyContent] = Action.async { request =>
+    ws.url(instanceRegistryUri + action)
+      .addQueryStringParameters("Id" -> instanceID)
+      .post("")
+      .map { response =>
+        response.status match {
+          case 202 =>
+            Ok(response.body)
+          case x =>
+            new Status(x)
+        }
+      }(myExecutionContext)
+  }
+
+  /**
+  * This function is for handling an POST request for adding an instance to the Scala web server
+  *
+  * @param componentType
+  * @param name
+  */
+  def postInstance(compType: String, name: String): Action[AnyContent] = Action.async { request =>
+    ws.url(instanceRegistryUri + "/deploy")
+      .addQueryStringParameters("ComponentType" -> compType, "InstanceName" -> name)
+      .post("")
+      .map { response =>
+        response.status match {
+          case 202 =>
+            Ok(response.body)
+          case x =>
+            new Status(x)
+        }
+      }(myExecutionContext)
+  }
+
 }

client/package-lock.json

@@ -47,6 +47,7 @@
     "karma-chrome-launcher": "^2.2.0",
     "karma-cli": "^1.0.1",
     "karma-coverage-istanbul-reporter": "^2.0.4",
+    "karma-firefox-launcher": "^1.1.0",
     "karma-jasmine": "^2.0.0",
     "karma-jasmine-html-reporter": "^1.4.0",
     "protractor": "^5.4.1",

client/package.json

@@ -16,20 +16,62 @@
  * limitations under the License.
  */
 
-import { TestBed, inject } from '@angular/core/testing';
-import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { TestBed, async,fakeAsync, inject } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
 import { ApiService } from './api.service';
-import {HttpClientModule} from '@angular/common/http';
+import { HttpClientModule } from '@angular/common/http';
 
 describe('ApiService', () => {
+
+  let service, http;
+
   beforeEach(() => {
     TestBed.configureTestingModule({
       imports: [HttpClientTestingModule, HttpClientModule],
-      providers: [ApiService]
+      providers: [ApiService],
     });
+
+    service = TestBed.get(ApiService);
+    http = TestBed.get(HttpTestingController);
   });
 
-  it('should be created', inject([ApiService], (service: ApiService) => {
-    expect(service).toBeTruthy();
+
+  afterEach(inject([HttpTestingController], (backend: HttpTestingController) => {
+    backend.verify();
   }));
+
+  it('should be created an instance', inject([ApiService], (apiService: ApiService) => {
+    expect(apiService).toBeTruthy();
+  }));
+
+  it(`should create an instance`,
+    async(inject([ApiService], (apiService: ApiService) => {
+      expect(apiService.postInstance('', '')).not.toBeNull();
+    })));
+
+  it(`should start an instance`,
+    async(inject([ApiService], (apiService: ApiService) => {
+      expect(apiService.startInstance('', '')).not.toBeNull();
+    })));
+
+  it(`should stop an instance`,
+    async(inject([ApiService], (apiService: ApiService) => {
+      expect(apiService.stopInstance('', '')).not.toBeNull();
+    })));
+
+  it(`should pause an instance`,
+    async(inject([ApiService], (apiService: ApiService) => {
+      expect(apiService.pauseInstance('')).not.toBeNull();
+    })));
+
+  it(`should resume an instance`,
+    async(inject([ApiService], (apiService: ApiService) => {
+      expect(apiService.resumeInstance('')).not.toBeNull();
+    })));
+
+  it(`should delete an instance`,
+    async(inject([ApiService], (apiService: ApiService) => {
+      expect(apiService.deleteInstance('')).not.toBeNull();
+    })));
+
 });