webapp/src/app/@core-xds/services/xdsagent.service.ts

   1 /**
   2 * @license
   3 * Copyright (C) 2017 "IoT.bzh"
   4 * Author Sebastien Douheret <sebastien@iot.bzh>
   5 *
   6 * Licensed under the Apache License, Version 2.0 (the "License");
   7 * you may not use this file except in compliance with the License.
   8 * You may obtain a copy of the License at
   9 *
  10 *   http://www.apache.org/licenses/LICENSE-2.0
  11 *
  12 * Unless required by applicable law or agreed to in writing, software
  13 * distributed under the License is distributed on an "AS IS" BASIS,
  14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 * See the License for the specific language governing permissions and
  16 * limitations under the License.
  17 */
  18
  19 import { Injectable, Inject, isDevMode } from '@angular/core';
  20 import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
  21 import { DOCUMENT } from '@angular/common';
  22 import { Observable } from 'rxjs/Observable';
  23 import { Subject } from 'rxjs/Subject';
  24 import { BehaviorSubject } from 'rxjs/BehaviorSubject';
  25 import * as io from 'socket.io-client';
  26
  27 import { AlertService } from './alert.service';
  28 import { ISdk } from './sdk.service';
  29 import { ProjectType, ProjectTypeEnum } from './project.service';
  30
  31 // Import RxJs required methods
  32 import 'rxjs/add/operator/map';
  33 import 'rxjs/add/operator/catch';
  34 import 'rxjs/add/observable/throw';
  35 import 'rxjs/add/operator/mergeMap';
  36 import 'rxjs/add/observable/of';
  37 import 'rxjs/add/operator/retryWhen';
  38
  39
  40 export interface IXDSConfigProject {
  41   id: string;
  42   path: string;
  43   clientSyncThingID: string;
  44   type: string;
  45   label?: string;
  46   defaultSdkID?: string;
  47 }
  48
  49 interface IXDSBuilderConfig {
  50   ip: string;
  51   port: string;
  52   syncThingID: string;
  53 }
  54
  55 export interface IXDSProjectConfig {
  56   id: string;
  57   serverId: string;
  58   label: string;
  59   clientPath: string;
  60   serverPath?: string;
  61   type: ProjectTypeEnum;
  62   status?: string;
  63   isInSync?: boolean;
  64   defaultSdkID: string;
  65   clientData?: string;
  66 }
  67
  68 export interface IXDSVer {
  69   id: string;
  70   version: string;
  71   apiVersion: string;
  72   gitTag: string;
  73 }
  74
  75 export interface IXDSVersions {
  76   client: IXDSVer;
  77   servers: IXDSVer[];
  78 }
  79
  80 export interface IXDServerCfg {
  81   id: string;
  82   url: string;
  83   apiUrl?: string;
  84   partialUrl?: string;
  85   connRetry: number;
  86   connected: boolean;
  87 }
  88
  89 export interface IXDSConfig {
  90   servers: IXDServerCfg[];
  91 }
  92
  93 export interface ISdkMessage {
  94   wsID: string;
  95   msgType: string;
  96   data: any;
  97 }
  98
  99 export interface ICmdOutput {
 100   cmdID: string;
 101   timestamp: string;
 102   stdout: string;
 103   stderr: string;
 104 }
 105
 106 export interface ICmdExit {
 107   cmdID: string;
 108   timestamp: string;
 109   code: number;
 110   error: string;
 111 }
 112
 113 export interface IServerStatus {
 114   id: string;
 115   connected: boolean;
 116 }
 117
 118 export interface IAgentStatus {
 119   connected: boolean;
 120   servers: IServerStatus[];
 121 }
 122
 123
 124 @Injectable()
 125 export class XDSAgentService {
 126
 127   public XdsConfig$: Observable<IXDSConfig>;
 128   public Status$: Observable<IAgentStatus>;
 129   public CmdOutput$ = <Subject<ICmdOutput>>new Subject();
 130   public CmdExit$ = <Subject<ICmdExit>>new Subject();
 131
 132   protected projectAdd$ = new Subject<IXDSProjectConfig>();
 133   protected projectDel$ = new Subject<IXDSProjectConfig>();
 134   protected projectChange$ = new Subject<IXDSProjectConfig>();
 135
 136   private baseUrl: string;
 137   private wsUrl: string;
 138   private httpSessionID: string;
 139   private _config = <IXDSConfig>{ servers: [] };
 140   private _status = { connected: false, servers: [] };
 141
 142   private configSubject = <BehaviorSubject<IXDSConfig>>new BehaviorSubject(this._config);
 143   private statusSubject = <BehaviorSubject<IAgentStatus>>new BehaviorSubject(this._status);
 144
 145   private socket: SocketIOClient.Socket;
 146
 147   constructor( @Inject(DOCUMENT) private document: Document,
 148     private http: HttpClient, private alert: AlertService) {
 149
 150     this.XdsConfig$ = this.configSubject.asObservable();
 151     this.Status$ = this.statusSubject.asObservable();
 152
 153     const originUrl = this.document.location.origin;
 154     this.baseUrl = originUrl + '/api/v1';
 155
 156     // Retrieve Session ID / token
 157     this.http.get(this.baseUrl + '/version', { observe: 'response' })
 158       .subscribe(
 159       resp => {
 160         this.httpSessionID = resp.headers.get('xds-agent-sid');
 161
 162         const re = originUrl.match(/http[s]?:\/\/([^\/]*)[\/]?/);
 163         if (re === null || re.length < 2) {
 164           console.error('ERROR: cannot determine Websocket url');
 165         } else {
 166           this.wsUrl = 'ws://' + re[1];
 167           this._handleIoSocket();
 168           this._RegisterEvents();
 169         }
 170       },
 171       err => {
 172         /* tslint:disable:no-console */
 173         console.error('ERROR while retrieving session id:', err);
 174       });
 175   }
 176
 177   private _NotifyXdsAgentState(sts: boolean) {
 178     this._status.connected = sts;
 179     this.statusSubject.next(Object.assign({}, this._status));
 180
 181     // Update XDS config including XDS Server list when connected
 182     if (sts) {
 183       this.getConfig().subscribe(c => {
 184         this._config = c;
 185         this._NotifyXdsServerState();
 186         this.configSubject.next(Object.assign({ servers: [] }, this._config));
 187       });
 188     }
 189   }
 190
 191   private _NotifyXdsServerState() {
 192     this._status.servers = this._config.servers.map(svr => {
 193       return { id: svr.id, connected: svr.connected };
 194     });
 195     this.statusSubject.next(Object.assign({}, this._status));
 196   }
 197
 198   private _handleIoSocket() {
 199     this.socket = io(this.wsUrl, { transports: ['websocket'] });
 200
 201     this.socket.on('connect_error', (res) => {
 202       this._NotifyXdsAgentState(false);
 203       console.error('XDS Agent WebSocket Connection error !');
 204     });
 205
 206     this.socket.on('connect', (res) => {
 207       this._NotifyXdsAgentState(true);
 208     });
 209
 210     this.socket.on('disconnection', (res) => {
 211       this._NotifyXdsAgentState(false);
 212       this.alert.error('WS disconnection: ' + res);
 213     });
 214
 215     this.socket.on('error', (err) => {
 216       console.error('WS error:', err);
 217     });
 218
 219     // XDS Events decoding
 220
 221     this.socket.on('make:output', data => {
 222       this.CmdOutput$.next(Object.assign({}, <ICmdOutput>data));
 223     });
 224
 225     this.socket.on('make:exit', data => {
 226       this.CmdExit$.next(Object.assign({}, <ICmdExit>data));
 227     });
 228
 229     this.socket.on('exec:output', data => {
 230       this.CmdOutput$.next(Object.assign({}, <ICmdOutput>data));
 231     });
 232
 233     this.socket.on('exec:exit', data => {
 234       this.CmdExit$.next(Object.assign({}, <ICmdExit>data));
 235     });
 236
 237     this.socket.on('event:server-config', ev => {
 238       if (ev && ev.data) {
 239         const cfg: IXDServerCfg = ev.data;
 240         const idx = this._config.servers.findIndex(el => el.id === cfg.id);
 241         if (idx >= 0) {
 242           this._config.servers[idx] = Object.assign({}, cfg);
 243           this._NotifyXdsServerState();
 244         }
 245         this.configSubject.next(Object.assign({}, this._config));
 246       }
 247     });
 248
 249     this.socket.on('event:project-add', (ev) => {
 250       if (ev && ev.data && ev.data.id) {
 251         this.projectAdd$.next(Object.assign({}, ev.data));
 252         if (ev.sessionID !== this.httpSessionID && ev.data.label) {
 253           this.alert.info('Project "' + ev.data.label + '" has been added by another tool.');
 254         }
 255       } else if (isDevMode) {
 256         /* tslint:disable:no-console */
 257         console.log('Warning: received event:project-add with unknown data: ev=', ev);
 258       }
 259     });
 260
 261     this.socket.on('event:project-delete', (ev) => {
 262       if (ev && ev.data && ev.data.id) {
 263         this.projectDel$.next(Object.assign({}, ev.data));
 264         if (ev.sessionID !== this.httpSessionID && ev.data.label) {
 265           this.alert.info('Project "' + ev.data.label + '" has been deleted by another tool.');
 266         }
 267       } else if (isDevMode) {
 268         console.log('Warning: received event:project-delete with unknown data: ev=', ev);
 269       }
 270     });
 271
 272     this.socket.on('event:project-state-change', ev => {
 273       if (ev && ev.data) {
 274         this.projectChange$.next(Object.assign({}, ev.data));
 275       } else if (isDevMode) {
 276         console.log('Warning: received event:project-state-change with unknown data: ev=', ev);
 277       }
 278     });
 279
 280   }
 281
 282   /**
 283   ** Events registration
 284   ***/
 285   onProjectAdd(): Observable<IXDSProjectConfig> {
 286     return this.projectAdd$.asObservable();
 287   }
 288
 289   onProjectDelete(): Observable<IXDSProjectConfig> {
 290     return this.projectDel$.asObservable();
 291   }
 292
 293   onProjectChange(): Observable<IXDSProjectConfig> {
 294     return this.projectChange$.asObservable();
 295   }
 296
 297   /**
 298   ** Misc / Version
 299   ***/
 300   getVersion(): Observable<IXDSVersions> {
 301     return this._get('/version');
 302   }
 303
 304   /***
 305   ** Config
 306   ***/
 307   getConfig(): Observable<IXDSConfig> {
 308     return this._get('/config');
 309   }
 310
 311   setConfig(cfg: IXDSConfig): Observable<IXDSConfig> {
 312     return this._post('/config', cfg);
 313   }
 314
 315   setServerRetry(serverID: string, retry: number): Observable<IXDSConfig> {
 316     const svr = this._getServer(serverID);
 317     if (!svr) {
 318       return Observable.throw('Unknown server ID');
 319     }
 320     if (retry < 0 || Number.isNaN(retry) || retry == null) {
 321       return Observable.throw('Not a valid number');
 322     }
 323     svr.connRetry = retry;
 324     return this._setConfig();
 325   }
 326
 327   setServerUrl(serverID: string, url: string, retry: number): Observable<IXDSConfig> {
 328     const svr = this._getServer(serverID);
 329     if (!svr) {
 330       return Observable.throw('Unknown server ID');
 331     }
 332     svr.connected = false;
 333     svr.url = url;
 334     if (!Number.isNaN(retry) && retry > 0) {
 335       svr.connRetry = retry;
 336     }
 337     this._NotifyXdsServerState();
 338     return this._setConfig();
 339   }
 340
 341   private _setConfig(): Observable<IXDSConfig> {
 342     return this.setConfig(this._config)
 343       .map(newCfg => {
 344         this._config = newCfg;
 345         this.configSubject.next(Object.assign({}, this._config));
 346         return this._config;
 347       });
 348   }
 349
 350   /***
 351   ** SDKs
 352   ***/
 353   getSdks(serverID: string): Observable<ISdk[]> {
 354     const svr = this._getServer(serverID);
 355     if (!svr || !svr.connected) {
 356       return Observable.of([]);
 357     }
 358
 359     return this._get(svr.partialUrl + '/sdks');
 360   }
 361
 362   /***
 363   ** Projects
 364   ***/
 365   getProjects(): Observable<IXDSProjectConfig[]> {
 366     return this._get('/projects');
 367   }
 368
 369   addProject(cfg: IXDSProjectConfig): Observable<IXDSProjectConfig> {
 370     return this._post('/projects', cfg);
 371   }
 372
 373   deleteProject(id: string): Observable<IXDSProjectConfig> {
 374     return this._delete('/projects/' + id);
 375   }
 376
 377   updateProject(cfg: IXDSProjectConfig): Observable<IXDSProjectConfig> {
 378     return this._put('/projects/' + cfg.id, cfg);
 379   }
 380
 381   syncProject(id: string): Observable<string> {
 382     return this._post('/projects/sync/' + id, {});
 383   }
 384
 385   /***
 386   ** Exec
 387   ***/
 388   exec(prjID: string, dir: string, cmd: string, sdkid?: string, args?: string[], env?: string[]): Observable<any> {
 389     return this._post('/exec',
 390       {
 391         id: prjID,
 392         rpath: dir,
 393         cmd: cmd,
 394         sdkID: sdkid || '',
 395         args: args || [],
 396         env: env || [],
 397       });
 398   }
 399
 400   /**
 401   ** Private functions
 402   ***/
 403
 404   private _RegisterEvents() {
 405     // Register to all existing events
 406     this._post('/events/register', { 'name': 'event:all' })
 407       .subscribe(
 408       res => { },
 409       error => {
 410         this.alert.error('ERROR while registering to all events: ' + error);
 411       },
 412     );
 413   }
 414
 415   private _getServer(ID: string): IXDServerCfg {
 416     const svr = this._config.servers.filter(item => item.id === ID);
 417     if (svr.length < 1) {
 418       return null;
 419     }
 420     return svr[0];
 421   }
 422
 423   private _attachAuthHeaders(options?: any) {
 424     options = options || {};
 425     const headers = options.headers || new HttpHeaders();
 426     // headers.append('Authorization', 'Basic ' + btoa('username:password'));
 427     headers.append('Accept', 'application/json');
 428     headers.append('Content-Type', 'application/json');
 429     // headers.append('Access-Control-Allow-Origin', '*');
 430
 431     options.headers = headers;
 432     return options;
 433   }
 434
 435   private _get(url: string): Observable<any> {
 436     return this.http.get(this.baseUrl + url, this._attachAuthHeaders())
 437       .catch(this._decodeError);
 438   }
 439   private _post(url: string, body: any): Observable<any> {
 440     return this.http.post(this.baseUrl + url, JSON.stringify(body), this._attachAuthHeaders())
 441       .catch((error) => {
 442         return this._decodeError(error);
 443       });
 444   }
 445   private _put(url: string, body: any): Observable<any> {
 446     return this.http.put(this.baseUrl + url, JSON.stringify(body), this._attachAuthHeaders())
 447       .catch((error) => {
 448         return this._decodeError(error);
 449       });
 450   }
 451   private _delete(url: string): Observable<any> {
 452     return this.http.delete(this.baseUrl + url, this._attachAuthHeaders())
 453       .catch(this._decodeError);
 454   }
 455
 456   private _decodeError(err: any) {
 457     let e: string;
 458     if (err instanceof HttpErrorResponse) {
 459       e = (err.error && err.error.error) ? err.error.error : err.message || 'Unknown error';
 460     } else if (typeof err === 'object') {
 461       if (err.statusText) {
 462         e = err.statusText;
 463       } else if (err.error) {
 464         e = String(err.error);
 465       } else {
 466         e = JSON.stringify(err);
 467       }
 468     } else {
 469       e = err.message ? err.message : err.toString();
 470     }
 471     /* tslint:disable:no-console */
 472     if (isDevMode) {
 473       console.log('xdsagent.service - ERROR: ', e);
 474     }
 475     return Observable.throw(e);
 476   }
 477 }