Merge pull request #1356 from GNS3/enhancement/1353

Enhancement/1353

.github/workflows/main.yml

@@ -2,7 +2,7 @@ name: Build
 on:
   push:
     branches:
-      - '**'  
+      - '**'
   pull_request:
     branches:
       - master
@@ -10,14 +10,17 @@ on:
 
 jobs:
   build:
-    runs-on: windows-latest
-    
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node: [ 14, 16, 18 ]
+    name: Node ${{ matrix.node }}
     steps:
-      - uses: actions/checkout@v2
-      - name: Setup node 14
-        uses: actions/setup-node@v2
+      - uses: actions/checkout@v3
+      - name: Setup ${{ matrix.node }}
+        uses: actions/setup-node@v3
         with:
-          node-version: 14.x
+          node-version: ${{ matrix.node }}
       - uses: c-hive/gha-yarn-cache@v1
       - name: Install JS dependencies
         run: yarn install

e2e/controllers.e2e-spec.ts

@@ -0,0 +1,43 @@
+import { TestHelper } from './helpers/common.po';
+import { ControllersPage } from './helpers/controller.po';
+
+describe('Controllers page', () => {
+  let page: ControllersPage;
+  let helper: TestHelper;
+
+  beforeEach(() => {
+    page = new ControllersPage();
+    helper = new TestHelper();
+  });
+
+  xit('user should have possibility to add controller', async () => {
+    // arrange
+    page.maximizeWindow();
+    await page.navigateToControllersPage();
+
+    // act
+    let text = await page.getAddControllerNotificationText();
+
+    // assert
+    expect(text).toBe("We've discovered GNS3 controller on 127.0.0.1:3080, would you like to add to the list?");
+  });
+
+  it('user should see added controller in the list', async () => {
+    // arrange
+    page.maximizeWindow();
+    await page.navigateToControllersPage();
+    await page.clickAddController();
+    helper.sleep(1000);
+
+    // act
+    let firstRowOfControllersTable = await page.checkControllersTable();
+    let controllerData = [];
+    await helper.asyncForEach(firstRowOfControllersTable, async (element) => {
+      controllerData.push(await element.getText());
+    });
+
+    // assert
+    expect(controllerData).toContain('127.0.0.1');
+    expect(controllerData).toContain('3080');
+  });
+});

e2e/helpers/controller.po.ts

@@ -1,41 +1,41 @@
 import { browser, by } from 'protractor';
 import { TestHelper } from './common.po';
 
-export class ServersPage {
+export class ControllersPage {
   helper = new TestHelper();
 
   maximizeWindow() {
     browser.driver.manage().window().maximize();
   }
 
-  navigateToServersPage() {
-    return browser.get('/servers');
+  navigateToControllersPage() {
+    return browser.get('/controllers');
   }
 
-  getAddServerNotificationText() {
+  getAddControllerNotificationText() {
     return browser.driver.findElement(by.className('mat-card-content')).getText();
   }
 
-  async clickAddServer() {
-    let serversTable = await this.checkServersTable();
-    if (serversTable.length === 0) {
+  async clickAddController() {
+    let controllerTable = await this.checkControllersTable();
+    if (controllerTable.length === 0) {
       let buttons = await browser.driver.findElements(by.className('mat-button mat-button-base'));
       await buttons[3].click();
     }
   }
 
-  checkServersTable() {
+  checkControllersTable() {
     return browser.driver.findElements(by.css('mat-cell'));
   }
 
-  async navigateToServerProjects() {
+  async navigateToControllerProjects() {
     this.helper.sleep(2000);
     let hyperlinks = await browser.driver.findElements(by.css('a.table-link'));
-    let serverLink;
+    let controllerLink;
     await this.helper.asyncForEach(hyperlinks, async (element) => {
       let text = await element.getText();
-      if (text === '127.0.0.1') serverLink = element;
+      if (text === '127.0.0.1') controllerLink = element;
     });
-    await serverLink.click();
+    await controllerLink.click();
   }
 }

e2e/project-map.e2e-spec.ts

@@ -1,24 +1,24 @@
 import { TestHelper } from './helpers/common.po';
 import { ProjectMapPage } from './helpers/project-map.po';
 import { ProjectsPage } from './helpers/project.po';
-import { ServersPage } from './helpers/server.po';
+import { ControllersPage } from './helpers/controller.po';
 
 describe('Project map page', () => {
-  let serversPage: ServersPage;
+  let controllersPage: ControllersPage;
   let projectsPage: ProjectsPage;
   let projectMapPage: ProjectMapPage;
   let helper: TestHelper;
 
   beforeEach(async () => {
-    serversPage = new ServersPage();
+    controllersPage = new ControllersPage();
     projectsPage = new ProjectsPage();
     projectMapPage = new ProjectMapPage();
     helper = new TestHelper();
 
-    serversPage.maximizeWindow();
-    await serversPage.navigateToServersPage();
-    await serversPage.clickAddServer();
-    await serversPage.navigateToServerProjects();
+    controllersPage.maximizeWindow();
+    await controllersPage.navigateToControllersPage();
+    await controllersPage.clickAddController();
+    await controllersPage.navigateToControllerProjects();
     await projectsPage.openAddProjectDialog();
     helper.sleep(2000);
     await projectsPage.createProject();

e2e/projects.e2e-spec.ts

@@ -1,24 +1,24 @@
 import { TestHelper } from './helpers/common.po';
 import { ProjectsPage } from './helpers/project.po';
-import { ServersPage } from './helpers/server.po';
+import { ControllersPage } from './helpers/controller.po';
 
 describe('Projects page', () => {
-  let serversPage: ServersPage;
+  let controllersPage: ControllersPage;
   let projectsPage: ProjectsPage;
   let helper: TestHelper;
 
   beforeEach(() => {
-    serversPage = new ServersPage();
+    controllersPage = new ControllersPage();
     projectsPage = new ProjectsPage();
     helper = new TestHelper();
   });
 
   it('user should have possibility to create new project', async () => {
     // arrange
-    serversPage.maximizeWindow();
-    await serversPage.navigateToServersPage();
-    await serversPage.clickAddServer();
-    await serversPage.navigateToServerProjects();
+    controllersPage.maximizeWindow();
+    await controllersPage.navigateToControllersPage();
+    await controllersPage.clickAddController();
+    await controllersPage.navigateToControllerProjects();
     helper.sleep(2000);
 
     //act
@@ -28,6 +28,6 @@ describe('Projects page', () => {
     helper.sleep(2000);
 
     //assert
-    expect(helper.getCurrentUrl()).toMatch('server/1/project/');
+    expect(helper.getCurrentUrl()).toMatch('controller/1/project/');
   });
 });

e2e/servers.e2e-spec.ts

@@ -1,43 +0,0 @@
-import { TestHelper } from './helpers/common.po';
-import { ServersPage } from './helpers/server.po';
-
-describe('Servers page', () => {
-  let page: ServersPage;
-  let helper: TestHelper;
-
-  beforeEach(() => {
-    page = new ServersPage();
-    helper = new TestHelper();
-  });
-
-  xit('user should have possibility to add server', async () => {
-    // arrange
-    page.maximizeWindow();
-    await page.navigateToServersPage();
-
-    // act
-    let text = await page.getAddServerNotificationText();
-
-    // assert
-    expect(text).toBe("We've discovered GNS3 server on 127.0.0.1:3080, would you like to add to the list?");
-  });
-
-  it('user should see added server in the list', async () => {
-    // arrange
-    page.maximizeWindow();
-    await page.navigateToServersPage();
-    await page.clickAddServer();
-    helper.sleep(1000);
-
-    // act
-    let firstRowOfServersTable = await page.checkServersTable();
-    let serverData = [];
-    await helper.asyncForEach(firstRowOfServersTable, async (element) => {
-      serverData.push(await element.getText());
-    });
-
-    // assert
-    expect(serverData).toContain('127.0.0.1');
-    expect(serverData).toContain('3080');
-  });
-});

electron-builder.yml

@@ -15,7 +15,7 @@ files:
   - renderer.js
   - sentry.js
   - installed-software.js
-  - local-server.js
+  - local-controller.js
   - console-executor.js
   - package.json
 

local-controller.js

@@ -8,9 +8,9 @@ const { app } = require('electron')
 
 const isWin = /^win/.test(process.platform);
 
-let runningServers = {};
+let runningControllers = {};
 
-exports.getLocalServerPath = async () => {
+exports.getLocalControllerPath = async () => {
   let binary = isWin ? 'gns3server.exe': 'gns3server';
   return findBinary('exe.', binary);
 }
@@ -20,27 +20,27 @@ exports.getUbridgePath = async () => {
   return findBinary('ubridge', binary);
 }
 
-exports.startLocalServer = async (server) => {
-  return await run(server, {
+exports.startLocalController = async (controller) => {
+  return await run(controller, {
     logStdout: true
   });
 }
 
-exports.stopLocalServer = async (server) => {
-  return await stop(server.name);
+exports.stopLocalController = async (controller) => {
+  return await stop(controller.name);
 }
 
-exports.getRunningServers = () => {
-  return Object.keys(runningServers);
+exports.getRunningControllers = () => {
+  return Object.keys(runningControllers);
 }
 
-exports.stopAllLocalServers = async () => {
+exports.stopAllLocalControllers = async () => {
   return await stopAll();
 }
 
 async function findBinary(binaryDirectory, filename) {
   const lookupDirectories = [
-    __dirname, 
+    __dirname,
     path.dirname(app.getPath('exe'))
   ];
 
@@ -60,7 +60,7 @@ async function findBinaryInDirectory(baseDirectory, binaryDirectory, filename) {
   }
 
   const files = fs.readdirSync(distDirectory);
-  
+
   let binaryPath = null;
 
   files.forEach((directory) => {
@@ -77,33 +77,33 @@ async function findBinaryInDirectory(baseDirectory, binaryDirectory, filename) {
 }
 
 
-function getServerArguments(server, overrides, configPath) {
-  let serverArguments = [];
-  if(server.host) {
-    serverArguments.push('--host');
-    serverArguments.push(server.host);
+function getControllerArguments(controller, overrides, configPath) {
+  let controllerArguments = [];
+  if(controller.host) {
+    controllerArguments.push('--host');
+    controllerArguments.push(controller.host);
   }
-  if(server.port) {
-    serverArguments.push('--port');
-    serverArguments.push(server.port);
+  if(controller.port) {
+    controllerArguments.push('--port');
+    controllerArguments.push(controller.port);
   }
 
-  serverArguments.push('--local');
+  controllerArguments.push('--local');
 
   if(configPath) {
-    serverArguments.push('--config');
-    serverArguments.push(configPath);
+    controllerArguments.push('--config');
+    controllerArguments.push(configPath);
   }
 
-  return serverArguments;
+  return controllerArguments;
 }
 
-function getChannelForServer(server) {
-  return `local-server-run-${server.name}`;
+function getChannelForController(controller) {
+  return `local-controller-run-${controller.name}`;
 }
 
 function notifyStatus(status) {
-  ipcMain.emit('local-server-status-events', status);
+  ipcMain.emit('local-controller-status-events', status);
 }
 
 function filterOutput(line) {
@@ -120,44 +120,44 @@ function filterOutput(line) {
 }
 
 async function stopAll() {
-  for(var serverName in runningServers) {
-    let result, error = await stop(serverName);
+  for(var controllerName in runningControllers) {
+    let result, error = await stop(controllerName);
   }
-  console.log(`Stopped all servers`);
+  console.log(`Stopped all controllers`);
 }
 
-async function stop(serverName) {
+async function stop(controllerName) {
   let pid = undefined;
 
-  const runningServer = runningServers[serverName];
+  const runningController = runningControllers[controllerName];
 
-  if(runningServer !== undefined && runningServer.process) {
-    pid = runningServer.process.pid;
+  if(runningController !== undefined && runningController.process) {
+    pid = runningController.process.pid;
   }
 
-  console.log(`Stopping '${serverName}' with PID='${pid}'`);
-  
+  console.log(`Stopping '${controllerName}' with PID='${pid}'`);
+
   const stopped = new Promise((resolve, reject) => {
     if(pid === undefined) {
-      resolve(`Server '${serverName} is already stopped`);
-      delete runningServers[serverName];
+      resolve(`Controller '${controllerName} is already stopped`);
+      delete runningControllers[controllerName];
       return;
     }
 
     kill(pid, (error) => {
       if(error) {
-        console.error(`Error occured during stopping '${serverName}' with PID='${pid}'`);
+        console.error(`Error occured during stopping '${controllerName}' with PID='${pid}'`);
         reject(error);
       }
       else {
-        delete runningServers[serverName];
-        console.log(`Stopped '${serverName}' with PID='${pid}'`);
-        resolve(`Stopped '${serverName}' with PID='${pid}'`);
+        delete runningControllers[controllerName];
+        console.log(`Stopped '${controllerName}' with PID='${pid}'`);
+        resolve(`Stopped '${controllerName}' with PID='${pid}'`);
 
         notifyStatus({
-          serverName: serverName,
+          controllerName: controllerName,
           status: 'stopped',
-          message: `Server '${serverName}' stopped'`
+          message: `Controller '${controllerName}' stopped'`
         });
       }
     });
@@ -166,11 +166,11 @@ async function stop(serverName) {
   return stopped;
 }
 
-async function getIniFile(server) {
-  return path.join(app.getPath('userData'), `gns3_server_${server.id}.ini`);
+async function getIniFile(controller) {
+  return path.join(app.getPath('userData'), `gns3_controller_${controller.id}.ini`);
 }
 
-async function configure(configPath, server) {
+async function configure(configPath, controller) {
   if(!fs.existsSync(configPath)) {
     fs.closeSync(fs.openSync(configPath, 'w'));
     console.log(`Configuration file '${configPath}' has been created.`);
@@ -178,20 +178,20 @@ async function configure(configPath, server) {
 
   var config = ini.parse(fs.readFileSync(configPath, 'utf-8'));
 
-  if(server.path) {
-    config.path = server.path;
+  if(controller.path) {
+    config.path = controller.path;
   }
-  if(server.host) {
-    config.host = server.host;
+  if(controller.host) {
+    config.host = controller.host;
   }
-  if(server.port) {
-    config.port = server.port;
+  if(controller.port) {
+    config.port = controller.port;
   }
-  if(server.ubridge_path) {
-    config.ubridge_path = server.ubridge_path;
+  if(controller.ubridge_path) {
+    config.ubridge_path = controller.ubridge_path;
   }
 
-  fs.writeFileSync(configPath, ini.stringify(config, { section: 'Server' }));
+  fs.writeFileSync(configPath, ini.stringify(config, { section: 'Controller' }));
 }
 
 async function setPATHEnv() {
@@ -216,7 +216,7 @@ async function setPATHEnv() {
   process.env.PATH = extra.join(";");
 }
 
-async function run(server, options) {
+async function run(controller, options) {
   if(!options) {
     options = {};
   }
@@ -226,34 +226,34 @@ async function run(server, options) {
 
   console.log(`Configuring`);
 
-  const configPath = await getIniFile(server);
-  await configure(configPath, server);
+  const configPath = await getIniFile(controller);
+  await configure(configPath, controller);
 
   console.log(`Setting up PATH`);
   await setPATHEnv();
 
-  console.log(`Running '${server.path}'`);
+  console.log(`Running '${controller.path}'`);
 
-  let serverProcess = spawn(server.path, getServerArguments(server, {}, configPath));
+  let controllerProcess = spawn(controller.path, getControllerArguments(controller, {}, configPath));
 
   notifyStatus({
-    serverName: server.name,
+    controllerName: controller.name,
     status: 'started',
-    message: `Server '${server.name}' started'`
+    message: `Controller '${controller.name}' started'`
   });
-  
-  runningServers[server.name] = {
-    process: serverProcess
+
+  runningControllers[controller.name] = {
+    process: controllerProcess
   };
 
-  serverProcess.stdout.on('data', function(data) {
+  controllerProcess.stdout.on('data', function(data) {
     const line = data.toString();
     const { isCritical, errorMessage } = filterOutput(line);
     if(isCritical) {
       notifyStatus({
-        serverName: server.name,
+        controllerName: controller.name,
         status: 'stderr',
-        message: `Server reported error: '${errorMessage}`
+        message: `Controller reported error: '${errorMessage}`
       });
     }
 
@@ -262,25 +262,25 @@ async function run(server, options) {
     }
   });
 
-  serverProcess.stderr.on('data', function(data) {
+  controllerProcess.stderr.on('data', function(data) {
     if(logSterr) {
       console.log(data.toString());
     }
   });
 
-  serverProcess.on('exit', (code, signal) => {
+  controllerProcess.on('exit', (code, signal) => {
     notifyStatus({
-      serverName: server.name,
+      controllerName: controller.name,
       status: 'errored',
-      message: `Server '${server.name}' has exited with status='${code}'`
+      message: `controller '${controller.name}' has exited with status='${code}'`
     });
   });
 
-  serverProcess.on('error', (err) => {
+  controllerProcess.on('error', (err) => {
     notifyStatus({
-      serverName: server.name,
+      controllerName: controller.name,
       status: 'errored',
-      message: `Server errored: '${err}`
+      message: `Controller errored: '${err}`
     });
   });
 
@@ -297,9 +297,9 @@ async function main() {
 }
 
 if(ipcMain) {
-  ipcMain.on('local-server-run', async function (event, server) {
-    const responseChannel = getChannelForServer();
-    await run(server);
+  ipcMain.on('local-controller-run', async function (event, controller) {
+    const responseChannel = getChannelForController();
+    await run(controller);
     event.sender.send(responseChannel, {
       success: true
     });
@@ -318,4 +318,4 @@ if (require.main === module) {
   });
 
   main();
-}
+}

src/ReleaseNotes.txt

@@ -67,7 +67,7 @@ GNS3 Web UI 2020.2.0-beta.4
 Bug Fixes
 - New port setting for GNS3 VM preferences
 - Option to auto-hide menu toolbar on the left side
-- Server type in template preferences
+-Controller  type in template preferences
 - Error when selecting existing Docker image
 - Default values in templates
 - TypeError: Cannot read property 'message' of undefined

src/app/app-routing.module.ts

@@ -1,6 +1,6 @@
 import { NgModule } from '@angular/core';
 import { RouterModule, Routes } from '@angular/router';
-import { BundledServerFinderComponent } from './components/bundled-server-finder/bundled-server-finder.component';
+import { BundledControllerFinderComponent } from './components/bundled-controller-finder/bundled-controller-finder.component';
 import { DirectLinkComponent } from './components/direct-link/direct-link.component';
 import { HelpComponent } from './components/help/help.component';
 import { InstalledSoftwareComponent } from './components/installed-software/installed-software.component';
@@ -44,7 +44,7 @@ import { VpcsTemplateDetailsComponent } from './components/preferences/vpcs/vpcs
 import { VpcsTemplatesComponent } from './components/preferences/vpcs/vpcs-templates/vpcs-templates.component';
 import { ProjectMapComponent } from './components/project-map/project-map.component';
 import { ProjectsComponent } from './components/projects/projects.component';
-import { ServersComponent } from './components/servers/servers.component';
+import { ControllersComponent } from './components/controllers/controllers.component';
 import { ConsoleComponent } from './components/settings/console/console.component';
 import { SettingsComponent } from './components/settings/settings.component';
 import { ListOfSnapshotsComponent } from './components/snapshots/list-of-snapshots/list-of-snapshots.component';
@@ -53,7 +53,7 @@ import { WebConsoleFullWindowComponent } from './components/web-console-full-win
 import { ConsoleGuard } from './guards/console-guard';
 import { LoginGuard } from './guards/login-guard';
 import { DefaultLayoutComponent } from './layouts/default-layout/default-layout.component';
-import { ServerResolve } from './resolvers/server-resolve';
+import { ControllerResolve } from './resolvers/controller-resolve';
 import { UserManagementComponent } from './components/user-management/user-management.component';
 import { LoggedUserComponent } from './components/users/logged-user/logged-user.component';
 import { ImageManagerComponent } from './components/image-manager/image-manager.component';
@@ -80,151 +80,150 @@ const routes: Routes = [
     path: '',
     component: DefaultLayoutComponent,
     children: [
-      { path: '', redirectTo: 'servers', pathMatch: 'full' },
-      { path: 'servers', component: ServersComponent },
-      { path: 'bundled', component: BundledServerFinderComponent },
-      { path: 'server/:server_id/login', component: LoginComponent },
-      { path: 'server/:server_id/loggeduser', component: LoggedUserComponent },
-      {path : 'server/:server_id/image-manager', component: ImageManagerComponent},
+      { path: '', redirectTo: 'controllers', pathMatch: 'full' },
+      { path: 'controllers', component: ControllersComponent },
+      { path: 'bundled', component: BundledControllerFinderComponent },
+      { path: 'controller/:controller_id/login', component: LoginComponent },
+      { path: 'controller/:controller_id/loggeduser', component: LoggedUserComponent },
+      {path : 'controller/:controller_id/image-manager', component: ImageManagerComponent},
       {
-        path: 'server/:server_id/projects',
+        path: 'controller/:controller_id/projects',
         component: ProjectsComponent,
         canActivate: [LoginGuard],
-        resolve: { server: ServerResolve },
+        resolve: { controller: ControllerResolve },
       },
       { path: 'help', component: HelpComponent },
       { path: 'settings', component: SettingsComponent },
       { path: 'settings/console', component: ConsoleComponent },
       {
-        path: 'server/:server_id/management/users/:user_id',
+        path: 'controller/:controller_id/management/users/:user_id',
         component: UserDetailComponent,
         canActivate: [LoginGuard],
         resolve: {
           user: UserDetailResolver,
           groups: UserGroupsResolver,
           permissions: UserPermissionsResolver,
-          server: ServerResolve},
+          controller: ControllerResolve},
       },
       { path: 'installed-software', component: InstalledSoftwareComponent },
-      { path: 'server/:server_id/systemstatus', component: SystemStatusComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/systemstatus', component: SystemStatusComponent, canActivate: [LoginGuard] },
 
-      { path: 'server/:server_ip/:server_port/project/:project_id', component: DirectLinkComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_ip/:controller_port/project/:project_id', component: DirectLinkComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/project/:project_id/snapshots',
+        path: 'controller/:controller_id/project/:project_id/snapshots',
         component: ListOfSnapshotsComponent,
         canActivate: [LoginGuard],
-        resolve: { server: ServerResolve },
+        resolve: { controller: ControllerResolve },
       },
-      { path: 'server/:server_id/preferences', component: PreferencesComponent, canActivate: [LoginGuard] },
-      // { path: 'server/:server_id/preferences/general', component: GeneralPreferencesComponent },
-      { path: 'server/:server_id/preferences/builtin', component: BuiltInPreferencesComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences', component: PreferencesComponent, canActivate: [LoginGuard] },
+      // { path: 'controller/:controller_id/preferences/general', component: GeneralPreferencesComponent },
+      { path: 'controller/:controller_id/preferences/builtin', component: BuiltInPreferencesComponent, canActivate: [LoginGuard] },
 
-      { path: 'server/:server_id/preferences/builtin/ethernet-hubs', component: EthernetHubsTemplatesComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/builtin/ethernet-hubs', component: EthernetHubsTemplatesComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/builtin/ethernet-hubs/addtemplate',
+        path: 'controller/:controller_id/preferences/builtin/ethernet-hubs/addtemplate',
         component: EthernetHubsAddTemplateComponent,
         canActivate: [LoginGuard]
       },
       {
-        path: 'server/:server_id/preferences/builtin/ethernet-hubs/:template_id',
+        path: 'controller/:controller_id/preferences/builtin/ethernet-hubs/:template_id',
         component: EthernetHubsTemplateDetailsComponent,
         canActivate: [LoginGuard]
       },
 
       {
-        path: 'server/:server_id/preferences/builtin/ethernet-switches',
+        path: 'controller/:controller_id/preferences/builtin/ethernet-switches',
         component: EthernetSwitchesTemplatesComponent,
         canActivate: [LoginGuard]
       },
       {
-        path: 'server/:server_id/preferences/builtin/ethernet-switches/addtemplate',
+        path: 'controller/:controller_id/preferences/builtin/ethernet-switches/addtemplate',
         component: EthernetSwitchesAddTemplateComponent,
         canActivate: [LoginGuard]
       },
       {
-        path: 'server/:server_id/preferences/builtin/ethernet-switches/:template_id',
+        path: 'controller/:controller_id/preferences/builtin/ethernet-switches/:template_id',
         component: EthernetSwitchesTemplateDetailsComponent,
         canActivate: [LoginGuard]
       },
 
-      { path: 'server/:server_id/preferences/builtin/cloud-nodes', component: CloudNodesTemplatesComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/builtin/cloud-nodes', component: CloudNodesTemplatesComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/builtin/cloud-nodes/addtemplate',
+        path: 'controller/:controller_id/preferences/builtin/cloud-nodes/addtemplate',
         component: CloudNodesAddTemplateComponent,
         canActivate: [LoginGuard]
       },
       {
-        path: 'server/:server_id/preferences/builtin/cloud-nodes/:template_id',
+        path: 'controller/:controller_id/preferences/builtin/cloud-nodes/:template_id',
         component: CloudNodesTemplateDetailsComponent,
         canActivate: [LoginGuard]
       },
 
-      //{ path: 'server/:server_id/preferences/dynamips', component: DynamipsPreferencesComponent },
-      { path: 'server/:server_id/preferences/dynamips/templates', component: IosTemplatesComponent, canActivate: [LoginGuard] },
-      { path: 'server/:server_id/preferences/dynamips/templates/addtemplate', component: AddIosTemplateComponent, canActivate: [LoginGuard] },
-      { path: 'server/:server_id/preferences/dynamips/templates/:template_id', component: IosTemplateDetailsComponent, canActivate: [LoginGuard] },
+      //{ path: 'controller/:controller_id/preferences/dynamips', component: DynamipsPreferencesComponent },
+      { path: 'controller/:controller_id/preferences/dynamips/templates', component: IosTemplatesComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/dynamips/templates/addtemplate', component: AddIosTemplateComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/dynamips/templates/:template_id', component: IosTemplateDetailsComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/dynamips/templates/:template_id/copy',
+        path: 'controller/:controller_id/preferences/dynamips/templates/:template_id/copy',
         component: CopyIosTemplateComponent,
         canActivate: [LoginGuard]
       },
 
-      // { path: 'server/:server_id/preferences/qemu', component: QemuPreferencesComponent },
-      { path: 'server/:server_id/preferences/qemu/templates', component: QemuVmTemplatesComponent, canActivate: [LoginGuard] },
+      // { path: 'controller/:controller_id/preferences/qemu', component: QemuPreferencesComponent },
+      { path: 'controller/:controller_id/preferences/qemu/templates', component: QemuVmTemplatesComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/qemu/templates/:template_id/copy',
+        path: 'controller/:controller_id/preferences/qemu/templates/:template_id/copy',
         component: CopyQemuVmTemplateComponent,
         canActivate: [LoginGuard]
       },
-      { path: 'server/:server_id/preferences/qemu/templates/:template_id', component: QemuVmTemplateDetailsComponent, canActivate: [LoginGuard] },
-      { path: 'server/:server_id/preferences/qemu/addtemplate', component: AddQemuVmTemplateComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/qemu/templates/:template_id', component: QemuVmTemplateDetailsComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/qemu/addtemplate', component: AddQemuVmTemplateComponent, canActivate: [LoginGuard] },
 
-      // { path: 'server/:server_id/preferences/vpcs', component: VpcsPreferencesComponent },
-      { path: 'server/:server_id/preferences/vpcs/templates', component: VpcsTemplatesComponent, canActivate: [LoginGuard] },
-      { path: 'server/:server_id/preferences/vpcs/templates/:template_id', component: VpcsTemplateDetailsComponent, canActivate: [LoginGuard] },
-      { path: 'server/:server_id/preferences/vpcs/addtemplate', component: AddVpcsTemplateComponent, canActivate: [LoginGuard] },
+      // { path: 'controller/:controller_id/preferences/vpcs', component: VpcsPreferencesComponent },
+      { path: 'controller/:controller_id/preferences/vpcs/templates', component: VpcsTemplatesComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/vpcs/templates/:template_id', component: VpcsTemplateDetailsComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/vpcs/addtemplate', component: AddVpcsTemplateComponent, canActivate: [LoginGuard] },
 
-      // { path: 'server/:server_id/preferences/virtualbox', component: VirtualBoxPreferencesComponent },
-      { path: 'server/:server_id/preferences/virtualbox/templates', component: VirtualBoxTemplatesComponent, canActivate: [LoginGuard] },
+      // { path: 'controller/:controller_id/preferences/virtualbox', component: VirtualBoxPreferencesComponent },
+      { path: 'controller/:controller_id/preferences/virtualbox/templates', component: VirtualBoxTemplatesComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/virtualbox/templates/:template_id',
+        path: 'controller/:controller_id/preferences/virtualbox/templates/:template_id',
         component: VirtualBoxTemplateDetailsComponent,
         canActivate: [LoginGuard]
       },
-      { path: 'server/:server_id/preferences/virtualbox/addtemplate', component: AddVirtualBoxTemplateComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/virtualbox/addtemplate', component: AddVirtualBoxTemplateComponent, canActivate: [LoginGuard] },
 
-      // { path: 'server/:server_id/preferences/vmware', component: VmwarePreferencesComponent },
-      { path: 'server/:server_id/preferences/vmware/templates', component: VmwareTemplatesComponent, canActivate: [LoginGuard] },
+      // { path: 'controller/:controller_id/preferences/vmware', component: VmwarePreferencesComponent },
+      { path: 'controller/:controller_id/preferences/vmware/templates', component: VmwareTemplatesComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/vmware/templates/:template_id',
+        path: 'controller/:controller_id/preferences/vmware/templates/:template_id',
         component: VmwareTemplateDetailsComponent,
         canActivate: [LoginGuard]
       },
-      { path: 'server/:server_id/preferences/vmware/addtemplate', component: AddVmwareTemplateComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/vmware/addtemplate', component: AddVmwareTemplateComponent, canActivate: [LoginGuard] },
 
-      { path: 'server/:server_id/preferences/docker/templates', component: DockerTemplatesComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/docker/templates', component: DockerTemplatesComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/docker/templates/:template_id',
+        path: 'controller/:controller_id/preferences/docker/templates/:template_id',
         component: DockerTemplateDetailsComponent,
         canActivate: [LoginGuard]
       },
       {
-        path: 'server/:server_id/preferences/docker/templates/:template_id/copy',
+        path: 'controller/:controller_id/preferences/docker/templates/:template_id/copy',
         component: CopyDockerTemplateComponent,
         canActivate: [LoginGuard]
       },
-      { path: 'server/:server_id/preferences/docker/addtemplate', component: AddDockerTemplateComponent, canActivate: [LoginGuard] },
-
-      { path: 'server/:server_id/preferences/iou/templates', component: IouTemplatesComponent, canActivate: [LoginGuard] },
-      { path: 'server/:server_id/preferences/iou/templates/:template_id', component: IouTemplateDetailsComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/docker/addtemplate', component: AddDockerTemplateComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/iou/templates', component: IouTemplatesComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id//preferences/iou/templates/:template_id', component: IouTemplateDetailsComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/preferences/iou/templates/:template_id/copy',
+        path: 'controller/:controller_id/preferences/iou/templates/:template_id/copy',
         component: CopyIouTemplateComponent,
         canActivate: [LoginGuard]
       },
-      { path: 'server/:server_id/preferences/iou/addtemplate', component: AddIouTemplateComponent, canActivate: [LoginGuard] },
+      { path: 'controller/:controller_id/preferences/iou/addtemplate', component: AddIouTemplateComponent, canActivate: [LoginGuard] },
       {
-        path: 'server/:server_id/management',
+        path: 'controller/:controller_id/management',
         component: ManagementComponent,
         children: [
           {
@@ -239,63 +238,64 @@ const routes: Routes = [
             path: 'roles',
             component: RoleManagementComponent
           },
-          {path: 'permissions',
-          component: PermissionsManagementComponent
+          {
+            path: 'permissions',
+            component: PermissionsManagementComponent
           }
         ]
       },
       {
-        path: 'server/:server_id/management/groups/:user_group_id',
+        path: 'controller/:controller_id/management/groups/:user_group_id',
         component: GroupDetailsComponent,
         resolve: {
           members: GroupMembersResolver,
-          server: ServerResolve,
+          controller: ControllerResolve,
           group: GroupResolver,
           roles: GroupRoleResolver
         }
       },
       {
-        path: 'server/:server_id/management/roles/:role_id',
+        path: 'controller/:controller_id/management/roles/:role_id',
         component: RoleDetailComponent,
         resolve: {
           role: RoleDetailResolver,
-          server: ServerResolve
+          controller: ControllerResolve
         }
       },
       {
-        path: 'server/:server_id/management/roles/:role_id/permissions',
+        path: 'controller/:controller_id/management/roles/:role_id/permissions',
         component: RolePermissionsComponent,
         resolve: {
           role: RoleDetailResolver,
-          server: ServerResolve,
+          controller: ControllerResolve,
           permissions: PermissionResolver
         }
       },
       {
-        path: 'server/:server_id/management/users/:user_id/permissions',
+        path: 'controller/:controller_id/management/users/:user_id/permissions',
         component: UserPermissionsComponent,
         resolve: {
           user: UserDetailResolver,
           userPermissions: UserPermissionsResolver,
-          server: ServerResolve,
+          controller: ControllerResolve,
           permissions: PermissionResolver
         }
       }
     ],
   },
   {
-    path: 'server/:server_id/project/:project_id',
+    path: 'controller/:controller_id/project/:project_id',
     component: ProjectMapComponent,
     canActivate: [LoginGuard],
     canDeactivate: [ConsoleGuard],
   },
   {
-    path: 'server/:server_id/project/:project_id/nodes/:node_id',
+    path: 'controller/:controller_id/project/:project_id/nodes/:node_id',
     component: WebConsoleFullWindowComponent,
     canActivate: [LoginGuard]
   },
   {
-    path: 'static/web-ui/server/:server_id/project/:project_id/nodes/:node_id',
+    path: 'static/web-ui/controller/:controller_id/project/:project_id/nodes/:node_id',
     component: WebConsoleFullWindowComponent,
     canActivate: [LoginGuard]
   },

src/app/app.module.ts

@@ -30,7 +30,7 @@ import { ProgressDialogService } from './common/progress-dialog/progress-dialog.
 import { ProgressComponent } from './common/progress/progress.component';
 import { ProgressService } from './common/progress/progress.service';
 import { AdbutlerComponent } from './components/adbutler/adbutler.component';
-import { BundledServerFinderComponent } from './components/bundled-server-finder/bundled-server-finder.component';
+import { BundledControllerFinderComponent } from './components/bundled-controller-finder/bundled-controller-finder.component';
 import { InformationDialogComponent } from './components/dialogs/information-dialog.component';
 import { DirectLinkComponent } from './components/direct-link/direct-link.component';
 import { DrawingAddedComponent } from './components/drawings-listeners/drawing-added/drawing-added.component';
@@ -188,9 +188,9 @@ import { ProjectNameValidator } from './components/projects/models/projectNameVa
 import { NavigationDialogComponent } from './components/projects/navigation-dialog/navigation-dialog.component';
 import { ProjectsComponent } from './components/projects/projects.component';
 import { SaveProjectDialogComponent } from './components/projects/save-project-dialog/save-project-dialog.component';
-import { AddServerDialogComponent } from './components/servers/add-server-dialog/add-server-dialog.component';
-import { ServerDiscoveryComponent } from './components/servers/server-discovery/server-discovery.component';
-import { ServersComponent } from './components/servers/servers.component';
+import { AddControllerDialogComponent } from './components/controllers/add-controller-dialog/add-controller-dialog.component';
+import { ControllerDiscoveryComponent } from './components/controllers/controller-discovery/controller-discovery.component';
+import { ControllersComponent } from './components/controllers/controllers.component';
 import { ConsoleComponent } from './components/settings/console/console.component';
 import { SettingsComponent } from './components/settings/settings.component';
 import { CreateSnapshotDialogComponent } from './components/snapshots/create-snapshot-dialog/create-snapshot-dialog.component';
@@ -215,7 +215,7 @@ import { LoginGuard } from './guards/login-guard';
 import { ProjectWebServiceHandler } from './handlers/project-web-service-handler';
 import { DefaultLayoutComponent } from './layouts/default-layout/default-layout.component';
 import { MATERIAL_IMPORTS } from './material.imports';
-import { ServerResolve } from './resolvers/server-resolve';
+import { ControllerResolve } from './resolvers/controller-resolve';
 import { ApplianceService } from './services/appliances.service';
 import { BuiltInTemplatesConfigurationService } from './services/built-in-templates-configuration.service';
 import { BuiltInTemplatesService } from './services/built-in-templates.service';
@@ -225,7 +225,7 @@ import { DockerService } from './services/docker.service';
 import { DrawingService } from './services/drawing.service';
 import { ExternalSoftwareDefinitionService } from './services/external-software-definition.service';
 import { GoogleAnalyticsService } from './services/google-analytics.service';
-import { HttpServer, ServerErrorHandler } from './services/http-server.service';
+import { HttpController, ControllerErrorHandler } from './services/http-controller.service';
 import { InfoService } from './services/info.service';
 import { InstalledSoftwareService } from './services/installed-software.service';
 import { IosConfigurationService } from './services/ios-configuration.service';
@@ -244,10 +244,10 @@ import { ProjectService } from './services/project.service';
 import { QemuConfigurationService } from './services/qemu-configuration.service';
 import { QemuService } from './services/qemu.service';
 import { RecentlyOpenedProjectService } from './services/recentlyOpenedProject.service';
-import { ServerManagementService } from './services/server-management.service';
-import { ServerSettingsService } from './services/server-settings.service';
-import { ServerDatabase } from './services/server.database';
-import { ServerService } from './services/server.service';
+import { ControllerManagementService } from './services/controller-management.service';
+import { ControllerSettingsService } from './services/controller-settings.service';
+import { ControllerDatabase } from './services/controller.database';
+import { ControllerService } from './services/controller.service';
 import { SettingsService } from './services/settings.service';
 import { ConsoleService } from './services/settings/console.service';
 import { DefaultConsoleService } from './services/settings/default-console.service';
@@ -329,8 +329,8 @@ import { NodesMenuConfirmationDialogComponent } from './components/project-map/n
     LoggedUserComponent,
     ProjectMapComponent,
     LoginComponent,
-    ServersComponent,
-    AddServerDialogComponent,
+    ControllersComponent,
+    AddControllerDialogComponent,
     CreateSnapshotDialogComponent,
     SnapshotMenuItemComponent,
     ProjectsComponent,
@@ -361,9 +361,9 @@ import { NodesMenuConfirmationDialogComponent } from './components/project-map/n
     SuspendLinkActionComponent,
     SettingsComponent,
     PreferencesComponent,
-    BundledServerFinderComponent,
+    BundledControllerFinderComponent,
     ProgressComponent,
-    ServerDiscoveryComponent,
+    ControllerDiscoveryComponent,
     NodeSelectInterfaceComponent,
     DrawLinkToolComponent,
     InstalledSoftwareComponent,
@@ -593,12 +593,12 @@ import { NodesMenuConfirmationDialogComponent } from './components/project-map/n
     VersionService,
     ProjectService,
     SymbolService,
-    ServerService,
+    ControllerService,
     TemplateService,
     NodeService,
     LinkService,
     DrawingService,
-    HttpServer,
+    HttpController,
     SnapshotService,
     ProgressDialogService,
     ToasterService,
@@ -611,11 +611,11 @@ import { NodesMenuConfirmationDialogComponent } from './components/project-map/n
     SelectionManager,
     InRectangleHelper,
     DrawingsDataSource,
-    ServerErrorHandler,
-    ServerDatabase,
+    ControllerErrorHandler,
+    ControllerDatabase,
     ProjectNameValidator,
     ToolsService,
-    ServerSettingsService,
+    ControllerSettingsService,
     QemuService,
     VpcsService,
     TemplateMocksService,
@@ -637,7 +637,7 @@ import { NodesMenuConfirmationDialogComponent } from './components/project-map/n
     IouService,
     IouConfigurationService,
     RecentlyOpenedProjectService,
-    ServerManagementService,
+    ControllerManagementService,
     MapScaleService,
     ConsoleService,
     DefaultConsoleService,
@@ -652,7 +652,7 @@ import { NodesMenuConfirmationDialogComponent } from './components/project-map/n
     ThemeService,
     GoogleAnalyticsService,
     NodeConsoleService,
-    ServerResolve,
+    ControllerResolve,
     LoginGuard,
     ConsoleGuard,
     Title,
@@ -662,7 +662,7 @@ import { NodesMenuConfirmationDialogComponent } from './components/project-map/n
     UserService
   ],
   entryComponents: [
-    AddServerDialogComponent,
+    AddControllerDialogComponent,
     CreateSnapshotDialogComponent,
     ProgressDialogComponent,
     TemplateListDialogComponent,

src/app/cartography/components/d3-map/d3-map.component.html

@@ -44,6 +44,6 @@
 <app-drawing-resizing></app-drawing-resizing>
 <app-selection-control></app-selection-control>
 <app-selection-select></app-selection-select>
-<app-text-editor #textEditor [server]="server" [svg]="svg"></app-text-editor>
+<app-text-editor #textEditor [controller]="controller" [svg]="svg"></app-text-editor>
 <app-draggable-selection [svg]="svg"></app-draggable-selection>
 <app-link-editing [svg]="svg"></app-link-editing>

src/app/cartography/components/d3-map/d3-map.component.ts

@@ -13,7 +13,7 @@ import { select, Selection } from 'd3-selection';
 import { Subscription } from 'rxjs';
 import { Link } from '../../../models/link';
 import { Project } from '../../../models/project';
-import { Server } from '../../../models/server';
+import { Controller } from '../../../models/controller';
 import { Symbol } from '../../../models/symbol';
 import { MapScaleService } from '../../../services/mapScale.service';
 import { MapSettingsService } from '../../../services/mapsettings.service';
@@ -43,7 +43,7 @@ export class D3MapComponent implements OnInit, OnChanges, OnDestroy {
   @Input() drawings: Drawing[] = [];
   @Input() symbols: Symbol[] = [];
   @Input() project: Project;
-  @Input() server: Server;
+  @Input() controller: Controller;
 
   @Input() width = 1500;
   @Input() height = 600;

src/app/cartography/components/text-editor/text-editor.component.ts

@@ -13,7 +13,7 @@ import { select } from 'd3-selection';
 import { Subscription } from 'rxjs';
 import { StyleProperty } from '../../../components/project-map/drawings-editors/text-editor/text-editor.component';
 import { Link } from '../../../models/link';
-import { Server } from '../../../models/server';
+import { Controller } from '../../../models/controller';
 import { LinkService } from '../../../services/link.service';
 import { MapScaleService } from '../../../services/mapScale.service';
 import { ToolsService } from '../../../services/tools.service';
@@ -37,7 +37,7 @@ import { Node } from '../../models/node';
 export class TextEditorComponent implements OnInit, OnDestroy {
   @ViewChild('temporaryTextElement') temporaryTextElement: ElementRef;
   @Input('svg') svg: SVGSVGElement;
-  @Input('server') server: Server;
+  @Input('controller') controller: Controller;
 
   leftPosition: string = '0px';
   topPosition: string = '0px';
@@ -185,7 +185,7 @@ export class TextEditorComponent implements OnInit, OnDestroy {
           let link: Link = this.linksDataSource.get(this.editedLink.linkId);
           link.nodes.find((n) => n.node_id === this.editedNode.node_id).label.text = innerText;
 
-          this.linkService.updateLink(this.server, link).subscribe((link: Link) => {
+          this.linkService.updateLink(this.controller, link).subscribe((link: Link) => {
             rootElement
               .selectAll<SVGTextElement, TextElement>('text.editingMode')
               .attr('visibility', 'visible')

src/app/cartography/models/map/map-link.ts

@@ -16,13 +16,13 @@ export class MapLink implements Indexed {
   suspend: boolean;
   link_style?: LinkStyle;
 
-  distance: number; // this is not from server
-  length: number; // this is not from server
-  source: MapNode; // this is not from server
-  target: MapNode; // this is not from server
+  distance: number; // this is not from controller
+  length: number; // this is not from controller
+  source: MapNode; // this is not from controller
+  target: MapNode; // this is not from controller
 
-  isSelected = false; // this is not from server
-  isMultiplied = false; // this is not from server
-  x: number; // this is not from server
-  y: number; // this is not from server
+  isSelected = false; // this is not from controller
+  isMultiplied = false; // this is not from controller
+  x: number; // this is not from controller
+  y: number; // this is not from controller
 }

src/app/common/uploading-processbar/uploading-processbar.component.ts

@@ -22,7 +22,6 @@ export class UploadingProcessbarComponent implements OnInit {
 
   ngOnInit() {
    this.upload_file_type =  this.data.upload_file_type 
-    debugger
     this.subscription = this._US.currentCount.subscribe((count:number) => {
       this.uploadProgress = count;
       if (this.uploadProgress === 100 || this.uploadProgress == null ) {

src/app/components/bundled-controller-finder/bundled-controller-finder.component.spec.ts

@@ -0,0 +1,64 @@
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { ComponentFixture, fakeAsync, TestBed, tick } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { Router } from '@angular/router';
+import { RouterTestingModule } from '@angular/router/testing';
+import { ProgressService } from '../../common/progress/progress.service';
+import{ Controller } from '../../models/controller';
+import { ControllerService } from '../../services/controller.service';
+import { MockedControllerService } from '../../services/controller.service.spec';
+import { MockedProgressService } from '../project-map/project-map.component.spec';
+import { BundledControllerFinderComponent } from './bundled-controller-finder.component';
+
+describe('BundledControllerFinderComponent', () => {
+  let component: BundledControllerFinderComponent;
+  let fixture: ComponentFixture<BundledControllerFinderComponent>;
+  let router: any;
+  let service: ControllerService;
+  let progressService: MockedProgressService = new MockedProgressService();
+  let controllerServiceMock: jasmine.SpyObj<ControllerService>;
+
+
+  beforeEach(async () => {
+    router = {
+      navigate: jasmine.createSpy('navigate'),
+    };
+
+    
+
+    controllerServiceMock = jasmine.createSpyObj<ControllerService>([
+      "getLocalController"
+    ]);
+
+
+    await TestBed.configureTestingModule({
+      providers: [
+        { provide: Router, useValue: router },
+        { provide: ControllerService, useValue: controllerServiceMock },
+        { provide: ProgressService, useValue: progressService },
+      ],
+      declarations: [BundledControllerFinderComponent],
+      schemas: [NO_ERRORS_SCHEMA],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(BundledControllerFinderComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create and redirect to controller', fakeAsync(() => {
+    const controller = new Controller ();
+    controller.id = 99;
+    controllerServiceMock.getLocalController.and.returnValue(
+      Promise.resolve(controller)
+    );
+    expect(component).toBeTruthy();
+    tick(101)
+    fixture.detectChanges()
+    fixture.whenStable().then(() => {
+      expect(controllerServiceMock.getLocalController).toHaveBeenCalledWith('vps3.gns3.net',3000);
+      expect(router.navigate).toHaveBeenCalledWith(['/controller', 99, 'projects']);
+    })
+    service = TestBed.inject(ControllerService);
+  }));
+});

src/app/components/bundled-controller-finder/bundled-controller-finder.component.ts

@@ -2,18 +2,18 @@ import { DOCUMENT } from '@angular/common';
 import { Component, Inject, OnInit } from '@angular/core';
 import { Router } from '@angular/router';
 import { ProgressService } from '../../common/progress/progress.service';
-import { Server } from '../../models/server';
-import { ServerService } from '../../services/server.service';
+import{ Controller } from '../../models/controller';
+import { ControllerService } from '../../services/controller.service';
 
 @Component({
-  selector: 'app-bundled-server-finder',
-  templateUrl: './bundled-server-finder.component.html',
-  styleUrls: ['./bundled-server-finder.component.scss'],
+  selector: 'app-bundled-controller-finder',
+  templateUrl: './bundled-controller-finder.component.html',
+  styleUrls: ['./bundled-controller-finder.component.scss'],
 })
-export class BundledServerFinderComponent implements OnInit {
+export class BundledControllerFinderComponent implements OnInit {
   constructor(
     private router: Router,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private progressService: ProgressService,
     @Inject(DOCUMENT) private document
   ) {}
@@ -31,8 +31,8 @@ export class BundledServerFinderComponent implements OnInit {
         port = 80;
       }
 
-      this.serverService.getLocalServer(this.document.location.hostname, port).then((server: Server) => {
-        this.router.navigate(['/server', server.id, 'projects']);
+      this.controllerService.getLocalController(this.document.location.hostname, port).then((controller:Controller ) => {
+        this.router.navigate(['/controller', controller.id, 'projects']);
         this.progressService.deactivate();
       });
     }, 100);

src/app/components/bundled-server-finder/bundled-server-finder.component.spec.ts

@@ -1,67 +0,0 @@
-import { NO_ERRORS_SCHEMA } from '@angular/core';
-import { ComponentFixture, fakeAsync, TestBed, tick } from '@angular/core/testing';
-import { By } from '@angular/platform-browser';
-import { Router } from '@angular/router';
-import { RouterTestingModule } from '@angular/router/testing';
-import { ProgressService } from '../../common/progress/progress.service';
-import { Server } from '../../models/server';
-import { ServerService } from '../../services/server.service';
-import { MockedServerService } from '../../services/server.service.spec';
-import { MockedProgressService } from '../project-map/project-map.component.spec';
-import { BundledServerFinderComponent } from './bundled-server-finder.component';
-
-describe('BundledServerFinderComponent', () => {
-  let component: BundledServerFinderComponent;
-  let fixture: ComponentFixture<BundledServerFinderComponent>;
-  let router: any;
-  let service: ServerService;
-  let progressService: MockedProgressService = new MockedProgressService();
-  let serverServiceMock: jasmine.SpyObj<ServerService>;
-
-
-  beforeEach(async () => {
-    router = {
-      navigate: jasmine.createSpy('navigate'),
-    };
-
-    
-
-    serverServiceMock = jasmine.createSpyObj<ServerService>([
-      "getLocalServer"
-    ]);
-
-
-    // serverService = new MockedServerService();
-    // spyOn(serverService, 'getLocalServer').and.returnValue(Promise.resolve(server));
-
-    await TestBed.configureTestingModule({
-      providers: [
-        { provide: Router, useValue: router },
-        { provide: ServerService, useValue: serverServiceMock },
-        { provide: ProgressService, useValue: progressService },
-      ],
-      declarations: [BundledServerFinderComponent],
-      schemas: [NO_ERRORS_SCHEMA],
-    }).compileComponents();
-
-    fixture = TestBed.createComponent(BundledServerFinderComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create and redirect to server', fakeAsync(() => {
-    const server = new Server();
-    server.id = 99;
-    serverServiceMock.getLocalServer.and.returnValue(
-      Promise.resolve(server)
-    );
-    expect(component).toBeTruthy();
-    tick(101)
-    fixture.detectChanges()
-    fixture.whenStable().then(() => {
-      expect(serverServiceMock.getLocalServer).toHaveBeenCalledWith('vps3.gns3.net',3000);
-      expect(router.navigate).toHaveBeenCalledWith(['/server', 99, 'projects']);
-    })
-    service = TestBed.inject(ServerService);
-  }));
-});

src/app/components/controllers/add-controller-dialog/add-controller-dialog.component.html

@@ -1,24 +1,24 @@
-<h1 mat-dialog-title>Add server</h1>
-<form [formGroup]="serverForm">
+<h1 mat-dialog-title>Add controller</h1>
+<form [formGroup]="controllerForm">
   <div mat-dialog-content>
     <mat-form-field>
       <input matInput tabindex="1" formControlName="name" placeholder="Name" />
-      <mat-error *ngIf="serverForm.get('name').hasError('required')">You must enter a value</mat-error>
+      <mat-error *ngIf="controllerForm.get('name').hasError('required')">You must enter a value</mat-error>
     </mat-form-field>
 
-    <mat-form-field>
+    <!-- <mat-form-field>
       <mat-select placeholder="Location" formControlName="location">
         <mat-option *ngFor="let location of locations" [value]="location.key"> {{ location.name }} </mat-option>
       </mat-select>
+    </mat-form-field> -->
+
+    <!-- <mat-form-field *ngIf="controllerForm.get('location').value === 'local'">
+      <input matInput tabindex="1" formControlName="path" placeholder="Local controller path" />
     </mat-form-field>
 
-    <mat-form-field *ngIf="serverForm.get('location').value === 'local'">
-      <input matInput tabindex="1" formControlName="path" placeholder="Local server path" />
-    </mat-form-field>
-
-    <mat-form-field *ngIf="serverForm.get('location').value === 'local'">
+    <mat-form-field *ngIf="controllerForm.get('location').value === 'local'">
       <input matInput tabindex="1" formControlName="ubridge_path" placeholder="Ubridge path" />
-    </mat-form-field>
+    </mat-form-field> -->
 
     <mat-form-field>
       <input matInput tabindex="1" formControlName="host" placeholder="Host" />

src/app/components/controllers/add-controller-dialog/add-controller-dialog.component.ts

@@ -2,22 +2,22 @@ import { Component, Inject, OnInit } from '@angular/core';
 import { FormControl, FormGroup, Validators } from '@angular/forms';
 import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
 import { ElectronService } from 'ngx-electron';
-import { Server } from '../../../models/server';
-import { ServerService } from '../../../services/server.service';
+import { Controller } from '../../../models/controller';
+import { ControllerService } from '../../../services/controller.service';
 import { ToasterService } from '../../../services/toaster.service';
 
 @Component({
-  selector: 'app-add-server-dialog',
-  templateUrl: 'add-server-dialog.component.html',
+  selector: 'app-add-controller-dialog',
+  templateUrl: 'add-controller-dialog.component.html',
 })
-export class AddServerDialogComponent implements OnInit {
+export class AddControllerDialogComponent implements OnInit {
   protocols = [
     { key: 'http:', name: 'HTTP' },
     { key: 'https:', name: 'HTTPS' },
   ];
   locations = [];
 
-  serverForm = new FormGroup({
+  controllerForm = new FormGroup({
     name: new FormControl('', [Validators.required]),
     location: new FormControl(''),
     path: new FormControl(''),
@@ -28,18 +28,18 @@ export class AddServerDialogComponent implements OnInit {
   });
 
   constructor(
-    public dialogRef: MatDialogRef<AddServerDialogComponent>,
+    public dialogRef: MatDialogRef<AddControllerDialogComponent>,
     private electronService: ElectronService,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private toasterService: ToasterService,
     @Inject(MAT_DIALOG_DATA) public data: any
   ) {}
 
   async getLocations() {
-    const localServers = await this.numberOfLocalServers();
+    const localControllers = await this.numberOfLocalControllers();
 
     let locations = [];
-    if (this.electronService.isElectronApp && localServers === 0) {
+    if (this.electronService.isElectronApp && localControllers === 0) {
       locations.push({ key: 'local', name: 'Local' });
     }
     locations.push({ key: 'remote', name: 'Remote' });
@@ -47,17 +47,17 @@ export class AddServerDialogComponent implements OnInit {
   }
 
   async getDefaultLocation() {
-    const localServers = await this.numberOfLocalServers();
-    if (this.electronService.isElectronApp && localServers === 0) {
+    const localControllers = await this.numberOfLocalControllers();
+    if (this.electronService.isElectronApp && localControllers === 0) {
       return 'local';
     }
     return 'remote';
   }
 
-  async numberOfLocalServers() {
-    const servers = await this.serverService.findAll();
+  async numberOfLocalControllers() {
+    const controllers = await this.controllerService.findAll();
 
-    return servers.filter((server) => server.location === 'local').length;
+    return controllers.filter((controller) => controller.location === 'local').length;
   }
 
   getDefaultHost() {
@@ -68,16 +68,16 @@ export class AddServerDialogComponent implements OnInit {
     return 3080;
   }
 
-  async getDefaultLocalServerPath() {
+  async getDefaultLocalControllerPath() {
     if (this.electronService.isElectronApp) {
-      return await this.electronService.remote.require('./local-server.js').getLocalServerPath();
+      return await this.electronService.remote.require('./local-controller.js').getLocalControllerPath();
     }
     return;
   }
 
   async getDefaultUbridgePath() {
     if (this.electronService.isElectronApp) {
-      return await this.electronService.remote.require('./local-server.js').getUbridgePath();
+      return await this.electronService.remote.require('./local-controller.js').getUbridgePath();
     }
     return;
   }
@@ -85,15 +85,15 @@ export class AddServerDialogComponent implements OnInit {
   async ngOnInit() {
     this.locations = await this.getLocations();
 
-    const defaultLocalServerPath = await this.getDefaultLocalServerPath();
+    const defaultLocalControllerPath = await this.getDefaultLocalControllerPath();
     const defaultUbridgePath = await this.getDefaultUbridgePath();
 
-    this.serverForm.get('location').valueChanges.subscribe((location: string) => {
-      const pathControl = this.serverForm.get('path');
-      const ubridgePathControl = this.serverForm.get('ubridge_path');
+    this.controllerForm.get('location').valueChanges.subscribe((location: string) => {
+      const pathControl = this.controllerForm.get('path');
+      const ubridgePathControl = this.controllerForm.get('ubridge_path');
 
       if (location === 'local') {
-        pathControl.setValue(defaultLocalServerPath);
+        pathControl.setValue(defaultLocalControllerPath);
         pathControl.setValidators([Validators.required]);
 
         ubridgePathControl.setValue(defaultUbridgePath);
@@ -114,29 +114,29 @@ export class AddServerDialogComponent implements OnInit {
     });
 
     const defaultLocation = await this.getDefaultLocation();
-    this.serverForm.get('location').setValue(defaultLocation);
-    this.serverForm.get('host').setValue(this.getDefaultHost());
-    this.serverForm.get('port').setValue(this.getDefaultPort());
+    this.controllerForm.get('location').setValue(defaultLocation);
+    this.controllerForm.get('host').setValue(this.getDefaultHost());
+    this.controllerForm.get('port').setValue(this.getDefaultPort());
   }
 
   onAddClick(): void {
-    if (!this.serverForm.valid) {
+    if (!this.controllerForm.valid) {
       return;
     }
 
-    const server: Server = Object.assign({}, this.serverForm.value);
-    this.serverService.checkServerVersion(server).subscribe(
-      (serverInfo) => {
-        if (serverInfo.version.split('.')[0] >= 3) {
-          this.dialogRef.close(server);
-          this.toasterService.success(`Server ${server.name} added.`);
+    const controller:Controller  = Object.assign({}, this.controllerForm.value);
+    this.controllerService.checkControllerVersion(controller).subscribe(
+      (controllerInfo) => {
+        if (controllerInfo.version.split('.')[0] >= 3) {
+          this.dialogRef.close(controller);
+          this.toasterService.success(`Controller ${controller.name} added.`);
         } else {
           this.dialogRef.close();
-          this.toasterService.error(`Server version is not supported.`);
+          this.toasterService.error(`Controller version is not supported.`);
         }
       },
       (error) => {
-        this.toasterService.error('Cannot connect to the server: ' + error);
+        this.toasterService.error('Cannot connect to the controller: ' + error);
       }
     );
   }

src/app/components/controllers/controller-discovery/controller-discovery.component.html

@@ -0,0 +1,12 @@
+<mat-card class="info" *ngIf="discoveredController">
+  <mat-card-content align="center">
+    We've discovered GNS3 controller on <b>{{ discoveredController?.host }}:{{ discoveredController?.port }}</b
+    >, would you like to add to the list?
+  </mat-card-content>
+  <mat-card-actions align="right">
+    <button mat-button color="accent" (click)="ignore(discoveredController)">NO</button>
+    <button mat-button (click)="accept(discoveredController)">YES</button>
+  </mat-card-actions>
+</mat-card>
+
+<mat-divider *ngIf="discoveredController"></mat-divider>

src/app/components/controllers/controller-discovery/controller-discovery.component.spec.ts

@@ -0,0 +1,171 @@
+import { ComponentFixture, fakeAsync, TestBed, tick } from '@angular/core/testing';
+import { MatCardModule } from '@angular/material/card';
+import { MatDividerModule } from '@angular/material/divider';
+import { Observable } from 'rxjs/Rx';
+import{ Controller } from '../../../models/controller';
+import { Version } from '../../../models/version';
+import { ControllerDatabase } from '../../../services/controller.database';
+import { ControllerService } from '../../../services/controller.service';
+import { MockedControllerService } from '../../../services/controller.service.spec';
+import { VersionService } from '../../../services/version.service';
+import { MockedVersionService } from '../../../services/version.service.spec';
+import { ControllerDiscoveryComponent } from './controller-discovery.component';
+
+xdescribe('ControllerDiscoveryComponent', () => {
+  let component: ControllerDiscoveryComponent;
+  let fixture: ComponentFixture<ControllerDiscoveryComponent>;
+  let mockedVersionService: MockedVersionService;
+  let mockedControllerService: MockedControllerService;
+
+  beforeEach(async () => {
+    mockedControllerService = new MockedControllerService();
+    mockedVersionService = new MockedVersionService();
+    await TestBed.configureTestingModule({
+      imports: [MatCardModule, MatDividerModule],
+      providers: [
+        { provide: VersionService, useFactory: () => mockedVersionService },
+        { provide: ControllerService, useFactory: () => mockedControllerService },
+        ControllerDatabase,
+      ],
+      declarations: [ControllerDiscoveryComponent],
+    }).compileComponents();
+  });
+
+beforeEach(() => {
+  fixture = TestBed.createComponent(ControllerDiscoveryComponent);
+
+  component = fixture.componentInstance;
+
+  // we don't really want to run it during testing
+  spyOn(component, 'ngOnInit').and.returnValue(null);
+
+  fixture.detectChanges();
+});
+
+it('should create', () => {
+  expect(component).toBeTruthy();
+});
+
+describe('isAvailable', () => {
+  it('should return controller object when controller is available', () => {
+    const version = new Version();
+    version.version = '2.1.8';
+
+    const getVersionSpy = spyOn(mockedVersionService, 'get').and.returnValue(Observable.of(version));
+
+    component.isControllerAvailable('127.0.0.1', 3080).subscribe((s) => {
+      expect(s.host).toEqual('127.0.0.1');
+      expect(s.port).toEqual(3080);
+    });
+
+    const controller = new Controller ();
+    controller.host = '127.0.0.1';
+    controller.port = 3080;
+
+    expect(getVersionSpy).toHaveBeenCalledWith(controller);
+  });
+
+  it('should throw error once controller is not available', () => {
+    const controller = new Controller ();
+    controller.host = '127.0.0.1';
+    controller.port = 3080;
+
+    const getVersionSpy = spyOn(mockedVersionService, 'get').and.returnValue(
+      Observable.throwError(new Error('controller is unavailable'))
+    );
+    let hasExecuted = false;
+
+    component.isControllerAvailable('127.0.0.1', 3080).subscribe(
+      (ver) => { },
+      (err) => {
+        hasExecuted = true;
+        expect(err.toString()).toEqual('Error: controller is unavailable');
+      }
+    );
+
+    expect(getVersionSpy).toHaveBeenCalledWith(controller);
+    expect(hasExecuted).toBeTruthy();
+  });
+});
+
+describe('discovery', () => {
+  it('should discovery all controllers available', (done) => {
+    const version = new Version();
+    version.version = '2.1.8';
+
+    spyOn(component, 'isControllerAvailable').and.callFake((ip, port) => {
+      const controller = new Controller  ();
+      controller.host = ip;
+      controller.port = port;
+      return Observable.of(controller);
+    });
+
+    component.discovery().subscribe((discovered) => {
+      expect(discovered[0].host).toEqual('127.0.0.1');
+      expect(discovered[0].port).toEqual(3080);
+
+      expect(discovered.length).toEqual(1);
+
+      done();
+    });
+  });
+});
+
+describe('discoverFirstAvailableController', () => {
+  let controller:Controller ;
+
+  beforeEach(function () {
+    controller = new Controller  ();
+    (controller.host = '199.111.111.1'), (controller.port = 3333);
+
+    spyOn(component, 'discovery').and.callFake(() => {
+      return Observable.of([controller]);
+    });
+  });
+
+  it('should get first controller from discovered and with no added before', fakeAsync(() => {
+    expect(component.discoveredController).toBeUndefined();
+    component.discoverFirstAvailableController();
+    tick();
+    expect(component.discoveredController.host).toEqual('199.111.111.1');
+    expect(component.discoveredController.port).toEqual(3333);
+  }));
+
+  it('should get first controller from discovered and with already added', fakeAsync(() => {
+    mockedControllerService.controllers.push(controller);
+
+    expect(component.discoveredController).toBeUndefined();
+    component.discoverFirstAvailableController();
+    tick();
+    expect(component.discoveredController).toBeUndefined();
+  }));
+});
+
+describe('accepting and ignoring found controller', () => {
+  let controller:Controller ;
+  beforeEach(() => {
+    controller = new Controller  ();
+    (controller.host = '199.111.111.1'), (controller.port = 3333);
+    component.discoveredController = controller;
+  });
+
+  describe('accept', () => {
+    it('should add new controller', fakeAsync(() => {
+      component.accept(controller);
+      tick();
+      expect(component.discoveredController).toBeNull();
+      expect(mockedControllerService.controllers[0].host).toEqual('199.111.111.1');
+      expect(mockedControllerService.controllers[0].name).toEqual('199.111.111.1');
+      expect(mockedControllerService.controllers[0].location).toEqual('remote');
+    }));
+  });
+
+  describe('ignore', () => {
+    it('should reject controller', fakeAsync(() => {
+      component.ignore(controller);
+      tick();
+      expect(component.discoveredController).toBeNull();
+    }));
+  });
+});
+});

src/app/components/controllers/controller-discovery/controller-discovery.component.ts

@@ -0,0 +1,132 @@
+import { Component, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { forkJoin, from } from 'rxjs';
+import { map } from 'rxjs//operators';
+import { Observable } from 'rxjs/Rx';
+import { Controller, ControllerProtocol } from '../../../models/controller';
+import { Version } from '../../../models/version';
+import { ControllerDatabase } from '../../../services/controller.database';
+import { ControllerService } from '../../../services/controller.service';
+import { VersionService } from '../../../services/version.service';
+
+@Component({
+  selector: 'app-controller-discovery',
+  templateUrl: './controller-discovery.component.html',
+  styleUrls: ['./controller-discovery.component.scss'],
+})
+export class ControllerDiscoveryComponent implements OnInit {
+  private defaultControllers = [
+    {
+      host: '127.0.0.1',
+      port: 3080,
+    },
+  ];
+
+  discoveredController: Controller;
+
+  constructor(
+    private versionService: VersionService,
+    private controllerService: ControllerService,
+    private controllerDatabase: ControllerDatabase,
+    private route: ActivatedRoute
+  ) {}
+
+  ngOnInit() {
+    if (this.controllerService.isServiceInitialized) this.discoverFirstController();
+    this.controllerService.serviceInitialized.subscribe(async (value: boolean) => {
+      if (value) {
+        this.discoverFirstController();
+      }
+    });
+  }
+
+  async discoverFirstController() {
+    let discovered = await this.discoverControllers();
+    let local = await this.controllerService.findAll();
+
+    local.forEach((added) => {
+      discovered = discovered.filter((controller) => {
+        return !(controller.host == added.host && controller.port == added.port);
+      });
+    });
+
+    if (discovered.length > 0) {
+      this.discoveredController = discovered.shift();
+    }
+  }
+
+  async discoverControllers() {
+    let discoveredControllers: Controller[] = [];
+    this.defaultControllers.forEach(async (testController) => {
+      const controller = new Controller();
+      controller.host = testController.host;
+      controller.port = testController.port;
+      let version = await this.versionService
+        .get(controller)
+        .toPromise()
+        .catch((error) => null);
+      if (version) discoveredControllers.push(controller);
+    });
+    return discoveredControllers;
+  }
+
+  discoverFirstAvailableController() {
+    forkJoin([from(this.controllerService.findAll()).pipe(map((s: Controller[]) => s)), this.discovery()]).subscribe(
+      ([local, discovered]) => {
+        local.forEach((added) => {
+          discovered = discovered.filter((controller) => {
+            return !(controller.host == added.host && controller.port == added.port);
+          });
+        });
+        if (discovered.length > 0) {
+          this.discoveredController = discovered.shift();
+        }
+      },
+      (error) => {}
+    );
+  }
+
+  discovery(): Observable<Controller[]> {
+    const queries: Observable<Controller>[] = [];
+
+    this.defaultControllers.forEach((testController) => {
+      queries.push(
+        this.isControllerAvailable(testController.host, testController.port).catch((err) => {
+          return Observable.of(null);
+        })
+      );
+    });
+
+    return new Observable<Controller[]>((observer) => {
+      forkJoin(queries).subscribe((discoveredControllers) => {
+        observer.next(discoveredControllers.filter((s) => s != null));
+        observer.complete();
+      });
+    });
+  }
+
+  isControllerAvailable(ip: string, port: number): Observable<Controller> {
+    const controller = new Controller();
+    controller.host = ip;
+    controller.port = port;
+    return this.versionService.get(controller).flatMap((version: Version) => Observable.of(controller));
+  }
+
+  ignore(controller: Controller) {
+    this.discoveredController = null;
+  }
+
+  accept(controller: Controller) {
+    if (controller.name == null) {
+      controller.name = controller.host;
+    }
+
+    controller.location = 'remote';
+    controller.protocol = location.protocol as ControllerProtocol;
+
+    this.controllerService.create(controller).then((created: Controller) => {
+      this.controllerDatabase.addController(created);
+      this.discoveredController = null;
+    });
+  }
+}

src/app/components/controllers/controllers.component.html

@@ -1,7 +1,7 @@
 <div class="content">
-  <div class="default-header"><h1>Servers</h1></div>
+  <div class="default-header"><h1>Controllers</h1></div>
   <div class="default-content">
-    <app-server-discovery></app-server-discovery>
+    <app-controller-discovery></app-controller-discovery>
 
     <div class="mat-elevation-z8">
       <mat-table #table [dataSource]="dataSource">
@@ -14,13 +14,13 @@
           <mat-header-cell *matHeaderCellDef> Name </mat-header-cell>
           <mat-cell *matCellDef="let row">
             <a
-              *ngIf="getServerStatus(row) === 'running' || row.location === 'remote' || row.location === 'bundled'"
-              [routerLink]="['/server', row.id, 'login']"
+              *ngIf="getControllerStatus(row) === 'running' || row.location === 'remote' || row.location === 'bundled'"
+              [routerLink]="['/controller', row.id, 'login']"
               class="table-link"
               >{{ row.name }}</a
             >
             <span
-              *ngIf="getServerStatus(row) != 'running' && row.location !== 'remote' && row.location !== 'bundled'"
+              *ngIf="getControllerStatus(row) != 'running' && row.location !== 'remote' && row.location !== 'bundled'"
               >{{ row.name }}</span
             >
           </mat-cell>
@@ -49,43 +49,43 @@
               matTooltip="Go to projects"
               matTooltipClass="custom-tooltip"
               (click)="openProjects(row)"
-              *ngIf="getServerStatus(row) === 'running' || row.location === 'remote' || row.location === 'bundled'"
+              *ngIf="getControllerStatus(row) === 'running' || row.location === 'remote' || row.location === 'bundled'"
             >
               <mat-icon aria-label="Go to projects">arrow_forward</mat-icon>
             </button>
 
             <button
               mat-icon-button
-              matTooltip="Start server"
+              matTooltip="Start controller"
               matTooltipClass="custom-tooltip"
-              (click)="startServer(row)"
-              *ngIf="row.location === 'local' && getServerStatus(row) === 'stopped'"
+              (click)="startController(row)"
+              *ngIf="row.location === 'local' && getControllerStatus(row) === 'stopped'"
             >
-              <mat-icon aria-label="Start server">play_arrow</mat-icon>
+              <mat-icon aria-label="Start controller">play_arrow</mat-icon>
             </button>
 
             <button
               mat-icon-button
-              matTooltip="Stop server"
+              matTooltip="Stop controller"
               matTooltipClass="custom-tooltip"
-              (click)="stopServer(row)"
-              *ngIf="row.location === 'local' && getServerStatus(row) === 'running'"
+              (click)="stopController(row)"
+              *ngIf="row.location === 'local' && getControllerStatus(row) === 'running'"
             >
-              <mat-icon aria-label="Stop server">stop</mat-icon>
+              <mat-icon aria-label="Stop controller">stop</mat-icon>
             </button>
 
             <mat-spinner
               [diameter]="24"
-              *ngIf="row.location === 'local' && getServerStatus(row) === 'starting'"
+              *ngIf="row.location === 'local' && getControllerStatus(row) === 'starting'"
             ></mat-spinner>
 
             <button
               mat-icon-button
-              matTooltip="Remove server"
+              matTooltip="Remove controller"
               matTooltipClass="custom-tooltip"
-              (click)="deleteServer(row)"
+              (click)="deleteController(row)"
             >
-              <mat-icon aria-label="Remove server">delete</mat-icon>
+              <mat-icon aria-label="Remove controller">delete</mat-icon>
             </button>
           </mat-cell>
         </ng-container>
@@ -96,10 +96,10 @@
     </div>
 
     <div class="buttons-bar">
-      <button *ngIf="isElectronApp" mat-raised-button class="button" (click)="startLocalServer()">
-        Start local server
+      <button *ngIf="isElectronApp" mat-raised-button class="button" (click)="startLocalController()">
+        Start local controller
       </button>
-      <button mat-raised-button class="button" color="primary" (click)="createModal()">Add server</button>
+      <button mat-raised-button class="button" color="primary" (click)="createModal()">Add Controller</button>
     </div>
   </div>
 </div>

src/app/components/controllers/controllers.component.scss

@@ -0,0 +1,14 @@
+.buttons-bar {
+  padding-top: 0px;
+}
+
+.button {
+  margin: 20px !important;
+}
+table {
+  width: 100%;
+}
+
+mat-header-cell, mat-cell {
+  justify-content: center;
+}

src/app/components/controllers/controllers.component.spec.ts

@@ -4,11 +4,11 @@ import { MatDialog, MatDialogModule } from '@angular/material/dialog';
 import { MatIconModule } from '@angular/material/icon';
 import { MatMenuModule } from '@angular/material/menu';
 import { MatToolbarModule } from '@angular/material/toolbar';
-import { ServerDatabase } from '../../services/server.database';
-import { ServerService } from '../../services/server.service';
-import { MockedServerService } from 'app/services/server.service.spec';
-import { ServersComponent } from './servers.component';
-import { ServerManagementService } from 'app/services/server-management.service';
+import { ControllerDatabase } from '../../services/controller.database';
+import { ControllerService } from '../../services/controller.service';
+import { MockedControllerService } from 'app/services/controller.service.spec';
+import { ControllersComponent } from './controllers.component';
+import { ControllerManagementService } from '../../services/controller-management.service';
 import { ElectronService } from 'ngx-electron';
 import { ChildProcessService } from 'ngx-childprocess';
 import { MatBottomSheet, MatBottomSheetModule } from '@angular/material/bottom-sheet';
@@ -18,16 +18,16 @@ import { RouterTestingModule } from '@angular/router/testing';
 import { ChangeDetectorRef } from '@angular/core';
 import { MockedRouter } from 'app/common/progress/progress.component.spec';
 
-describe('ServersComponent', () => {
-  let component: ServersComponent;
-  let fixture: ComponentFixture<ServersComponent>;
-  let serverMockedService: MockedServerService
+describe('ControllersComponent', () => {
+  let component: ControllersComponent;
+  let fixture: ComponentFixture<ControllersComponent>;
+  let controllerMockedService: MockedControllerService
   let mockedActivatedRoute: MockedActivatedRoute
   let mockedRouter  : MockedRouter
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      declarations: [ServersComponent],
+      declarations: [ControllersComponent],
       imports: [
         MatDialogModule,
         RouterTestingModule,
@@ -35,13 +35,13 @@ describe('ServersComponent', () => {
       ],
       providers: [
         MatDialog,
-        ServerDatabase,
-        ServerManagementService,
+        ControllerDatabase,
+        ControllerManagementService,
         ElectronService,
         MatBottomSheet,
         ChildProcessService,
         ChangeDetectorRef,
-        { provide: ServerService, useValue: serverMockedService },
+        { provide: ControllerService, useValue: controllerMockedService },
         { provide: ActivatedRoute, useValue: mockedActivatedRoute },
         { provide: Router, useValue: mockedRouter },
       ]
@@ -49,7 +49,7 @@ describe('ServersComponent', () => {
   });
 
   beforeEach(() => {
-    fixture = TestBed.createComponent(ServersComponent);
+    fixture = TestBed.createComponent(ControllersComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
   });

src/app/components/controllers/controllers.component.ts

@@ -0,0 +1,177 @@
+import { DataSource } from '@angular/cdk/collections';
+import { ChangeDetectorRef, Component, OnDestroy, OnInit } from '@angular/core';
+import { MatBottomSheet } from '@angular/material/bottom-sheet';
+import { MatDialog } from '@angular/material/dialog';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ChildProcessService } from 'ngx-childprocess';
+import { ElectronService } from 'ngx-electron';
+import { merge, Observable, Subscription } from 'rxjs';
+import { map } from 'rxjs/operators';
+import {Controller , ControllerProtocol } from '../../models/controller';
+import { ControllerManagementService } from '../../services/controller-management.service';
+import { ControllerDatabase } from '../../services/controller.database';
+import { ControllerService } from '../../services/controller.service';
+import { ConfirmationBottomSheetComponent } from '../projects/confirmation-bottomsheet/confirmation-bottomsheet.component';
+import { AddControllerDialogComponent } from './add-controller-dialog/add-controller-dialog.component';
+
+@Component({
+  selector: 'app-controller-list',
+  templateUrl: './controllers.component.html',
+  styleUrls: ['./controllers.component.scss'],
+})
+export class ControllersComponent implements OnInit, OnDestroy {
+  dataSource: ControllerDataSource;
+  displayedColumns = ['id', 'name', 'location', 'ip', 'port', 'actions'];
+  controllerStatusSubscription: Subscription;
+  isElectronApp: boolean = false;
+
+  constructor(
+    private dialog: MatDialog,
+    private controllerService: ControllerService,
+    private controllerDatabase: ControllerDatabase,
+    private controllerManagement: ControllerManagementService,
+    private changeDetector: ChangeDetectorRef,
+    private electronService: ElectronService,
+    private childProcessService: ChildProcessService,
+    private bottomSheet: MatBottomSheet,
+    private route: ActivatedRoute,
+    private router: Router
+  ) { }
+
+  getControllers() {
+    const runningControllerNames = this.controllerManagement.getRunningControllers();
+
+    this.controllerService.findAll().then((controllers:Controller []) => {
+      controllers.forEach((controller) => {
+        const controllerIndex = runningControllerNames.findIndex((controllerName) => controller.name === controllerName);
+        if (controllerIndex >= 0) {
+          controller.status = 'running';
+        }
+      });
+
+      controllers.forEach((controller) => {
+        this.controllerService.checkControllerVersion(controller).subscribe(
+          (controllerInfo) => {
+            if (controllerInfo.version.split('.')[0] >= 3) {
+              if (!controller.protocol) controller.protocol = location.protocol as ControllerProtocol;
+              if (!this.controllerDatabase.find(controller.name)) this.controllerDatabase.addController(controller);
+            }
+          },
+          (error) => { }
+        );
+      });
+    });
+  }
+
+  ngOnInit() {
+    this.isElectronApp = this.electronService.isElectronApp;
+
+    if (this.controllerService && this.controllerService.isServiceInitialized) this.getControllers();
+
+    if (this.controllerService && this.controllerService.isServiceInitialized) {
+      this.controllerService.serviceInitialized.subscribe(async (value: boolean) => {
+        if (value) {
+          this.getControllers();
+        }
+      });
+    }
+
+    this.dataSource = new ControllerDataSource(this.controllerDatabase);
+
+    this.controllerStatusSubscription = this.controllerManagement.controllerStatusChanged.subscribe((controllerStatus) => {
+      const controller = this.controllerDatabase.find(controllerStatus.controllerName);
+      if (!controller) {
+        return;
+      }
+      if (controllerStatus.status === 'starting') {
+        controller.status = 'starting';
+      }
+      if (controllerStatus.status === 'stopped') {
+        controller.status = 'stopped';
+      }
+      if (controllerStatus.status === 'errored') {
+        controller.status = 'stopped';
+      }
+      if (controllerStatus.status === 'started') {
+        controller.status = 'running';
+      }
+      this.controllerDatabase.update(controller);
+      this.changeDetector.detectChanges();
+    });
+  }
+
+  ngOnDestroy() {
+    this.controllerStatusSubscription.unsubscribe();
+  }
+
+  startLocalController() {
+    const controller = this.controllerDatabase.data.find((n) => n.location === 'bundled' || 'local');
+    this.startController(controller);
+  }
+
+  openProjects(controller) {
+    this.router.navigate(['/controller', controller.id, 'projects']);
+  }
+
+  createModal() {
+    const dialogRef = this.dialog.open(AddControllerDialogComponent, {
+      width: '350px',
+      autoFocus: false,
+      disableClose: true,
+    });
+
+    dialogRef.afterClosed().subscribe((controller) => {
+      if (controller) {
+        this.controllerService.create(controller).then((created:Controller ) => {
+          this.controllerDatabase.addController(created);
+        });
+      }
+    });
+  }
+
+  getControllerStatus(controller:Controller ) {
+    if (controller.location === 'local') {
+      if (controller.status === undefined) {
+        return 'stopped';
+      }
+      return controller.status;
+    }
+  }
+
+  deleteController(controller:Controller ) {
+    this.bottomSheet.open(ConfirmationBottomSheetComponent);
+    let bottomSheetRef = this.bottomSheet._openedBottomSheetRef;
+    bottomSheetRef.instance.message = 'Do you want to delete the controller?';
+    const bottomSheetSubscription = bottomSheetRef.afterDismissed().subscribe((result: boolean) => {
+      if (result) {
+        this.controllerService.delete(controller).then(() => {
+          this.controllerDatabase.remove(controller);
+        });
+      }
+    });
+  }
+
+  async startController(controller:Controller ) {
+    await this.controllerManagement.start(controller);
+  }
+
+  async stopController(controller:Controller ) {
+    await this.controllerManagement.stop(controller);
+  }
+}
+
+export class ControllerDataSource extends DataSource<Controller> {
+  constructor(private controllerDatabase: ControllerDatabase) {
+    super();
+  }
+
+  connect(): Observable< Controller[] > {
+    return merge(this.controllerDatabase.dataChange).pipe(
+      map(() => {
+        return this.controllerDatabase.data;
+      })
+    );
+  }
+
+  disconnect() { }
+}

src/app/components/direct-link/direct-link.component.html

@@ -1,23 +1,23 @@
-<div [hidden]="!serverOptionsVisibility" class="content">
+<div [hidden]="!controllerOptionsVisibility" class="content">
     <div class="default-header">
         <div class="row">
-            <h1 class="col">Add new server</h1>
+            <h1 class="col">Add new controller</h1>
         </div>
     </div>
     <div class="default-content">
         <mat-card class="matCard">
-            <form [formGroup]="serverForm">
+            <form [formGroup]="controllerForm">
                 <mat-form-field>
                     <input matInput tabindex="1" formControlName="name" placeholder="Name" />
-                    <mat-error *ngIf="serverForm.get('name').hasError('required')">You must enter a value</mat-error>
+                    <mat-error *ngIf="controllerForm.get('name').hasError('required')">You must enter a value</mat-error>
                 </mat-form-field>
-    
+
                 <mat-form-field>
                     <mat-select placeholder="Location" formControlName="location">
                       <mat-option *ngFor="let location of locations" [value]="location.key"> {{ location.name }} </mat-option>
                     </mat-select>
                 </mat-form-field>
-    
+
                 <mat-form-field>
                     <mat-select placeholder="Protocol" formControlName="protocol">
                         <mat-option *ngFor="let protocol of protocols" [value]="protocol.key"> {{ protocol.name }} </mat-option>
@@ -26,7 +26,7 @@
             </form>
         </mat-card>
         <div class="buttons-bar">
-            <button mat-raised-button color="primary" (click)="createServer()">Add server</button>
+            <button mat-raised-button color="primary" (click)="createController()">Add controller</button>
         </div>
     </div>
 </div>

src/app/components/direct-link/direct-link.component.ts

@@ -1,9 +1,9 @@
 import { Component, OnInit, ViewEncapsulation } from '@angular/core';
 import { FormControl, FormGroup, Validators } from '@angular/forms';
 import { ActivatedRoute, Router } from '@angular/router';
-import { Server } from '../../models/server';
-import { ServerDatabase } from '../../services/server.database';
-import { ServerService } from '../../services/server.service';
+import{ Controller } from '../../models/controller';
+import { ControllerDatabase } from '../../services/controller.database';
+import { ControllerService } from '../../services/controller.service';
 import { ToasterService } from '../../services/toaster.service';
 
 @Component({
@@ -13,9 +13,9 @@ import { ToasterService } from '../../services/toaster.service';
   encapsulation: ViewEncapsulation.None,
 })
 export class DirectLinkComponent implements OnInit {
-  public serverOptionsVisibility = false;
-  public serverIp;
-  public serverPort;
+  public controllerOptionsVisibility = false;
+  public controllerIp;
+  public controllerPort;
   public projectId;
 
   protocols = [
@@ -27,61 +27,61 @@ export class DirectLinkComponent implements OnInit {
     { key: 'remote', name: 'Remote' },
   ];
 
-  serverForm = new FormGroup({
+  controllerForm = new FormGroup({
     name: new FormControl('', [Validators.required]),
     location: new FormControl(''),
     protocol: new FormControl('http:')
   });
 
   constructor(
-    private serverService: ServerService,
-    private serverDatabase: ServerDatabase,
+    private controllerService: ControllerService,
+    private controllerDatabase: ControllerDatabase,
     private route: ActivatedRoute,
     private router: Router,
     private toasterService: ToasterService
   ) {}
 
   async ngOnInit() {
-    if (this.serverService.isServiceInitialized) this.getServers();
+    if (this.controllerService.isServiceInitialized) this.getControllers();
 
-    this.serverService.serviceInitialized.subscribe(async (value: boolean) => {
+    this.controllerService.serviceInitialized.subscribe(async (value: boolean) => {
       if (value) {
-        this.getServers();
+        this.getControllers();
       }
     });
   }
 
-  private async getServers() {
-    this.serverIp = this.route.snapshot.paramMap.get('server_ip');
-    this.serverPort = +this.route.snapshot.paramMap.get('server_port');
+  private async getControllers() {
+    this.controllerIp = this.route.snapshot.paramMap.get('controller_ip');
+    this.controllerPort = +this.route.snapshot.paramMap.get('controller_port');
     this.projectId = this.route.snapshot.paramMap.get('project_id');
 
-    const servers = await this.serverService.findAll();
-    const server = servers.filter((server) => server.host === this.serverIp && server.port === this.serverPort)[0];
+    const controllers = await this.controllerService.findAll();
+    const controller = controllers.filter((controller) => controller.host === this.controllerIp && controller.port === this.controllerPort)[0];
 
-    if (server) {
-      this.router.navigate(['/server', server.id, 'project', this.projectId]);
+    if (controller) {
+      this.router.navigate(['/controller', controller.id, 'project', this.projectId]);
     } else {
-      this.serverOptionsVisibility = true;
+      this.controllerOptionsVisibility = true;
     }
   }
 
-  public createServer() {
-    if (!this.serverForm.get('name').hasError && !this.serverForm.get('location').hasError && !this.serverForm.get('protocol').hasError) {
+  public createController() {
+    if (!this.controllerForm.get('name').hasError && !this.controllerForm.get('location').hasError && !this.controllerForm.get('protocol').hasError) {
       this.toasterService.error('Please use correct values');
       return;
     }
 
-    let serverToAdd: Server = new Server();
-    serverToAdd.host = this.serverIp;
-    serverToAdd.port = this.serverPort;
+    let controllerToAdd:Controller  = new Controller  ();
+    controllerToAdd.host = this.controllerIp;
+    controllerToAdd.port = this.controllerPort;
 
-    serverToAdd.name = this.serverForm.get('name').value;
-    serverToAdd.location = this.serverForm.get('location').value;
-    serverToAdd.protocol = this.serverForm.get('protocol').value;
+    controllerToAdd.name = this.controllerForm.get('name').value;
+    controllerToAdd.location = this.controllerForm.get('location').value;
+    controllerToAdd.protocol = this.controllerForm.get('protocol').value;
 
-    this.serverService.create(serverToAdd).then((addedServer: Server) => {
-      this.router.navigate(['/server', addedServer.id, 'project', this.projectId]);
+    this.controllerService.create(controllerToAdd).then((addedController:Controller ) => {
+      this.router.navigate(['/controller', addedController.id, 'project', this.projectId]);
     });
   }
 }

src/app/components/drawings-listeners/drawing-added/drawing-added.component.ts

@@ -7,7 +7,7 @@ import { AddedDataEvent } from '../../../cartography/events/event-source';
 import { DefaultDrawingsFactory } from '../../../cartography/helpers/default-drawings-factory';
 import { Drawing } from '../../../cartography/models/drawing';
 import { Project } from '../../../models/project';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { DrawingService } from '../../../services/drawing.service';
 
 @Component({
@@ -16,7 +16,7 @@ import { DrawingService } from '../../../services/drawing.service';
   styleUrls: ['./drawing-added.component.scss'],
 })
 export class DrawingAddedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller: Controller
   @Input() project: Project;
   @Input() selectedDrawing: string;
   @Output() drawingSaved = new EventEmitter<boolean>();
@@ -49,9 +49,9 @@ export class DrawingAddedComponent implements OnInit, OnDestroy {
     let svgText = this.mapDrawingToSvgConverter.convert(drawing);
 
     this.drawingService
-      .add(this.server, this.project.project_id, evt.x, evt.y, svgText)
-      .subscribe((serverDrawing: Drawing) => {
-        this.drawingsDataSource.add(serverDrawing);
+      .add(this.controller, this.project.project_id, evt.x, evt.y, svgText)
+      .subscribe((controllerDrawing: Drawing) => {
+        this.drawingsDataSource.add(controllerDrawing);
         this.drawingSaved.emit(true);
       });
   }

src/app/components/drawings-listeners/drawing-dragged/drawing-dragged.component.ts

@@ -6,7 +6,7 @@ import { DraggedDataEvent } from '../../../cartography/events/event-source';
 import { Drawing } from '../../../cartography/models/drawing';
 import { MapDrawing } from '../../../cartography/models/map/map-drawing';
 import { Project } from '../../../models/project';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { DrawingService } from '../../../services/drawing.service';
 
 @Component({
@@ -15,7 +15,7 @@ import { DrawingService } from '../../../services/drawing.service';
   styleUrls: ['./drawing-dragged.component.scss'],
 })
 export class DrawingDraggedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller:Controller ;
   @Input() project: Project;
   private drawingDragged: Subscription;
 
@@ -35,9 +35,9 @@ export class DrawingDraggedComponent implements OnInit, OnDestroy {
     drawing.y += draggedEvent.dy;
 
     this.drawingService
-      .updatePosition(this.server, this.project, drawing, drawing.x, drawing.y)
-      .subscribe((serverDrawing: Drawing) => {
-        this.drawingsDataSource.update(serverDrawing);
+      .updatePosition(this.controller, this.project, drawing, drawing.x, drawing.y)
+      .subscribe((controllerDrawing: Drawing) => {
+        this.drawingsDataSource.update(controllerDrawing);
       });
   }
 

src/app/components/drawings-listeners/drawing-resized/drawing-resized.component.ts

@@ -6,7 +6,7 @@ import { DrawingsEventSource } from '../../../cartography/events/drawings-event-
 import { ResizedDataEvent } from '../../../cartography/events/event-source';
 import { Drawing } from '../../../cartography/models/drawing';
 import { MapDrawing } from '../../../cartography/models/map/map-drawing';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { DrawingService } from '../../../services/drawing.service';
 
 @Component({
@@ -15,7 +15,7 @@ import { DrawingService } from '../../../services/drawing.service';
   styleUrls: ['./drawing-resized.component.scss'],
 })
 export class DrawingResizedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller:Controller ;
   private drawingResized: Subscription;
 
   constructor(
@@ -34,9 +34,9 @@ export class DrawingResizedComponent implements OnInit, OnDestroy {
     let svgString = this.mapDrawingToSvgConverter.convert(resizedEvent.datum);
 
     this.drawingService
-      .updateSizeAndPosition(this.server, drawing, resizedEvent.x, resizedEvent.y, svgString)
-      .subscribe((serverDrawing: Drawing) => {
-        this.drawingsDataSource.update(serverDrawing);
+      .updateSizeAndPosition(this.controller, drawing, resizedEvent.x, resizedEvent.y, svgString)
+      .subscribe((controllerDrawing: Drawing) => {
+        this.drawingsDataSource.update(controllerDrawing);
       });
   }
 

src/app/components/drawings-listeners/interface-label-dragged/interface-label-dragged.component.ts

@@ -5,7 +5,7 @@ import { DraggedDataEvent } from '../../../cartography/events/event-source';
 import { LinksEventSource } from '../../../cartography/events/links-event-source';
 import { MapLinkNode } from '../../../cartography/models/map/map-link-node';
 import { Link } from '../../../models/link';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { LinkService } from '../../../services/link.service';
 
 @Component({
@@ -14,7 +14,7 @@ import { LinkService } from '../../../services/link.service';
   styleUrls: ['./interface-label-dragged.component.scss'],
 })
 export class InterfaceLabelDraggedComponent {
-  @Input() server: Server;
+  @Input() controller:Controller ;
   private interfaceDragged: Subscription;
 
   constructor(
@@ -40,8 +40,8 @@ export class InterfaceLabelDraggedComponent {
       link.nodes[1].label.y += draggedEvent.dy;
     }
 
-    this.linkService.updateNodes(this.server, link, link.nodes).subscribe((serverLink: Link) => {
-      this.linksDataSource.update(serverLink);
+    this.linkService.updateNodes(this.controller, link, link.nodes).subscribe((controllerLink: Link) => {
+      this.linksDataSource.update(controllerLink);
     });
   }
 

src/app/components/drawings-listeners/link-created/link-created.component.ts

@@ -7,7 +7,7 @@ import { MapLinkCreated } from '../../../cartography/events/links';
 import { LinksEventSource } from '../../../cartography/events/links-event-source';
 import { Link } from '../../../models/link';
 import { Project } from '../../../models/project';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { LinkService } from '../../../services/link.service';
 import { ProjectService } from '../../../services/project.service';
 
@@ -17,7 +17,7 @@ import { ProjectService } from '../../../services/project.service';
   styleUrls: ['./link-created.component.scss'],
 })
 export class LinkCreatedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller:Controller ;
   @Input() project: Project;
   private linkCreated: Subscription;
 
@@ -87,7 +87,7 @@ export class LinkCreatedComponent implements OnInit, OnDestroy {
 
     this.linkService
       .createLink(
-        this.server,
+        this.controller,
         sourceNode,
         sourcePort,
         targetNode,
@@ -98,7 +98,7 @@ export class LinkCreatedComponent implements OnInit, OnDestroy {
         yLabelTargetNode
       )
       .subscribe(() => {
-        this.projectService.links(this.server, this.project.project_id).subscribe((links: Link[]) => {
+        this.projectService.links(this.controller, this.project.project_id).subscribe((links: Link[]) => {
           this.linksDataSource.set(links);
         });
       });

src/app/components/drawings-listeners/node-dragged/node-dragged.component.ts

@@ -6,7 +6,7 @@ import { NodesEventSource } from '../../../cartography/events/nodes-event-source
 import { MapNode } from '../../../cartography/models/map/map-node';
 import { Node } from '../../../cartography/models/node';
 import { Project } from '../../../models/project';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { NodeService } from '../../../services/node.service';
 
 @Component({
@@ -15,7 +15,7 @@ import { NodeService } from '../../../services/node.service';
   styleUrls: ['./node-dragged.component.scss'],
 })
 export class NodeDraggedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller:Controller ;
   @Input() project: Project;
   private nodeDragged: Subscription;
 
@@ -34,8 +34,8 @@ export class NodeDraggedComponent implements OnInit, OnDestroy {
     node.x += draggedEvent.dx;
     node.y += draggedEvent.dy;
 
-    this.nodeService.updatePosition(this.server, this.project, node, node.x, node.y).subscribe((serverNode: Node) => {
-      this.nodesDataSource.update(serverNode);
+    this.nodeService.updatePosition(this.controller, this.project, node, node.x, node.y).subscribe((controllerNode: Node) => {
+      this.nodesDataSource.update(controllerNode);
     });
   }
 

src/app/components/drawings-listeners/node-label-dragged/node-label-dragged.component.ts

@@ -6,7 +6,7 @@ import { DraggedDataEvent } from '../../../cartography/events/event-source';
 import { NodesEventSource } from '../../../cartography/events/nodes-event-source';
 import { MapLabel } from '../../../cartography/models/map/map-label';
 import { Node } from '../../../cartography/models/node';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { NodeService } from '../../../services/node.service';
 
 @Component({
@@ -15,7 +15,7 @@ import { NodeService } from '../../../services/node.service';
   styleUrls: ['./node-label-dragged.component.scss'],
 })
 export class NodeLabelDraggedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller:Controller ;
   private nodeLabelDragged: Subscription;
 
   constructor(
@@ -38,8 +38,8 @@ export class NodeLabelDraggedComponent implements OnInit, OnDestroy {
     const label = this.mapLabelToLabel.convert(mapLabel);
     node.label = label;
 
-    this.nodeService.updateLabel(this.server, node, node.label).subscribe((serverNode: Node) => {
-      this.nodesDataSource.update(serverNode);
+    this.nodeService.updateLabel(this.controller, node, node.label).subscribe((controllerNode: Node) => {
+      this.nodesDataSource.update(controllerNode);
     });
   }
 

src/app/components/drawings-listeners/text-added/text-added.component.ts

@@ -9,7 +9,7 @@ import { Context } from '../../../cartography/models/context';
 import { Drawing } from '../../../cartography/models/drawing';
 import { TextElement } from '../../../cartography/models/drawings/text-element';
 import { Project } from '../../../models/project';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { DrawingService } from '../../../services/drawing.service';
 
 @Component({
@@ -18,7 +18,7 @@ import { DrawingService } from '../../../services/drawing.service';
   styleUrls: ['./text-added.component.scss'],
 })
 export class TextAddedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller: Controller;
   @Input() project: Project;
   @Output() drawingSaved = new EventEmitter<boolean>();
   private textAdded: Subscription;
@@ -43,7 +43,7 @@ export class TextAddedComponent implements OnInit, OnDestroy {
 
     this.drawingService
       .add(
-        this.server,
+        this.controller,
         this.project.project_id,
         (evt.x - (this.context.getZeroZeroTransformationPoint().x + this.context.transformation.x)) /
           this.context.transformation.k,
@@ -51,8 +51,8 @@ export class TextAddedComponent implements OnInit, OnDestroy {
           this.context.transformation.k,
         svgText
       )
-      .subscribe((serverDrawing: Drawing) => {
-        this.drawingsDataSource.add(serverDrawing);
+      .subscribe((controllerDrawing: Drawing) => {
+        this.drawingsDataSource.add(controllerDrawing);
         this.drawingSaved.emit(true);
       });
   }

src/app/components/drawings-listeners/text-edited/text-edited.component.ts

@@ -7,7 +7,7 @@ import { TextEditedDataEvent } from '../../../cartography/events/event-source';
 import { Drawing } from '../../../cartography/models/drawing';
 import { TextElement } from '../../../cartography/models/drawings/text-element';
 import { MapDrawing } from '../../../cartography/models/map/map-drawing';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { DrawingService } from '../../../services/drawing.service';
 
 @Component({
@@ -16,7 +16,7 @@ import { DrawingService } from '../../../services/drawing.service';
   styleUrls: ['./text-edited.component.scss'],
 })
 export class TextEditedComponent implements OnInit, OnDestroy {
-  @Input() server: Server;
+  @Input() controller: Controller;
   private textEdited: Subscription;
 
   constructor(
@@ -38,8 +38,8 @@ export class TextEditedComponent implements OnInit, OnDestroy {
 
     let drawing = this.drawingsDataSource.get(evt.textDrawingId);
 
-    this.drawingService.updateText(this.server, drawing, svgString).subscribe((serverDrawing: Drawing) => {
-      this.drawingsDataSource.update(serverDrawing);
+    this.drawingService.updateText(this.controller, drawing, svgString).subscribe((controllerDrawing: Drawing) => {
+      this.drawingsDataSource.update(controllerDrawing);
       this.drawingsEventSource.textSaved.emit(true);
     });
   }

src/app/components/export-portable-project/export-portable-project.component.html

@@ -21,7 +21,7 @@
         <mat-form-field class="input-full-width">
           <mat-select formControlName="compression" (selectionChange)="selectCompression($event)" required>
             <mat-option *ngFor="let compressionValue of compression_methods" [value]="compressionValue">{{
-              compressionValue.name
+              compressionValue?.name
             }}</mat-option>
           </mat-select>
         </mat-form-field>

src/app/components/export-portable-project/export-portable-project.component.ts

@@ -2,7 +2,7 @@ import { Component, Inject, OnInit } from '@angular/core';
 import { FormBuilder, FormGroup, Validators } from '@angular/forms';
 import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
 import { Project } from '../../models/project';
-import { Server } from '../../models/server';
+import{ Controller } from '../../models/controller';
 import { ProjectService } from '../../services/project.service';
 
 @Component({
@@ -16,7 +16,7 @@ export class ExportPortableProjectComponent implements OnInit {
   compression_methods: any = [];
   compression_level: any = [];
   compression_filter_value: any = [];
-  server: Server;
+  controller:Controller ;
   project: Project;
   index: number = 4;
   fileName: string;
@@ -30,7 +30,7 @@ export class ExportPortableProjectComponent implements OnInit {
   ) {}
 
   async ngOnInit() {
-    this.server = this.data.serverDetails;
+    this.controller = this.data.controllerDetails;
     this.project = this.data.projectDetails;
     this.fileName = this.project.name + '.gns3project';
     await this.formControls();
@@ -65,7 +65,7 @@ export class ExportPortableProjectComponent implements OnInit {
   exportPortableProject() {
     this.isExport = true;
     this.export_project_form.value.compression = this.export_project_form.value.compression.value ?? 'zstd';
-     window.location.assign(this.projectService.getexportPortableProjectPath(this.server, this.project.project_id, this.export_project_form.value))
+     window.location.assign(this.projectService.getexportPortableProjectPath(this.controller, this.project.project_id, this.export_project_form.value))
      this.dialogRef.close();
   }
 }

src/app/components/group-details/add-role-to-group/add-role-to-group.component.ts

@@ -14,7 +14,7 @@ import {Component, Inject, OnInit} from '@angular/core';
 import {BehaviorSubject, forkJoin, timer} from "rxjs";
 import {User} from "@models/users/user";
 import {MAT_DIALOG_DATA, MatDialogRef} from "@angular/material/dialog";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {Group} from "@models/groups/group";
 import {UserService} from "@services/user.service";
 import {GroupService} from "@services/group.service";
@@ -35,7 +35,7 @@ export class AddRoleToGroupComponent implements OnInit {
   loading = false;
 
   constructor(private dialog: MatDialogRef<AddRoleToGroupComponent>,
-              @Inject(MAT_DIALOG_DATA) public data: { server: Server; group: Group },
+              @Inject(MAT_DIALOG_DATA) public data: { controller: Controller; group: Group },
               private groupService: GroupService,
               private roleService: RoleService,
               private toastService: ToasterService) {
@@ -58,8 +58,8 @@ export class AddRoleToGroupComponent implements OnInit {
 
   getRoles() {
     forkJoin([
-      this.roleService.get(this.data.server),
-      this.groupService.getGroupRole(this.data.server, this.data.group.user_group_id)
+      this.roleService.get(this.data.controller),
+      this.groupService.getGroupRole(this.data.controller, this.data.group.user_group_id)
     ]).subscribe((results) => {
       const [globalRoles, groupRoles] = results;
       const roles = globalRoles.filter((role: Role) => {
@@ -76,7 +76,7 @@ export class AddRoleToGroupComponent implements OnInit {
   addRole(role: Role) {
     this.loading = true;
     this.groupService
-      .addRoleToGroup(this.data.server, this.data.group, role)
+      .addRoleToGroup(this.data.controller, this.data.group, role)
       .subscribe(() => {
         this.toastService.success(`role ${role.name} was added`);
         this.getRoles();

src/app/components/group-details/add-user-to-group-dialog/add-user-to-group-dialog.component.ts

@@ -13,7 +13,7 @@
 import {Component, Inject, OnInit} from '@angular/core';
 import {MAT_DIALOG_DATA, MatDialogRef} from "@angular/material/dialog";
 import {UserService} from "@services/user.service";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {BehaviorSubject, forkJoin, observable, Observable, timer} from "rxjs";
 import {User} from "@models/users/user";
 import {GroupService} from "@services/group.service";
@@ -34,7 +34,7 @@ export class AddUserToGroupDialogComponent implements OnInit {
   loading = false;
 
   constructor(private dialog: MatDialogRef<AddUserToGroupDialogComponent>,
-              @Inject(MAT_DIALOG_DATA) public data: { server: Server; group: Group },
+              @Inject(MAT_DIALOG_DATA) public data: { controller: Controller; group: Group },
               private userService: UserService,
               private groupService: GroupService,
               private toastService: ToasterService) {
@@ -57,8 +57,8 @@ export class AddUserToGroupDialogComponent implements OnInit {
 
   getUsers() {
     forkJoin([
-      this.userService.list(this.data.server),
-      this.groupService.getGroupMember(this.data.server, this.data.group.user_group_id)
+      this.userService.list(this.data.controller),
+      this.groupService.getGroupMember(this.data.controller, this.data.group.user_group_id)
     ]).subscribe((results) => {
       const [userList, members] = results;
       const users = userList.filter((user: User) => {
@@ -75,7 +75,7 @@ export class AddUserToGroupDialogComponent implements OnInit {
   addUser(user: User) {
     this.loading = true;
     this.groupService
-      .addMemberToGroup(this.data.server, this.data.group, user)
+      .addMemberToGroup(this.data.controller, this.data.group, user)
       .subscribe(() => {
         this.toastService.success(`user ${user.username} was added`);
         this.getUsers();

src/app/components/group-details/group-details.component.html

@@ -5,7 +5,7 @@
         mat-icon-button
         matTooltip="Back to group management"
         matTooltipClass="custom-tooltip"
-        [routerLink]="['/server', server.id, 'management', 'groups']">
+        [routerLink]="['/controller', controller.id, 'management', 'groups']">
         <mat-icon aria-label="Back to group management">keyboard_arrow_left</mat-icon>
       </a>
       <h1 class="col">Groups {{group.name}} details</h1>
@@ -47,7 +47,7 @@
             </mat-form-field>
           </div>
           <div *ngFor="let user of members | membersFilter: searchMembers | paginator: pageEvent">
-            <a href="/server/{{server.id}}/management/users/{{user.user_id}}">
+            <a href="/controller/{{controller.id}}/management/users/{{user.user_id}}">
               <div>{{user.username}}</div>
             </a>
             <mat-icon class="clickable" (click)="openRemoveUserDialog(user)">delete</mat-icon>

src/app/components/group-details/group-details.component.ts

@@ -12,7 +12,7 @@
 */
 import {Component, OnInit} from '@angular/core';
 import {ActivatedRoute} from "@angular/router";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {Group} from "@models/groups/group";
 import {User} from "@models/users/user";
 import {FormControl, FormGroup} from "@angular/forms";
@@ -31,7 +31,7 @@ import {AddRoleToGroupComponent} from "@components/group-details/add-role-to-gro
   styleUrls: ['./group-details.component.scss']
 })
 export class GroupDetailsComponent implements OnInit {
-  server: Server;
+  controller: Controller;
   group: Group;
   members: User[];
   editGroupForm: FormGroup;
@@ -48,9 +48,9 @@ export class GroupDetailsComponent implements OnInit {
       groupname: new FormControl(''),
     });
 
-    this.route.data.subscribe((d: { server: Server; group: Group, members: User[], roles: Role[] }) => {
+    this.route.data.subscribe((d: { controller: Controller; group: Group, members: User[], roles: Role[] }) => {
 
-      this.server = d.server;
+      this.controller = d.controller;
       this.group = d.group;
       this.roles = d.roles;
       this.members = d.members.sort((a: User, b: User) => a.username.toLowerCase().localeCompare(b.username.toLowerCase()));
@@ -63,7 +63,7 @@ export class GroupDetailsComponent implements OnInit {
   }
 
   onUpdate() {
-    this.groupService.update(this.server, this.group)
+    this.groupService.update(this.controller, this.group)
       .subscribe(() => {
         this.toastService.success(`group updated`);
       }, (error) => {
@@ -77,7 +77,7 @@ export class GroupDetailsComponent implements OnInit {
       .open<AddRoleToGroupComponent>(AddRoleToGroupComponent,
         {
           width: '700px', height: '500px',
-          data: {server: this.server, group: this.group}
+          data: {controller: this.controller, group: this.group}
         })
       .afterClosed()
       .subscribe(() => {
@@ -89,7 +89,7 @@ export class GroupDetailsComponent implements OnInit {
       .open<AddUserToGroupDialogComponent>(AddUserToGroupDialogComponent,
         {
           width: '700px', height: '500px',
-          data: {server: this.server, group: this.group}
+          data: {controller: this.controller, group: this.group}
         })
       .afterClosed()
       .subscribe(() => {
@@ -103,7 +103,7 @@ export class GroupDetailsComponent implements OnInit {
       .afterClosed()
       .subscribe((confirm: boolean) => {
         if (confirm) {
-          this.groupService.removeUser(this.server, this.group, user)
+          this.groupService.removeUser(this.controller, this.group, user)
             .subscribe(() => {
                 this.toastService.success(`User ${user.username} was removed`);
                 this.reloadMembers();
@@ -123,7 +123,7 @@ export class GroupDetailsComponent implements OnInit {
       .afterClosed()
       .subscribe((confirm: string) => {
         if (confirm) {
-          this.groupService.removeRole(this.server, this.group, role)
+          this.groupService.removeRole(this.controller, this.group, role)
             .subscribe(() => {
                 this.toastService.success(`Role ${role.name} was removed`);
                 this.reloadRoles();
@@ -137,14 +137,14 @@ export class GroupDetailsComponent implements OnInit {
   }
 
   reloadMembers() {
-    this.groupService.getGroupMember(this.server, this.group.user_group_id)
+    this.groupService.getGroupMember(this.controller, this.group.user_group_id)
       .subscribe((members: User[]) => {
         this.members = members;
       });
   }
 
   reloadRoles() {
-    this.groupService.getGroupRole(this.server, this.group.user_group_id)
+    this.groupService.getGroupRole(this.controller, this.group.user_group_id)
       .subscribe((roles: Role[]) => {
         this.roles = roles;
       });

src/app/components/group-management/add-group-dialog/add-group-dialog.component.ts

@@ -16,7 +16,7 @@ import {FormBuilder, FormControl, FormGroup, Validators} from "@angular/forms";
 import {groupNameAsyncValidator} from "@components/group-management/add-group-dialog/groupNameAsyncValidator";
 import {GroupNameValidator} from "@components/group-management/add-group-dialog/GroupNameValidator";
 import {GroupService} from "../../../services/group.service";
-import {Server} from "../../../models/server";
+import {Controller} from "../../../models/controller";
 import {BehaviorSubject, forkJoin, timer} from "rxjs";
 import {User} from "@models/users/user";
 import {UserService} from "@services/user.service";
@@ -35,7 +35,7 @@ import {map, startWith} from "rxjs/operators";
 export class AddGroupDialogComponent implements OnInit {
 
   groupNameForm: FormGroup;
-  server: Server;
+  controller: Controller;
 
   users: User[];
   usersToAdd: Set<User> = new Set([]);
@@ -46,7 +46,7 @@ export class AddGroupDialogComponent implements OnInit {
 
 
   constructor(private dialogRef: MatDialogRef<AddGroupDialogComponent>,
-              @Inject(MAT_DIALOG_DATA) public data: { server: Server },
+              @Inject(MAT_DIALOG_DATA) public data: { controller: Controller },
               private formBuilder: FormBuilder,
               private groupNameValidator: GroupNameValidator,
               private groupService: GroupService,
@@ -55,15 +55,15 @@ export class AddGroupDialogComponent implements OnInit {
   }
 
   ngOnInit(): void {
-    this.server = this.data.server;
+    this.controller = this.data.controller;
     this.groupNameForm = this.formBuilder.group({
       groupName: new FormControl(
         null,
         [Validators.required, this.groupNameValidator.get],
-        [groupNameAsyncValidator(this.data.server, this.groupService)]
+        [groupNameAsyncValidator(this.data.controller, this.groupService)]
       ),
     });
-    this.userService.list(this.server)
+    this.userService.list(this.controller)
       .subscribe((users: User[]) => {
         this.users = users;
         this.filteredUsers = this.autocompleteControl.valueChanges.pipe(
@@ -91,10 +91,10 @@ export class AddGroupDialogComponent implements OnInit {
     const toAdd = Array.from(this.usersToAdd.values());
 
 
-    this.groupService.addGroup(this.server, groupName)
+    this.groupService.addGroup(this.controller, groupName)
       .subscribe((group) => {
         toAdd.forEach((user: User) => {
-          this.groupService.addMemberToGroup(this.server, group, user)
+          this.groupService.addMemberToGroup(this.controller, group, user)
             .subscribe(() => {
                 this.toasterService.success(`user ${user.username} was added`);
               },

src/app/components/group-management/add-group-dialog/groupNameAsyncValidator.ts

@@ -12,14 +12,14 @@
 */
 import { FormControl } from '@angular/forms';
 import { timer } from 'rxjs';
-import {map, switchMap, tap} from 'rxjs/operators';
-import {Server} from "../../../models/server";
-import {GroupService} from "../../../services/group.service";
+import { map, switchMap, tap } from 'rxjs/operators';
+import { Controller } from "../../../models/controller";
+import { GroupService } from "../../../services/group.service";
 
-export const groupNameAsyncValidator = (server: Server, groupService: GroupService) => {
+export const groupNameAsyncValidator = (controller: Controller, groupService: GroupService) => {
   return (control: FormControl) => {
     return timer(500).pipe(
-      switchMap(() => groupService.getGroups(server)),
+      switchMap(() => groupService.getGroups(controller)),
       map((response) => {
         console.log(response);
         return (response.find((n) => n.name === control.value) ? { projectExist: true } : null);

src/app/components/group-management/group-management.component.html

@@ -37,7 +37,7 @@
 
       <ng-container matColumnDef="name">
         <th mat-header-cell *matHeaderCellDef mat-sort-header> Name</th>
-        <td mat-cell *matCellDef="let element"><a class="table-link" routerLink="/server/{{server.id}}/management/groups/{{element.user_group_id}}">{{element.name}}</a> </td>
+        <td mat-cell *matCellDef="let element"><a class="table-link" routerLink="/controller/{{controller.id}}/management/groups/{{element.user_group_id}}">{{element.name}}</a> </td>
       </ng-container>
 
       <ng-container matColumnDef="created_at">

src/app/components/group-management/group-management.component.ts

@@ -12,10 +12,10 @@
 */
 import {Component, OnInit, QueryList, ViewChild, ViewChildren} from '@angular/core';
 import {ActivatedRoute, Router} from "@angular/router";
-import {ServerService} from "../../services/server.service";
+import {ControllerService} from "../../services/controller.service";
 import {ToasterService} from "../../services/toaster.service";
 import {GroupService} from "../../services/group.service";
-import {Server} from "../../models/server";
+import {Controller} from "../../models/controller";
 import {Group} from "../../models/groups/group";
 import {MatSort, Sort} from "@angular/material/sort";
 import {MatDialog} from "@angular/material/dialog";
@@ -33,7 +33,7 @@ import {MatTableDataSource} from "@angular/material/table";
   styleUrls: ['./group-management.component.scss']
 })
 export class GroupManagementComponent implements OnInit {
-  server: Server;
+  controller: Controller;
 
   @ViewChildren('groupsPaginator') groupsPaginator: QueryList<MatPaginator>;
   @ViewChildren('groupsSort') groupsSort: QueryList<MatSort>;
@@ -47,7 +47,7 @@ export class GroupManagementComponent implements OnInit {
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private toasterService: ToasterService,
     public groupService: GroupService,
     public dialog: MatDialog
@@ -56,9 +56,9 @@ export class GroupManagementComponent implements OnInit {
 
 
   ngOnInit(): void {
-    const serverId = this.route.parent.snapshot.paramMap.get('server_id');
-    this.serverService.get(+serverId).then((server: Server) => {
-      this.server = server;
+    const controllerId = this.route.parent.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(+controllerId).then((controller: Controller) => {
+      this.controller = controller;
       this.refresh();
     });
   }
@@ -95,7 +95,7 @@ export class GroupManagementComponent implements OnInit {
 
   addGroup() {
     this.dialog
-      .open(AddGroupDialogComponent, {width: '600px', height: '500px', data: {server: this.server}})
+      .open(AddGroupDialogComponent, {width: '600px', height: '500px', data: {controller: this.controller}})
       .afterClosed()
       .subscribe((added: boolean) => {
         if (added) {
@@ -105,7 +105,7 @@ export class GroupManagementComponent implements OnInit {
   }
 
   refresh() {
-    this.groupService.getGroups(this.server).subscribe((groups: Group[]) => {
+    this.groupService.getGroups(this.controller).subscribe((groups: Group[]) => {
       this.isReady = true;
       this.groups = groups;
       this.dataSource.data = groups;
@@ -119,7 +119,7 @@ export class GroupManagementComponent implements OnInit {
       .afterClosed()
       .subscribe((isDeletedConfirm) => {
         if (isDeletedConfirm) {
-          const observables = groupsToDelete.map((group: Group) => this.groupService.delete(this.server, group.user_group_id));
+          const observables = groupsToDelete.map((group: Group) => this.groupService.delete(this.controller, group.user_group_id));
           forkJoin(observables)
             .subscribe(() => {
                 this.refresh();

src/app/components/image-manager/add-image-dialog/add-image-dialog.component.spec.ts

@@ -5,10 +5,10 @@ import { MatIconModule } from '@angular/material/icon';
 import { MatMenuModule } from '@angular/material/menu';
 import { MatToolbarModule } from '@angular/material/toolbar';
 import { ImageManagerService } from 'app/services/image-manager.service';
-import { ServerService } from '../../../services/server.service';
-import { MockedServerService } from '../../../services/server.service.spec';
+import { ControllerService } from '../../../services/controller.service';
+import { MockedControllerService } from '../../../services/controller.service.spec';
 import { of } from 'rxjs';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 
 import { AddImageDialogComponent } from './add-image-dialog.component';
 import { NO_ERRORS_SCHEMA } from '@angular/core';
@@ -17,7 +17,7 @@ import { MockedToasterService } from 'app/services/toaster.service.spec';
 import { MatSnackBarModule } from '@angular/material/snack-bar';
 
 export class MockedImageManagerService {
-  public getImages(server: Server) {
+  public getImages(controller:Controller ) {
     return of();
   }
 
@@ -26,8 +26,8 @@ export class MockedImageManagerService {
 describe('AddImageDialogComponent', () => {
   let component: AddImageDialogComponent;
   let fixture: ComponentFixture<AddImageDialogComponent>;
-  
-  let mockedServerService = new MockedServerService();
+
+  let mockedControllerService = new MockedControllerService();
   let mockedImageManagerService = new MockedImageManagerService()
   let mockedToasterService = new MockedToasterService()
 
@@ -42,7 +42,7 @@ describe('AddImageDialogComponent', () => {
         MatSnackBarModule
       ],
       providers: [
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: ImageManagerService, useValue: mockedImageManagerService },
         { provide: MAT_DIALOG_DATA, useValue: {} },
         { provide: MatDialogRef, useValue: {} },

src/app/components/image-manager/add-image-dialog/add-image-dialog.component.ts

@@ -3,7 +3,7 @@ import { Component, Inject, OnInit } from '@angular/core';
 import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
 import { UploadServiceService } from 'app/common/uploading-processbar/upload-service.service';
 import { FileItem, FileUploader, ParsedResponseHeaders } from 'ng2-file-upload';
-import { Server } from '../../../models/server';
+import{ Controller } from '../../../models/controller';
 import { ImageManagerService } from '../../../services/image-manager.service';
 import { ToasterService } from '../../../services/toaster.service';
 
@@ -20,7 +20,7 @@ import { ToasterService } from '../../../services/toaster.service';
   ],
 })
 export class AddImageDialogComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   isInstallAppliance: boolean = false;
   install_appliance: boolean = false;
   selectFile: any = [];
@@ -36,7 +36,7 @@ export class AddImageDialogComponent implements OnInit {
   ) {}
 
   public ngOnInit() {
-    this.server = this.data;
+    this.controller =this.data;
 
     this.uploaderImage = new FileUploader({});
     this.uploaderImage.onAfterAddingFile = (file) => {
@@ -98,11 +98,11 @@ export class AddImageDialogComponent implements OnInit {
       let file = event;
       let fileReader: FileReader = new FileReader();
       fileReader.onloadend = () => {
-        const url = this.imageService.getImagePath(this.server, this.install_appliance, fileName);
+        const url = this.imageService.getImagePath(this.controller, this.install_appliance, fileName);
         const itemToUpload = this.uploaderImage.queue[i];
         itemToUpload.url = url;
         if ((itemToUpload as any).options) (itemToUpload as any).options.disableMultipart = true;
-        (itemToUpload as any).options.headers = [{ name: 'Authorization', value: 'Bearer ' + this.server.authToken }];
+        (itemToUpload as any).options.headers = [{ name: 'Authorization', value: 'Bearer ' + this.controller.authToken }];
         this.uploaderImage.uploadItem(itemToUpload);
       };
       fileReader.readAsText(file);

src/app/components/image-manager/deleteallfiles-dialog/deleteallfiles-dialog.component.spec.ts

@@ -10,14 +10,14 @@ import { MockedToasterService } from 'app/services/toaster.service.spec';
 import { Server } from 'http';
 import { of } from 'rxjs';
 import { ImageManagerService } from '../../../services/image-manager.service';
-import { ServerService } from '../../../services/server.service';
-import { MockedServerService } from '../../../services/server.service.spec';
+import { ControllerService } from '../../../services/controller.service';
+import { MockedControllerService } from '../../../services/controller.service.spec';
 import { ImageManagerComponent } from '../image-manager.component';
 
 import { DeleteAllImageFilesDialogComponent } from './deleteallfiles-dialog.component';
 
 export class MockedImageManagerService {
-  public deleteALLFile(server: Server, image_path) {
+  public deleteALLFile(controller:Server , image_path) {
     return of();
   }
 }
@@ -25,7 +25,7 @@ export class MockedImageManagerService {
  describe('DeleteAllImageFilesDialogComponent', () => {
   let component: DeleteAllImageFilesDialogComponent;
   let fixture: ComponentFixture<DeleteAllImageFilesDialogComponent>;
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedImageManagerService = new MockedImageManagerService()
   let mockedToasterService = new MockedToasterService()
 
@@ -39,7 +39,7 @@ export class MockedImageManagerService {
         MatDialogModule,
       ],
       providers: [
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: ImageManagerService, useValue: mockedImageManagerService },
         { provide: MAT_DIALOG_DATA, useValue: {} },
         { provide: MatDialogRef, useValue: {} },

src/app/components/image-manager/deleteallfiles-dialog/deleteallfiles-dialog.component.ts

@@ -35,7 +35,7 @@ export class DeleteAllImageFilesDialogComponent implements OnInit {
   deleteFile() {
     const calls = [];
     this.deleteData.deleteFilesPaths.forEach(pathElement => {
-      calls.push(this.imageService.deleteFile(this.deleteData.server, pathElement.filename).pipe(catchError(error => of(error))))
+      calls.push(this.imageService.deleteFile(this.deleteData.controller, pathElement.filename).pipe(catchError(error => of(error))))
     });
     Observable.forkJoin(calls).subscribe(responses => {
       this.deleteFliesDetails = responses.filter(x => x !== null)

src/app/components/image-manager/image-database-file.ts

@@ -20,14 +20,14 @@ export class imageDatabase {
 }
 
 export class imageDataSource extends DataSource<Image> {
-  constructor(private serverDatabase: imageDatabase) {
+  constructor(private controllerDatabase: imageDatabase) {
     super();
   }
 
   connect(): Observable<Image[]> {
-    return merge(this.serverDatabase.dataChange).pipe(
+    return merge(this.controllerDatabase.dataChange).pipe(
       map(() => {
-        return this.serverDatabase.data;
+        return this.controllerDatabase.data;
       })
     );
   }

src/app/components/image-manager/image-manager.component.html

@@ -15,7 +15,7 @@
 
   </div>
   <div class="default-content">
-    <app-server-discovery></app-server-discovery>
+    <app-controller-discovery></app-controller-discovery>
 
     <div class="mat-elevation-z8">
       <mat-table #table [dataSource]="dataSource">

src/app/components/image-manager/image-manager.component.spec.ts

@@ -6,10 +6,10 @@ import { MatIconModule } from '@angular/material/icon';
 import { MatMenuModule } from '@angular/material/menu';
 import { MatToolbarModule } from '@angular/material/toolbar';
 import { ImageManagerService } from 'app/services/image-manager.service';
-import { ServerService } from 'app/services/server.service';
-import { MockedServerService } from 'app/services/server.service.spec';
+import { ControllerService } from 'app/services/controller.service';
+import { MockedControllerService } from 'app/services/controller.service.spec';
 import { of } from 'rxjs';
-import { Server } from '../../models/server';
+import{ Controller } from '../../models/controller';
 
 import { ImageManagerComponent } from './image-manager.component';
 import { Image } from '../../models/images';
@@ -23,11 +23,11 @@ import { ToasterService } from 'app/services/toaster.service';
 import { MockedToasterService } from 'app/services/toaster.service.spec';
 
 export class MockedImageManagerService {
-  public getImages(server: Server) {
+  public getImages(controller:Controller ) {
     return of();
   }
 
-  public deleteFile(server: Server, image_path) {
+  public deleteFile(controller:Controller , image_path) {
     return of();
   }
 
@@ -37,7 +37,7 @@ describe('ImageManagerComponent', () => {
   let component: ImageManagerComponent;
   let fixture: ComponentFixture<ImageManagerComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedImageManagerService = new MockedImageManagerService()
   let mockedProgressService = new MockedProgressService()
   let mockedVersionService = new MockedVersionService()
@@ -59,7 +59,7 @@ describe('ImageManagerComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: ImageManagerService, useValue: mockedImageManagerService },
         { provide: ProgressService, useValue: mockedProgressService },
         { provide: VersionService, useValue: mockedVersionService },

src/app/components/image-manager/image-manager.component.ts

@@ -1,10 +1,10 @@
 import { Component, OnInit } from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
-import { ServerService } from '../../services/server.service';
+import { ControllerService } from '../../services/controller.service';
 import { VersionService } from '../../services/version.service';
 import { ProgressService } from 'app/common/progress/progress.service';
 import { Image } from '../../models/images';
-import { Server } from '../../models/server';
+import{ Controller } from '../../models/controller';
 import { ImageManagerService } from "../../services/image-manager.service";
 import { DataSource, SelectionModel } from '@angular/cdk/collections';
 import { AddImageDialogComponent } from './add-image-dialog/add-image-dialog.component';
@@ -19,7 +19,7 @@ import { imageDataSource, imageDatabase } from "./image-database-file";
   styleUrls: ['./image-manager.component.scss']
 })
 export class ImageManagerComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   public version: string;
   dataSource: imageDataSource;
   imageDatabase = new imageDatabase();
@@ -32,7 +32,7 @@ export class ImageManagerComponent implements OnInit {
     private imageService: ImageManagerService,
     private progressService: ProgressService,
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private versionService: VersionService,
     private dialog: MatDialog,
     private toasterService: ToasterService,
@@ -40,13 +40,13 @@ export class ImageManagerComponent implements OnInit {
   ) { }
 
   ngOnInit(): void {
-    let server_id = parseInt(this.route.snapshot.paramMap.get('server_id'));
-    this.serverService.get(server_id).then((server: Server) => {
-      this.server = server;
-      if (server.authToken) {
+    let controller_id = parseInt(this.route.snapshot.paramMap.get('controller_id'));
+    this.controllerService.get(controller_id).then((controller:Controller ) => {
+      this.controller = controller;
+      if (controller.authToken) {
         this.getImages()
       }
-      // this.versionService.get(this.server).subscribe((version: Version) => {
+      // this.versionService.get(this.controller).subscribe((version: Version) => {
       //   this.version = version.version;
       // });
     });
@@ -54,7 +54,7 @@ export class ImageManagerComponent implements OnInit {
   }
 
   getImages() {
-    this.imageService.getImages(this.server).subscribe(
+    this.imageService.getImages(this.controller).subscribe(
       (images: Image[]) => {
         this.imageDatabase.addImages(images)
       },
@@ -66,7 +66,7 @@ export class ImageManagerComponent implements OnInit {
   }
 
   deleteFile(path) {
-    this.imageService.deleteFile(this.server, path).subscribe(
+    this.imageService.deleteFile(this.controller, path).subscribe(
       (res) => {
         this.getImages()
         this.unChecked()
@@ -106,7 +106,7 @@ export class ImageManagerComponent implements OnInit {
       maxHeight: '550px',
       autoFocus: false,
       disableClose: true,
-      data: this.server
+      data: this.controller
     });
 
     dialogRef.afterClosed().subscribe((isAddes: boolean) => {
@@ -128,7 +128,7 @@ export class ImageManagerComponent implements OnInit {
       autoFocus: false,
       disableClose: true,
       data: {
-        server: this.server,
+        controller: this.controller,
         deleteFilesPaths: this.selection.selected
       }
     });

src/app/components/login/login.component.ts

@@ -2,11 +2,11 @@ import { Component, DoCheck, OnInit, ViewEncapsulation } from '@angular/core';
 import { FormControl, FormGroup, Validators } from '@angular/forms';
 import { ActivatedRoute, Router } from '@angular/router';
 import { AuthResponse } from '../../models/authResponse';
-import { Server } from '../../models/server';
+import{ Controller } from '../../models/controller';
 import { Version } from '../../models/version';
 import { LoginService } from '../../services/login.service';
-import { ServerDatabase } from '../../services/server.database';
-import { ServerService } from '../../services/server.service';
+import { ControllerDatabase } from '../../services/controller.database';
+import { ControllerService } from '../../services/controller.service';
 import { ThemeService } from '../../services/theme.service';
 import { ToasterService } from '../../services/toaster.service';
 import { VersionService } from '../../services/version.service';
@@ -18,7 +18,7 @@ import { VersionService } from '../../services/version.service';
   encapsulation: ViewEncapsulation.None,
 })
 export class LoginComponent implements OnInit, DoCheck {
-  private server: Server;
+  private controller:Controller ;
   public version: string;
   public isLightThemeEnabled: boolean = false;
   public loginError: boolean = false;
@@ -33,8 +33,8 @@ export class LoginComponent implements OnInit, DoCheck {
 
   constructor(
     private loginService: LoginService,
-    private serverService: ServerService,
-    private serverDatabase: ServerDatabase,
+    private controllerService: ControllerService,
+    private controllerDatabase: ControllerDatabase,
     private route: ActivatedRoute,
     private router: Router,
     private toasterService: ToasterService,
@@ -43,16 +43,16 @@ export class LoginComponent implements OnInit, DoCheck {
   ) {}
 
   async ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
     this.returnUrl = this.route.snapshot.queryParams['returnUrl'] || '/';
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
 
-      if (server.authToken) {
-        this.router.navigate(['/server', this.server.id, 'projects']);
+      if (controller.authToken) {
+        this.router.navigate(['/controller', this.controller.id, 'projects']);
       }
 
-      this.versionService.get(this.server).subscribe((version: Version) => {
+      this.versionService.get(this.controller).subscribe((version: Version) => {
         this.version = version.version;
       });
     });
@@ -78,17 +78,17 @@ export class LoginComponent implements OnInit, DoCheck {
     let username = this.loginForm.get('username').value;
     let password = this.loginForm.get('password').value;
 
-    this.loginService.login(this.server, username, password).subscribe(
+    this.loginService.login(this.controller, username, password).subscribe(
       async (response: AuthResponse) => {
-        let server = this.server;
-        server.authToken = response.access_token;
-        server.username = username;
-        server.password = password;
-        server.tokenExpired = false;
-        await this.serverService.update(server);
+        let controller = this.controller;
+        controller.authToken = response.access_token;
+        controller.username = username;
+        controller.password = password;
+        controller.tokenExpired = false;
+        await this.controllerService.update(controller);
 
         if (this.returnUrl.length <= 1) {
-          this.router.navigate(['/server', this.server.id, 'projects']);
+          this.router.navigate(['/controller', this.controller.id, 'projects']);
         } else {
           this.router.navigateByUrl(this.returnUrl);
         }

src/app/components/management/management.component.ts

@@ -12,8 +12,8 @@
 */
 import { Component, OnInit } from '@angular/core';
 import {ActivatedRoute, Router} from "@angular/router";
-import {Server} from "@models/server";
-import {ServerService} from "@services/server.service";
+import {Controller} from "@models/controller";
+import {ControllerService} from "@services/controller.service";
 
 @Component({
   selector: 'app-management',
@@ -22,19 +22,19 @@ import {ServerService} from "@services/server.service";
 })
 export class ManagementComponent implements OnInit {
 
-  server: Server;
+  controller: Controller;
   links = ['users', 'groups', 'roles', 'permissions'];
   activeLink: string = this.links[0];
 
   constructor(
     private route: ActivatedRoute,
     public router: Router,
-    private serverService: ServerService) { }
+    private controllerService: ControllerService) { }
 
   ngOnInit(): void {
-    const serverId = this.route.snapshot.paramMap.get('server_id');
-    this.serverService.get(+serverId).then((server: Server) => {
-      this.server = server;
+    const controllerId = this.route.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(+controllerId).then((controller: Controller) => {
+      this.controller = controller;
     });
   }
 }

src/app/components/page-not-found/page-not-found.component.html

@@ -2,6 +2,6 @@
   <div class="default-header">
     <br />
     <h1>404 Page not found</h1>
-    <button mat-button routerLink="/servers">Navigate to homepage</button>
+    <button mat-button routerLink="/controllers">Navigate to homepage</button>
   </div>
 </div>

src/app/components/permissions-management/add-permission-line/add-permission-line.component.html

@@ -4,7 +4,7 @@
       <div class="information-box">
         <div>
           <app-path-auto-complete
-            [server]="server"
+            [controller]="controller"
           (update)="permission.path = $event"></app-path-auto-complete>
         </div>
         <div class="methods">

src/app/components/permissions-management/add-permission-line/add-permission-line.component.spec.ts

@@ -5,7 +5,7 @@ import {ApiInformationService} from "@services/ApiInformation/api-information.se
 import {PermissionsService} from "@services/permissions.service";
 import {ToasterService} from "@services/toaster.service";
 import {Methods, Permission, PermissionActions} from "@models/api/permission";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {Observable, of, throwError} from "rxjs";
 import {HttpErrorResponse} from "@angular/common/http";
 
@@ -79,7 +79,7 @@ describe('AddPermissionLineComponent', () => {
     comp.permission.action = PermissionActions.DENY;
     comp.permission.description = "john doe is here";
 
-    permissionService.add = (server: Server, permission: Permission): Observable<Permission> => {
+    permissionService.add = (controller: Controller, permission: Permission): Observable<Permission> => {
       return of(permission);
     };
 
@@ -111,12 +111,12 @@ describe('AddPermissionLineComponent', () => {
 
     let errorMessage: string;
 
-    permissionService.add = (server: Server, permission: Permission): Observable<Permission> => {
+    permissionService.add = (controller: Controller, permission: Permission): Observable<Permission> => {
       const error = new HttpErrorResponse({
         error: new Error("An error occur"),
         headers: undefined,
         status: 500,
-        statusText: 'error from server'
+        statusText: 'error from controller'
       });
       return throwError(error);
     };

src/app/components/permissions-management/add-permission-line/add-permission-line.component.ts

@@ -11,7 +11,7 @@
 * Author: Sylvain MATHIEU, Elise LEBEAU
 */
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {ApiInformationService} from "@services/ApiInformation/api-information.service";
 import {Methods, Permission, PermissionActions} from "@models/api/permission";
 import {PermissionsService} from "@services/permissions.service";
@@ -25,7 +25,7 @@ import {HttpErrorResponse} from "@angular/common/http";
 })
 export class AddPermissionLineComponent implements OnInit {
 
-  @Input() server: Server;
+  @Input() controller: Controller;
   @Output() addPermissionEvent = new EventEmitter<void>();
   permission: Permission = {
     action: PermissionActions.ALLOW,
@@ -69,7 +69,7 @@ export class AddPermissionLineComponent implements OnInit {
   }
 
   save() {
-    this.permissionService.add(this.server, this.permission)
+    this.permissionService.add(this.controller, this.permission)
       .subscribe(() => {
         this.toasterService.success(`permission was created`);
         this.reset();

src/app/components/permissions-management/add-permission-line/path-auto-complete/path-auto-complete.component.ts

@@ -12,7 +12,7 @@
 */
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
 import {ApiInformationService} from "@services/ApiInformation/api-information.service";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {PermissionPath} from "@components/permissions-management/add-permission-line/path-auto-complete/PermissionPath";
 import {SubPath} from "@components/permissions-management/add-permission-line/path-auto-complete/SubPath";
 import {IGenericApiObject} from "@services/ApiInformation/IGenericApiObject";
@@ -26,7 +26,7 @@ export class PathAutoCompleteComponent implements OnInit {
 
 
   @Output() update = new EventEmitter<string>();
-  @Input() server: Server;
+  @Input() controller: Controller;
   path: PermissionPath = new PermissionPath();
   values: string[] = [];
   private completeData: { data: IGenericApiObject[]; key: string };
@@ -73,7 +73,7 @@ export class PathAutoCompleteComponent implements OnInit {
 
   valueChanged(value: string) {
     if (value.match(this.apiInformationService.bracketIdRegex) && !this.path.containStar()) {
-      this.apiInformationService.getListByObjectId(this.server, value, undefined, this.path.getVariables())
+      this.apiInformationService.getListByObjectId(this.controller, value, undefined, this.path.getVariables())
         .subscribe((data) => {
           this.mode = 'COMPLETE';
           this.completeData = {data, key: value};

src/app/components/permissions-management/display-path.pipe.spec.ts

@@ -1,7 +1,7 @@
 import {async, fakeAsync, TestBed, tick} from "@angular/core/testing";
 import {DisplayPathPipe} from "@components/permissions-management/display-path.pipe";
 import {ApiInformationService} from "@services/ApiInformation/api-information.service";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {Observable, of} from "rxjs";
 import {IExtraParams} from "@services/ApiInformation/IExtraParams";
 import {IGenericApiObject} from "@services/ApiInformation/IGenericApiObject";
@@ -33,7 +33,7 @@ describe('DisplayPathPipe', () => {
     };
 
     apiService
-      .getListByObjectId = (server: Server, key: string, value?: string, extraParams?: IExtraParams[]): Observable<IGenericApiObject[]> => {
+      .getListByObjectId = (controller: Controller, key: string, value?: string, extraParams?: IExtraParams[]): Observable<IGenericApiObject[]> => {
       if (key === 'project_id') {
         return of([{id: '1111-2222-3333', name: 'myProject'}]);
       }
@@ -44,9 +44,9 @@ describe('DisplayPathPipe', () => {
 
     let result: string;
 
-    const server = new Server();
+    const controller = new Controller();
     comp
-      .transform('/project/1111-2222-3333/nodes/2222-2222-2222', server)
+      .transform('/project/1111-2222-3333/nodes/2222-2222-2222', controller)
       .subscribe((res: string) => {
         result = res;
       });

src/app/components/permissions-management/display-path.pipe.ts

@@ -14,7 +14,7 @@ import {Pipe, PipeTransform} from '@angular/core';
 import {map, switchMap} from "rxjs/operators";
 import {forkJoin, Observable, of} from "rxjs";
 import {ApiInformationService} from "@services/ApiInformation/api-information.service";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 
 @Pipe({
   name: 'displayPath'
@@ -24,8 +24,8 @@ export class DisplayPathPipe implements PipeTransform {
   constructor(private apiInformation: ApiInformationService) {
   }
 
-  transform(originalPath: string, server: Server): Observable<string> {
-    if (!server) {
+  transform(originalPath: string, controller: Controller): Observable<string> {
+    if (!controller) {
       return of(originalPath);
     }
     return this.apiInformation
@@ -34,7 +34,7 @@ export class DisplayPathPipe implements PipeTransform {
           if (values.length === 0) {
             return of([]);
           }
-          const obs = values.map((k) => this.apiInformation.getListByObjectId(server, k.key, k.value, values));
+          const obs = values.map((k) => this.apiInformation.getListByObjectId(controller, k.key, k.value, values));
           return forkJoin(obs);
         }),
         map((values: { id: string; name: string }[][]) => {

src/app/components/permissions-management/permission-edit-line/permission-edit-line.component.html

@@ -18,9 +18,9 @@
   </div>
   <div>
     <div
-      [matTooltip]="permission.path | displayPath: server | async"
+      [matTooltip]="permission.path | displayPath: controller | async"
       matTooltipClass="custom-tooltip">
-      {{permission.path | displayPath: server | async}}
+      {{permission.path | displayPath: controller | async}}
     </div>
   </div>
   <div>

src/app/components/permissions-management/permission-edit-line/permission-edit-line.component.ts

@@ -12,7 +12,7 @@
 */
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
 import {Methods, Permission} from "@models/api/permission";
-import {Server} from '@models/server';
+import {Controller} from '@models/controller';
 import {ApiInformationService} from "@services/ApiInformation/api-information.service";
 import {PermissionsService} from "@services/permissions.service";
 import {ToasterService} from "@services/toaster.service";
@@ -26,7 +26,7 @@ import {DeletePermissionDialogComponent} from "@components/permissions-managemen
 })
 export class PermissionEditLineComponent {
   @Input() permission: Permission;
-  @Input() server: Server;
+  @Input() controller: Controller;
 
   isEditable = false;
   @Output() update = new EventEmitter<void>();
@@ -44,7 +44,7 @@ export class PermissionEditLineComponent {
       .afterClosed()
       .subscribe((confirm: boolean) => {
         if (confirm) {
-          this.permissionService.delete(this.server, this.permission.permission_id)
+          this.permissionService.delete(this.controller, this.permission.permission_id)
             .subscribe(() => {
               this.toasterService.success(`Permission was deleted`);
               this.update.emit();
@@ -58,7 +58,7 @@ export class PermissionEditLineComponent {
   }
 
   onSave() {
-    this.permissionService.update(this.server, this.permission)
+    this.permissionService.update(this.controller, this.permission)
       .subscribe(() => {
         this.toasterService.success(`Permission was updated`);
         this.update.emit();

src/app/components/permissions-management/permissions-management.component.html

@@ -1,7 +1,7 @@
 <div class="content" *ngIf="isReady; else loading">
   <div class="add">
     <app-add-permission-line
-      [server]="server"
+      [controller]="controller"
       (addPermissionEvent)="refresh()"></app-add-permission-line>
   </div>
   <div class="permission-content default-content">
@@ -22,7 +22,7 @@
     <div *ngFor="let permission of permissions | permissionsFilter: searchPermissions?.id | paginator: pageEvent">
       <app-permission-add-edit-line
               [permission]="permission"
-              [server]="server"
+              [controller]="controller"
         (update)="refresh()"></app-permission-add-edit-line>
     </div>
     <mat-paginator [length]="permissions.length" (page)="pageEvent = $event"

src/app/components/permissions-management/permissions-management.component.ts

@@ -12,12 +12,12 @@
 */
 import {Component, ComponentFactoryResolver, OnInit, ViewChild, ViewContainerRef} from '@angular/core';
 import {ActivatedRoute, Router} from "@angular/router";
-import {Server} from "@models/server";
+import {Controller} from "@models/controller";
 import {PermissionsService} from "@services/permissions.service";
 import {ProgressService} from "../../common/progress/progress.service";
 import {Permission} from "@models/api/permission";
 import {AddPermissionLineComponent} from "@components/permissions-management/add-permission-line/add-permission-line.component";
-import {ServerService} from "@services/server.service";
+import {ControllerService} from "@services/controller.service";
 import {PageEvent} from "@angular/material/paginator";
 import {ApiInformationService} from "@services/ApiInformation/api-information.service";
 import {IGenericApiObject} from "@services/ApiInformation/IGenericApiObject";
@@ -28,7 +28,7 @@ import {IGenericApiObject} from "@services/ApiInformation/IGenericApiObject";
   styleUrls: ['./permissions-management.component.scss']
 })
 export class PermissionsManagementComponent implements OnInit {
-  server: Server;
+  controller: Controller;
   permissions: Permission[];
   addPermissionLineComp = AddPermissionLineComponent;
   newPermissionEdit = false;
@@ -46,19 +46,19 @@ export class PermissionsManagementComponent implements OnInit {
               private router: Router,
               private permissionService: PermissionsService,
               private progressService: ProgressService,
-              private serverService: ServerService,
+              private controllerService: ControllerService,
               private apiInformationService: ApiInformationService) { }
 
   ngOnInit(): void {
-    const serverId = this.route.parent.snapshot.paramMap.get('server_id');
-    this.serverService.get(+serverId).then((server: Server) => {
-      this.server = server;
+    const controllerId = this.route.parent.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(+controllerId).then((controller: Controller) => {
+      this.controller = controller;
       this.refresh();
     });
   }
 
   refresh() {
-    this.permissionService.list(this.server).subscribe(
+    this.permissionService.list(this.controller).subscribe(
       (permissions: Permission[]) => {
         this.permissions = permissions;
         this.isReady = true;

src/app/components/preferences/built-in/built-in-preferences.component.html

@@ -2,7 +2,7 @@
   <div class="default-header">
     <div class="row">
       <h1 class="col">Built-in preferences</h1>
-      <button class="top-button" class="cancel-button" routerLink="/server/{{ serverId }}/preferences" mat-button>
+      <button class="top-button" class="cancel-button" routerLink="/controller/{{ controllerId }}/preferences" mat-button>
         Back
       </button>
     </div>
@@ -10,13 +10,13 @@
   <div class="default-content">
     <div class="listcontainer mat-elevation-z8">
       <mat-nav-list>
-        <mat-list-item routerLink="/server/{{ serverId }}/preferences/builtin/ethernet-hubs">
+        <mat-list-item routerLink="/controller/{{ controllerId }}/preferences/builtin/ethernet-hubs">
           Ethernet hubs
         </mat-list-item>
-        <mat-list-item routerLink="/server/{{ serverId }}/preferences/builtin/ethernet-switches">
+        <mat-list-item routerLink="/controller/{{ controllerId }}/preferences/builtin/ethernet-switches">
           Ethernet switches
         </mat-list-item>
-        <mat-list-item routerLink="/server/{{ serverId }}/preferences/builtin/cloud-nodes"> Cloud nodes </mat-list-item>
+        <mat-list-item routerLink="/controller/{{ controllerId }}/preferences/builtin/cloud-nodes"> Cloud nodes </mat-list-item>
       </mat-nav-list>
     </div>
   </div>

src/app/components/preferences/built-in/built-in-preferences.component.spec.ts

@@ -48,7 +48,7 @@ describe('BuiltInPreferencesComponent', () => {
     expect(component).toBeTruthy();
   });
 
-  it('should set correct server id', () => {
-    expect(component.serverId).toBe('1');
+  it('should set correct controller id', () => {
+    expect(component.controllerId).toBe('1');
   });
 });

src/app/components/preferences/built-in/built-in-preferences.component.ts

@@ -7,11 +7,11 @@ import { ActivatedRoute } from '@angular/router';
   styleUrls: ['./built-in-preferences.component.scss', '../preferences.component.scss'],
 })
 export class BuiltInPreferencesComponent implements OnInit {
-  public serverId: string = '';
+  public controllerId: string = '';
 
   constructor(private route: ActivatedRoute) {}
 
   ngOnInit() {
-    this.serverId = this.route.snapshot.paramMap.get('server_id');
+    this.controllerId = this.route.snapshot.paramMap.get('controller_id');
   }
 }

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-add-template/cloud-nodes-add-template.component.html

@@ -7,7 +7,7 @@
   <div class="default-content">
     <mat-card class="matCard">
       <mat-radio-group class="radio-group">
-        <mat-radio-button class="radio-button" value="1" (click)="setServerType('local')" checked
+        <mat-radio-button class="radio-button" value="1" (click)="setControllerType('local')" checked
           >Run the cloud node locally</mat-radio-button
         >
       </mat-radio-group>

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-add-template/cloud-nodes-add-template.component.spec.ts

@@ -10,12 +10,12 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { CloudTemplate } from '../../../../../models/templates/cloud-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
 import { ComputeService } from '../../../../../services/compute.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { TemplateMocksService } from '../../../../../services/template-mocks.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 import { MockedToasterService } from '../../../../../services/toaster.service.spec';
@@ -24,7 +24,7 @@ import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { CloudNodesAddTemplateComponent } from './cloud-nodes-add-template.component';
 
 export class MockedBuiltInTemplatesService {
-  public addTemplate(server: Server, cloudTemplate: CloudTemplate) {
+  public addTemplate(controller:Controller , cloudTemplate: CloudTemplate) {
     return of(cloudTemplate);
   }
 }
@@ -33,7 +33,7 @@ describe('CloudNodesAddTemplateComponent', () => {
   let component: CloudNodesAddTemplateComponent;
   let fixture: ComponentFixture<CloudNodesAddTemplateComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let mockedToasterService = new MockedToasterService();
   let mockedComputeService = new MockedComputeService();
@@ -51,12 +51,12 @@ describe('CloudNodesAddTemplateComponent', () => {
         CommonModule,
         NoopAnimationsModule,
         RouterTestingModule.withRoutes([
-          { path: 'server/1/preferences/builtin/cloud-nodes', component: CloudNodesAddTemplateComponent },
+          { path: 'controller/1/preferences/builtin/cloud-nodes', component: CloudNodesAddTemplateComponent },
         ]),
       ],
       providers: [
         { provide: ActivatedRoute, useValue: activatedRoute },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
         { provide: ToasterService, useValue: mockedToasterService },
         { provide: ComputeService, useValue: mockedComputeService },
@@ -80,7 +80,7 @@ describe('CloudNodesAddTemplateComponent', () => {
   it('should call add template', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as CloudTemplate));
     component.templateName = 'sample name';
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
     component.formGroup.controls['templateName'].setValue('template name');
 
     component.addTemplate();
@@ -92,7 +92,7 @@ describe('CloudNodesAddTemplateComponent', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as CloudTemplate));
     spyOn(mockedToasterService, 'error');
     component.templateName = '';
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
 
     component.addTemplate();
 

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-add-template/cloud-nodes-add-template.component.ts

@@ -3,11 +3,11 @@ import { FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms'
 import { ActivatedRoute, Router } from '@angular/router';
 import { v4 as uuid } from 'uuid';
 import { Compute } from '../../../../../models/compute';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { CloudTemplate } from '../../../../../models/templates/cloud-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
 import { ComputeService } from '../../../../../services/compute.service';
-import { ServerService } from '../../../../../services/server.service';
+import { ControllerService } from '../../../../../services/controller.service';
 import { TemplateMocksService } from '../../../../../services/template-mocks.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 
@@ -17,14 +17,14 @@ import { ToasterService } from '../../../../../services/toaster.service';
   styleUrls: ['./cloud-nodes-add-template.component.scss', '../../../preferences.component.scss'],
 })
 export class CloudNodesAddTemplateComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   templateName: string = '';
   formGroup: FormGroup;
   isLocalComputerChosen: boolean = true;
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private builtInTemplatesService: BuiltInTemplatesService,
     private router: Router,
     private toasterService: ToasterService,
@@ -38,20 +38,20 @@ export class CloudNodesAddTemplateComponent implements OnInit {
   }
 
   ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
     });
   }
 
-  setServerType(serverType: string) {
-    if (serverType === 'local') {
+  setControllerType(controllerType: string) {
+    if (controllerType === 'local') {
       this.isLocalComputerChosen = true;
     }
   }
 
   goBack() {
-    this.router.navigate(['/server', this.server.id, 'preferences', 'builtin', 'cloud-nodes']);
+    this.router.navigate(['/controller', this.controller.id, 'preferences', 'builtin', 'cloud-nodes']);
   }
 
   addTemplate() {
@@ -66,7 +66,7 @@ export class CloudNodesAddTemplateComponent implements OnInit {
       cloudTemplate.name = this.formGroup.get('templateName').value;
       cloudTemplate.compute_id = 'local';
 
-      this.builtInTemplatesService.addTemplate(this.server, cloudTemplate).subscribe((cloudNodeTemplate) => {
+      this.builtInTemplatesService.addTemplate(this.controller, cloudTemplate).subscribe((cloudNodeTemplate) => {
         this.goBack();
       });
     } else {

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-template-details/cloud-nodes-template-details.component.html

@@ -181,7 +181,7 @@
 </div>
 <app-symbols-menu
   *ngIf="isSymbolSelectionOpened && cloudNodeTemplate"
-  [server]="server"
+  [controller]="controller"
   [symbol]="cloudNodeTemplate.symbol"
   (symbolChangedEmitter)="symbolChanged($event)"
 ></app-symbols-menu>

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-template-details/cloud-nodes-template-details.component.spec.ts

@@ -11,23 +11,23 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { CloudTemplate } from '../../../../../models/templates/cloud-template';
 import { BuiltInTemplatesConfigurationService } from '../../../../../services/built-in-templates-configuration.service';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { ToasterService } from '../../../../../services/toaster.service';
 import { MockedToasterService } from '../../../../../services/toaster.service.spec';
 import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { CloudNodesTemplateDetailsComponent } from './cloud-nodes-template-details.component';
 
 export class MockedBuiltInTemplatesService {
-  public getTemplate(server: Server, template_id: string) {
+  public getTemplate(controller:Controller , template_id: string) {
     return of({ ports_mapping: [] } as CloudTemplate);
   }
 
-  public saveTemplate(server: Server, cloudTemplate: CloudTemplate) {
+  public saveTemplate(controller:Controller , cloudTemplate: CloudTemplate) {
     return of(cloudTemplate);
   }
 }
@@ -36,7 +36,7 @@ describe('CloudNodesTemplateDetailsComponent', () => {
   let component: CloudNodesTemplateDetailsComponent;
   let fixture: ComponentFixture<CloudNodesTemplateDetailsComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let mockedToasterService = new MockedToasterService();
   let activatedRoute = new MockedActivatedRoute().get();
@@ -60,7 +60,7 @@ describe('CloudNodesTemplateDetailsComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
         { provide: ToasterService, useValue: mockedToasterService },
         { provide: BuiltInTemplatesConfigurationService, useClass: BuiltInTemplatesConfigurationService },

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-template-details/cloud-nodes-template-details.component.ts

@@ -1,11 +1,11 @@
 import { Component, OnInit } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { PortsMappingEntity } from '../../../../../models/ethernetHub/ports-mapping-enity';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { CloudTemplate } from '../../../../../models/templates/cloud-template';
 import { BuiltInTemplatesConfigurationService } from '../../../../../services/built-in-templates-configuration.service';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
+import { ControllerService } from '../../../../../services/controller.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 
 @Component({
@@ -14,7 +14,7 @@ import { ToasterService } from '../../../../../services/toaster.service';
   styleUrls: ['./cloud-nodes-template-details.component.scss', '../../../preferences.component.scss'],
 })
 export class CloudNodesTemplateDetailsComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   cloudNodeTemplate: CloudTemplate;
 
   isSymbolSelectionOpened: boolean = false;
@@ -34,7 +34,7 @@ export class CloudNodesTemplateDetailsComponent implements OnInit {
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private builtInTemplatesService: BuiltInTemplatesService,
     private toasterService: ToasterService,
     private builtInTemplatesConfigurationService: BuiltInTemplatesConfigurationService,
@@ -47,14 +47,14 @@ export class CloudNodesTemplateDetailsComponent implements OnInit {
   }
 
   ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
     const template_id = this.route.snapshot.paramMap.get('template_id');
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
 
       this.getConfiguration();
       this.builtInTemplatesService
-        .getTemplate(this.server, template_id)
+        .getTemplate(this.controller, template_id)
         .subscribe((cloudNodeTemplate: CloudTemplate) => {
           this.cloudNodeTemplate = cloudNodeTemplate;
 
@@ -70,7 +70,7 @@ export class CloudNodesTemplateDetailsComponent implements OnInit {
   }
 
   goBack() {
-    this.router.navigate(['/server', this.server.id, 'preferences', 'builtin', 'cloud-nodes']);
+    this.router.navigate(['/controller', this.controller.id, 'preferences', 'builtin', 'cloud-nodes']);
   }
 
   getConfiguration() {
@@ -114,7 +114,7 @@ export class CloudNodesTemplateDetailsComponent implements OnInit {
     this.cloudNodeTemplate.ports_mapping = [...this.portsMappingEthernet, ...this.portsMappingTap];
 
     this.builtInTemplatesService
-      .saveTemplate(this.server, this.cloudNodeTemplate)
+      .saveTemplate(this.controller, this.cloudNodeTemplate)
       .subscribe((cloudNodeTemplate: CloudTemplate) => {
         this.toasterService.success('Changes saved');
       });

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-templates/cloud-nodes-templates.component.html

@@ -3,18 +3,18 @@
     <div class="row">
       <h1 class="col">Cloud nodes templates</h1>
       <button
-        *ngIf="server"
+        *ngIf="controller"
         class="top-button"
         class="cancel-button"
-        routerLink="/server/{{ server.id }}/preferences/builtin"
+        routerLink="/controller/{{ controller.id }}/preferences/builtin"
         mat-button
       >
         Back
       </button>
       <button
-        *ngIf="server"
+        *ngIf="controller"
         class="top-button"
-        routerLink="/server/{{ server.id }}/preferences/builtin/cloud-nodes/addtemplate"
+        routerLink="/controller/{{ controller.id }}/preferences/builtin/cloud-nodes/addtemplate"
         mat-raised-button
         color="primary"
       >
@@ -25,7 +25,7 @@
   <app-empty-templates-list *ngIf="!cloudNodesTemplates.length"></app-empty-templates-list>
   <div class="default-content" *ngIf="cloudNodesTemplates.length">
     <div class="listcontainer mat-elevation-z8">
-      <mat-nav-list *ngIf="server">
+      <mat-nav-list *ngIf="controller">
         <div class="list-item" *ngFor="let template of cloudNodesTemplates">
           <mat-list-item class="template-name" routerLink="{{ template.template_id }}">{{
             template.name
@@ -43,4 +43,4 @@
     </div>
   </div>
 </div>
-<app-delete-template #deleteComponent [server]="server" (deleteEvent)="onDeleteEvent()"> </app-delete-template>
+<app-delete-template #deleteComponent [controller]="controller" (deleteEvent)="onDeleteEvent()"> </app-delete-template>

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-templates/cloud-nodes-templates.component.spec.ts

@@ -9,16 +9,16 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { CloudTemplate } from '../../../../../models/templates/cloud-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { CloudNodesTemplatesComponent } from './cloud-nodes-templates.component';
 
 export class MockedBuiltInTemplatesService {
-  public getTemplates(server: Server) {
+  public getTemplates(controller:Controller ) {
     return of([{} as CloudTemplate]);
   }
 }
@@ -27,7 +27,7 @@ describe('CloudNodesTemplatesComponent', () => {
   let component: CloudNodesTemplatesComponent;
   let fixture: ComponentFixture<CloudNodesTemplatesComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let activatedRoute = new MockedActivatedRoute().get();
 
@@ -47,7 +47,7 @@ describe('CloudNodesTemplatesComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
       ],
       declarations: [CloudNodesTemplatesComponent],

src/app/components/preferences/built-in/cloud-nodes/cloud-nodes-templates/cloud-nodes-templates.component.ts

@@ -1,9 +1,9 @@
 import { Component, OnInit, ViewChild } from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { CloudTemplate } from '../../../../../models/templates/cloud-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
+import { ControllerService } from '../../../../../services/controller.service';
 import { DeleteTemplateComponent } from '../../../common/delete-template-component/delete-template.component';
 
 @Component({
@@ -12,26 +12,26 @@ import { DeleteTemplateComponent } from '../../../common/delete-template-compone
   styleUrls: ['./cloud-nodes-templates.component.scss', '../../../preferences.component.scss'],
 })
 export class CloudNodesTemplatesComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   cloudNodesTemplates: CloudTemplate[] = [];
   @ViewChild(DeleteTemplateComponent) deleteComponent: DeleteTemplateComponent;
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private builtInTemplatesService: BuiltInTemplatesService
   ) {}
 
   ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
       this.getTemplates();
     });
   }
 
   getTemplates() {
-    this.builtInTemplatesService.getTemplates(this.server).subscribe((cloudNodesTemplates: CloudTemplate[]) => {
+    this.builtInTemplatesService.getTemplates(this.controller).subscribe((cloudNodesTemplates: CloudTemplate[]) => {
       this.cloudNodesTemplates = cloudNodesTemplates.filter((elem) => elem.template_type === 'cloud' && !elem.builtin);
     });
   }

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-add-template/ethernet-hubs-add-template.component.html

@@ -7,7 +7,7 @@
   <div class="default-content">
     <mat-card class="matCard">
       <mat-radio-group class="radio-group">
-        <mat-radio-button class="radio-button" value="1" (click)="setServerType('local')" checked
+        <mat-radio-button class="radio-button" value="1" (click)="setControllerType('local')" checked
           >Run the Ethernet Hub locally</mat-radio-button
         >
       </mat-radio-group>

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-add-template/ethernet-hubs-add-template.component.spec.ts

@@ -10,12 +10,12 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetHubTemplate } from '../../../../../models/templates/ethernet-hub-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
 import { ComputeService } from '../../../../../services/compute.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { TemplateMocksService } from '../../../../../services/template-mocks.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 import { MockedToasterService } from '../../../../../services/toaster.service.spec';
@@ -24,7 +24,7 @@ import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { EthernetHubsAddTemplateComponent } from './ethernet-hubs-add-template.component';
 
 export class MockedBuiltInTemplatesService {
-  public addTemplate(server: Server, ethernetHubTemplate: EthernetHubTemplate) {
+  public addTemplate(controller:Controller , ethernetHubTemplate: EthernetHubTemplate) {
     return of(ethernetHubTemplate);
   }
 }
@@ -33,7 +33,7 @@ describe('EthernetHubsAddTemplateComponent', () => {
   let component: EthernetHubsAddTemplateComponent;
   let fixture: ComponentFixture<EthernetHubsAddTemplateComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let mockedToasterService = new MockedToasterService();
   let mockedComputeService = new MockedComputeService();
@@ -51,7 +51,7 @@ describe('EthernetHubsAddTemplateComponent', () => {
         CommonModule,
         NoopAnimationsModule,
         RouterTestingModule.withRoutes([
-          { path: 'server/1/preferences/builtin/ethernet-hubs', component: EthernetHubsAddTemplateComponent },
+          { path: 'controller/1/preferences/builtin/ethernet-hubs', component: EthernetHubsAddTemplateComponent },
         ]),
       ],
       providers: [
@@ -59,7 +59,7 @@ describe('EthernetHubsAddTemplateComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
         { provide: ToasterService, useValue: mockedToasterService },
         { provide: ComputeService, useValue: mockedComputeService },
@@ -83,7 +83,7 @@ describe('EthernetHubsAddTemplateComponent', () => {
   it('should call add template', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as EthernetHubTemplate));
     component.templateName = 'sample name';
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
     component.formGroup.controls['templateName'].setValue('template name');
     component.formGroup.controls['numberOfPorts'].setValue('1');
 
@@ -96,7 +96,7 @@ describe('EthernetHubsAddTemplateComponent', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as EthernetHubTemplate));
     spyOn(mockedToasterService, 'error');
     component.templateName = '';
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
 
     component.addTemplate();
 
@@ -108,7 +108,7 @@ describe('EthernetHubsAddTemplateComponent', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as EthernetHubTemplate));
     spyOn(mockedToasterService, 'error');
     component.templateName = 'sample name';
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
 
     component.addTemplate();
 

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-add-template/ethernet-hubs-add-template.component.ts

@@ -3,11 +3,11 @@ import { FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms'
 import { ActivatedRoute, Router } from '@angular/router';
 import { v4 as uuid } from 'uuid';
 import { Compute } from '../../../../../models/compute';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetHubTemplate } from '../../../../../models/templates/ethernet-hub-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
 import { ComputeService } from '../../../../../services/compute.service';
-import { ServerService } from '../../../../../services/server.service';
+import { ControllerService } from '../../../../../services/controller.service';
 import { TemplateMocksService } from '../../../../../services/template-mocks.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 
@@ -17,14 +17,14 @@ import { ToasterService } from '../../../../../services/toaster.service';
   styleUrls: ['./ethernet-hubs-add-template.component.scss', '../../../preferences.component.scss'],
 })
 export class EthernetHubsAddTemplateComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   templateName: string = '';
   formGroup: FormGroup;
   isLocalComputerChosen: boolean = true;
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private builtInTemplatesService: BuiltInTemplatesService,
     private router: Router,
     private toasterService: ToasterService,
@@ -39,20 +39,20 @@ export class EthernetHubsAddTemplateComponent implements OnInit {
   }
 
   ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
     });
   }
 
-  setServerType(serverType: string) {
-    if (serverType === 'local') {
+  setControllerType(controllerType: string) {
+    if (controllerType === 'local') {
       this.isLocalComputerChosen = true;
     }
   }
 
   goBack() {
-    this.router.navigate(['/server', this.server.id, 'preferences', 'builtin', 'ethernet-hubs']);
+    this.router.navigate(['/controller', this.controller.id, 'preferences', 'builtin', 'ethernet-hubs']);
   }
 
   addTemplate() {
@@ -74,7 +74,7 @@ export class EthernetHubsAddTemplateComponent implements OnInit {
         });
       }
 
-      this.builtInTemplatesService.addTemplate(this.server, ethernetHubTemplate).subscribe(() => {
+      this.builtInTemplatesService.addTemplate(this.controller, ethernetHubTemplate).subscribe(() => {
         this.goBack();
       });
     } else {

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-template-details/ethernet-hubs-template-details.component.html

@@ -65,7 +65,7 @@
 </div>
 <app-symbols-menu
   *ngIf="isSymbolSelectionOpened && ethernetHubTemplate"
-  [server]="server"
+  [controller]="controller"
   [symbol]="ethernetHubTemplate.symbol"
   (symbolChangedEmitter)="symbolChanged($event)"
 ></app-symbols-menu>

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-template-details/ethernet-hubs-template-details.component.spec.ts

@@ -11,23 +11,23 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetHubTemplate } from '../../../../../models/templates/ethernet-hub-template';
 import { BuiltInTemplatesConfigurationService } from '../../../../../services/built-in-templates-configuration.service';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { ToasterService } from '../../../../../services/toaster.service';
 import { MockedToasterService } from '../../../../../services/toaster.service.spec';
 import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { EthernetHubsTemplateDetailsComponent } from './ethernet-hubs-template-details.component';
 
 export class MockedBuiltInTemplatesService {
-  public getTemplate(server: Server, template_id: string) {
+  public getTemplate(controller:Controller , template_id: string) {
     return of({ ports_mapping: [] } as EthernetHubTemplate);
   }
 
-  public saveTemplate(server: Server, cloudTemplate: EthernetHubTemplate) {
+  public saveTemplate(controller:Controller , cloudTemplate: EthernetHubTemplate) {
     return of(cloudTemplate);
   }
 }
@@ -36,7 +36,7 @@ describe('EthernetHubsTemplateDetailsComponent', () => {
   let component: EthernetHubsTemplateDetailsComponent;
   let fixture: ComponentFixture<EthernetHubsTemplateDetailsComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let mockedToasterService = new MockedToasterService();
   let activatedRoute = new MockedActivatedRoute().get();
@@ -60,7 +60,7 @@ describe('EthernetHubsTemplateDetailsComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
         { provide: ToasterService, useValue: mockedToasterService },
         { provide: BuiltInTemplatesConfigurationService, useClass: BuiltInTemplatesConfigurationService },

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-template-details/ethernet-hubs-template-details.component.ts

@@ -1,11 +1,11 @@
 import { Component, OnInit } from '@angular/core';
 import { FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms';
 import { ActivatedRoute, Router } from '@angular/router';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetHubTemplate } from '../../../../../models/templates/ethernet-hub-template';
 import { BuiltInTemplatesConfigurationService } from '../../../../../services/built-in-templates-configuration.service';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
+import { ControllerService } from '../../../../../services/controller.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 
 @Component({
@@ -14,7 +14,7 @@ import { ToasterService } from '../../../../../services/toaster.service';
   styleUrls: ['./ethernet-hubs-template-details.component.scss', '../../../preferences.component.scss'],
 })
 export class EthernetHubsTemplateDetailsComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   ethernetHubTemplate: EthernetHubTemplate;
   numberOfPorts: number;
   inputForm: FormGroup;
@@ -24,7 +24,7 @@ export class EthernetHubsTemplateDetailsComponent implements OnInit {
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private builtInTemplatesService: BuiltInTemplatesService,
     private toasterService: ToasterService,
     private formBuilder: FormBuilder,
@@ -39,14 +39,14 @@ export class EthernetHubsTemplateDetailsComponent implements OnInit {
   }
 
   ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
     const template_id = this.route.snapshot.paramMap.get('template_id');
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
 
       this.categories = this.builtInTemplatesConfigurationService.getCategoriesForEthernetHubs();
       this.builtInTemplatesService
-        .getTemplate(this.server, template_id)
+        .getTemplate(this.controller, template_id)
         .subscribe((ethernetHubTemplate: EthernetHubTemplate) => {
           this.ethernetHubTemplate = ethernetHubTemplate;
           this.numberOfPorts = this.ethernetHubTemplate.ports_mapping.length;
@@ -55,7 +55,7 @@ export class EthernetHubsTemplateDetailsComponent implements OnInit {
   }
 
   goBack() {
-    this.router.navigate(['/server', this.server.id, 'preferences', 'builtin', 'ethernet-hubs']);
+    this.router.navigate(['/controller', this.controller.id, 'preferences', 'builtin', 'ethernet-hubs']);
   }
 
   onSave() {
@@ -71,7 +71,7 @@ export class EthernetHubsTemplateDetailsComponent implements OnInit {
       }
 
       this.builtInTemplatesService
-        .saveTemplate(this.server, this.ethernetHubTemplate)
+        .saveTemplate(this.controller, this.ethernetHubTemplate)
         .subscribe((ethernetHubTemplate: EthernetHubTemplate) => {
           this.toasterService.success('Changes saved');
         });

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-templates/ethernet-hubs-templates.component.html

@@ -3,18 +3,18 @@
     <div class="row">
       <h1 class="col">Ethernet hubs templates</h1>
       <button
-        *ngIf="server"
+        *ngIf="controller"
         class="top-button"
         class="cancel-button"
-        routerLink="/server/{{ server.id }}/preferences/builtin"
+        routerLink="/controller/{{ controller.id }}/preferences/builtin"
         mat-button
       >
         Back
       </button>
       <button
-        *ngIf="server"
+        *ngIf="controller"
         class="top-button"
-        routerLink="/server/{{ server.id }}/preferences/builtin/ethernet-hubs/addtemplate"
+        routerLink="/controller/{{ controller.id }}/preferences/builtin/ethernet-hubs/addtemplate"
         mat-raised-button
         color="primary"
       >
@@ -25,7 +25,7 @@
   <app-empty-templates-list *ngIf="!ethernetHubsTemplates.length"></app-empty-templates-list>
   <div class="default-content" *ngIf="ethernetHubsTemplates.length">
     <div class="listcontainer mat-elevation-z8">
-      <mat-nav-list *ngIf="server">
+      <mat-nav-list *ngIf="controller">
         <div class="list-item" *ngFor="let template of ethernetHubsTemplates">
           <mat-list-item class="template-name" routerLink="{{ template.template_id }}">{{
             template.name
@@ -43,4 +43,4 @@
     </div>
   </div>
 </div>
-<app-delete-template #deleteComponent [server]="server" (deleteEvent)="onDeleteEvent()"> </app-delete-template>
+<app-delete-template #deleteComponent [controller]="controller" (deleteEvent)="onDeleteEvent()"> </app-delete-template>

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-templates/ethernet-hubs-templates.component.spec.ts

@@ -9,16 +9,16 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetHubTemplate } from '../../../../../models/templates/ethernet-hub-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { EthernetHubsTemplatesComponent } from './ethernet-hubs-templates.component';
 
 export class MockedBuiltInTemplatesService {
-  public getTemplates(server: Server) {
+  public getTemplates(controller:Controller ) {
     return of([{} as EthernetHubTemplate]);
   }
 }
@@ -27,7 +27,7 @@ describe('EthernetHubsTemplatesComponent', () => {
   let component: EthernetHubsTemplatesComponent;
   let fixture: ComponentFixture<EthernetHubsTemplatesComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let activatedRoute = new MockedActivatedRoute().get();
 
@@ -47,7 +47,7 @@ describe('EthernetHubsTemplatesComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
       ],
       declarations: [EthernetHubsTemplatesComponent],

src/app/components/preferences/built-in/ethernet-hubs/ethernet-hubs-templates/ethernet-hubs-templates.component.ts

@@ -1,9 +1,9 @@
 import { Component, OnInit, ViewChild } from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetHubTemplate } from '../../../../../models/templates/ethernet-hub-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
+import { ControllerService } from '../../../../../services/controller.service';
 import { DeleteTemplateComponent } from '../../../common/delete-template-component/delete-template.component';
 
 @Component({
@@ -12,26 +12,26 @@ import { DeleteTemplateComponent } from '../../../common/delete-template-compone
   styleUrls: ['./ethernet-hubs-templates.component.scss', '../../../preferences.component.scss'],
 })
 export class EthernetHubsTemplatesComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   ethernetHubsTemplates: EthernetHubTemplate[] = [];
   @ViewChild(DeleteTemplateComponent) deleteComponent: DeleteTemplateComponent;
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private builtInTemplatesService: BuiltInTemplatesService
   ) {}
 
   ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
       this.getTemplates();
     });
   }
 
   getTemplates() {
-    this.builtInTemplatesService.getTemplates(this.server).subscribe((ethernetHubsTemplates: EthernetHubTemplate[]) => {
+    this.builtInTemplatesService.getTemplates(this.controller).subscribe((ethernetHubsTemplates: EthernetHubTemplate[]) => {
       this.ethernetHubsTemplates = ethernetHubsTemplates.filter(
         (elem) => elem.template_type === 'ethernet_hub' && !elem.builtin
       );

src/app/components/preferences/built-in/ethernet-switches/ethernet-switches-add-template/ethernet-switches-add-template.component.html

@@ -7,7 +7,7 @@
   <div class="default-content">
     <mat-card class="matCard">
       <mat-radio-group class="radio-group">
-        <mat-radio-button class="radio-button" value="1" (click)="setServerType('local')" checked
+        <mat-radio-button class="radio-button" value="1" (click)="setControllerType('local')" checked
           >Run the Ethernet switch locally</mat-radio-button
         >
       </mat-radio-group>

src/app/components/preferences/built-in/ethernet-switches/ethernet-switches-add-template/ethernet-switches-add-template.component.spec.ts

@@ -10,12 +10,12 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetSwitchTemplate } from '../../../../../models/templates/ethernet-switch-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
 import { ComputeService } from '../../../../../services/compute.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { TemplateMocksService } from '../../../../../services/template-mocks.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 import { MockedToasterService } from '../../../../../services/toaster.service.spec';
@@ -24,7 +24,7 @@ import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { EthernetSwitchesAddTemplateComponent } from './ethernet-switches-add-template.component';
 
 export class MockedBuiltInTemplatesService {
-  public addTemplate(server: Server, ethernetHubTemplate: EthernetSwitchTemplate) {
+  public addTemplate(controller:Controller , ethernetHubTemplate: EthernetSwitchTemplate) {
     return of(ethernetHubTemplate);
   }
 }
@@ -33,7 +33,7 @@ describe('EthernetSwitchesAddTemplateComponent', () => {
   let component: EthernetSwitchesAddTemplateComponent;
   let fixture: ComponentFixture<EthernetSwitchesAddTemplateComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let mockedToasterService = new MockedToasterService();
   let mockedComputeService = new MockedComputeService();
@@ -51,7 +51,7 @@ describe('EthernetSwitchesAddTemplateComponent', () => {
         CommonModule,
         NoopAnimationsModule,
         RouterTestingModule.withRoutes([
-          { path: 'server/1/preferences/builtin/ethernet-switches', component: EthernetSwitchesAddTemplateComponent },
+          { path: 'controller/1/preferences/builtin/ethernet-switches', component: EthernetSwitchesAddTemplateComponent },
         ]),
       ],
       providers: [
@@ -59,7 +59,7 @@ describe('EthernetSwitchesAddTemplateComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
         { provide: ToasterService, useValue: mockedToasterService },
         { provide: ComputeService, useValue: mockedComputeService },
@@ -83,7 +83,7 @@ describe('EthernetSwitchesAddTemplateComponent', () => {
   it('should call add template', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as EthernetSwitchTemplate));
     component.templateName = 'sample name';
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
     component.formGroup.controls['templateName'].setValue('template name');
     component.formGroup.controls['numberOfPorts'].setValue('1');
 
@@ -96,7 +96,7 @@ describe('EthernetSwitchesAddTemplateComponent', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as EthernetSwitchTemplate));
     spyOn(mockedToasterService, 'error');
     component.formGroup.controls['numberOfPorts'].setValue('1');
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
 
     component.addTemplate();
 
@@ -108,7 +108,7 @@ describe('EthernetSwitchesAddTemplateComponent', () => {
     spyOn(mockedBuiltInTemplatesService, 'addTemplate').and.returnValue(of({} as EthernetSwitchTemplate));
     spyOn(mockedToasterService, 'error');
     component.formGroup.controls['templateName'].setValue('template name');
-    component.server = { id: 1 } as Server;
+    component.controller = { id: 1 } as Controller ;
 
     component.addTemplate();
 

src/app/components/preferences/built-in/ethernet-switches/ethernet-switches-add-template/ethernet-switches-add-template.component.ts

@@ -3,11 +3,11 @@ import { FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms'
 import { ActivatedRoute, Router } from '@angular/router';
 import { v4 as uuid } from 'uuid';
 import { Compute } from '../../../../../models/compute';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetSwitchTemplate } from '../../../../../models/templates/ethernet-switch-template';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
 import { ComputeService } from '../../../../../services/compute.service';
-import { ServerService } from '../../../../../services/server.service';
+import { ControllerService } from '../../../../../services/controller.service';
 import { TemplateMocksService } from '../../../../../services/template-mocks.service';
 import { ToasterService } from '../../../../../services/toaster.service';
 
@@ -17,14 +17,14 @@ import { ToasterService } from '../../../../../services/toaster.service';
   styleUrls: ['./ethernet-switches-add-template.component.scss', '../../../preferences.component.scss'],
 })
 export class EthernetSwitchesAddTemplateComponent implements OnInit {
-  server: Server;
+  controller:Controller ;
   templateName: string = '';
   formGroup: FormGroup;
   isLocalComputerChosen: boolean = true;
 
   constructor(
     private route: ActivatedRoute,
-    private serverService: ServerService,
+    private controllerService: ControllerService,
     private builtInTemplatesService: BuiltInTemplatesService,
     private router: Router,
     private toasterService: ToasterService,
@@ -39,18 +39,18 @@ export class EthernetSwitchesAddTemplateComponent implements OnInit {
   }
 
   ngOnInit() {
-    const server_id = this.route.snapshot.paramMap.get('server_id');
-    this.serverService.get(parseInt(server_id, 10)).then((server: Server) => {
-      this.server = server;
+    const controller_id = this.route.snapshot.paramMap.get('controller_id');
+    this.controllerService.get(parseInt(controller_id, 10)).then((controller:Controller ) => {
+      this.controller = controller;
     });
   }
 
   goBack() {
-    this.router.navigate(['/server', this.server.id, 'preferences', 'builtin', 'ethernet-switches']);
+    this.router.navigate(['/controller', this.controller.id, 'preferences', 'builtin', 'ethernet-switches']);
   }
 
-  setServerType(serverType: string) {
-    if (serverType === 'local') {
+  setControllerType(controllerType: string) {
+    if (controllerType === 'local') {
       this.isLocalComputerChosen = true;
     }
   }
@@ -78,7 +78,7 @@ export class EthernetSwitchesAddTemplateComponent implements OnInit {
       }
 
       this.builtInTemplatesService
-        .addTemplate(this.server, ethernetSwitchTemplate)
+        .addTemplate(this.controller, ethernetSwitchTemplate)
         .subscribe((ethernetSwitchTemplate) => {
           this.goBack();
         });

src/app/components/preferences/built-in/ethernet-switches/ethernet-switches-template-details/ethernet-switches-template-details.component.html

@@ -78,7 +78,7 @@
 </div>
 <app-symbols-menu
   *ngIf="isSymbolSelectionOpened && ethernetSwitchTemplate"
-  [server]="server"
+  [controller]="controller"
   [symbol]="ethernetSwitchTemplate.symbol"
   (symbolChangedEmitter)="symbolChanged($event)"
 ></app-symbols-menu>

src/app/components/preferences/built-in/ethernet-switches/ethernet-switches-template-details/ethernet-switches-template-details.component.spec.ts

@@ -11,12 +11,12 @@ import { NoopAnimationsModule } from '@angular/platform-browser/animations';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { of } from 'rxjs';
-import { Server } from '../../../../../models/server';
+import{ Controller } from '../../../../../models/controller';
 import { EthernetSwitchTemplate } from '../../../../../models/templates/ethernet-switch-template';
 import { BuiltInTemplatesConfigurationService } from '../../../../../services/built-in-templates-configuration.service';
 import { BuiltInTemplatesService } from '../../../../../services/built-in-templates.service';
-import { ServerService } from '../../../../../services/server.service';
-import { MockedServerService } from '../../../../../services/server.service.spec';
+import { ControllerService } from '../../../../../services/controller.service';
+import { MockedControllerService } from '../../../../../services/controller.service.spec';
 import { ToasterService } from '../../../../../services/toaster.service';
 import { MockedToasterService } from '../../../../../services/toaster.service.spec';
 import { PortsComponent } from '../../../common/ports/ports.component';
@@ -24,11 +24,11 @@ import { MockedActivatedRoute } from '../../../preferences.component.spec';
 import { EthernetSwitchesTemplateDetailsComponent } from './ethernet-switches-template-details.component';
 
 export class MockedBuiltInTemplatesService {
-  public getTemplate(server: Server, template_id: string) {
+  public getTemplate(controller:Controller , template_id: string) {
     return of({ ports_mapping: [] } as EthernetSwitchTemplate);
   }
 
-  public saveTemplate(server: Server, cloudTemplate: EthernetSwitchTemplate) {
+  public saveTemplate(controller:Controller , cloudTemplate: EthernetSwitchTemplate) {
     return of(cloudTemplate);
   }
 }
@@ -37,7 +37,7 @@ describe('EthernetSwitchesTemplateDetailsComponent', () => {
   let component: EthernetSwitchesTemplateDetailsComponent;
   let fixture: ComponentFixture<EthernetSwitchesTemplateDetailsComponent>;
 
-  let mockedServerService = new MockedServerService();
+  let mockedControllerService = new MockedControllerService();
   let mockedBuiltInTemplatesService = new MockedBuiltInTemplatesService();
   let mockedToasterService = new MockedToasterService();
   let activatedRoute = new MockedActivatedRoute().get();
@@ -61,7 +61,7 @@ describe('EthernetSwitchesTemplateDetailsComponent', () => {
           provide: ActivatedRoute,
           useValue: activatedRoute,
         },
-        { provide: ServerService, useValue: mockedServerService },
+        { provide: ControllerService, useValue: mockedControllerService },
         { provide: BuiltInTemplatesService, useValue: mockedBuiltInTemplatesService },
         { provide: ToasterService, useValue: mockedToasterService },
         { provide: BuiltInTemplatesConfigurationService, useClass: BuiltInTemplatesConfigurationService },