--- /dev/null
+/**
+* @license
+* Copyright (C) 2018 "IoT.bzh"
+* Author Sebastien Douheret <sebastien@iot.bzh>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import { Injectable, SecurityContext, isDevMode } from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+import { Subject } from 'rxjs/Subject';
+import { BehaviorSubject } from 'rxjs/BehaviorSubject';
+
+import { XDSAgentService, IXDSTargetConfig, IXDSTargetTerminal } from '../services/xdsagent.service';
+
+/* FIXME: syntax only compatible with TS>2.4.0
+export enum TargetTypeEnum {
+ UNSET = '',
+ STANDARD: 'standard',
+}
+*/
+export type TargetTypeEnum = '' | 'standard';
+export const TargetType = {
+ UNSET: <TargetTypeEnum>'',
+ STANDARD: <TargetTypeEnum>'standard',
+};
+
+export const TargetTypes = [
+ { value: TargetType.STANDARD, display: 'Standard' },
+];
+
+export const TargetStatus = {
+ ErrorConfig: 'ErrorConfig',
+ Disable: 'Disable',
+ Enable: 'Enable',
+};
+
+export type TerminalTypeEnum = '' | 'ssh';
+export const TerminalType = {
+ UNSET: <TerminalTypeEnum>'',
+ SSH: <TerminalTypeEnum>'ssh',
+};
+
+export interface ITarget extends IXDSTargetConfig {
+ isUsable?: boolean;
+}
+
+export interface ITerminal extends IXDSTargetTerminal {
+ targetID?: string;
+}
+
+export interface ITerminalOutput {
+ termID: string;
+ timestamp: string;
+ stdout: string;
+ stderr: string;
+}
+
+export interface ITerminalExit {
+ termID: string;
+ timestamp: string;
+ code: number;
+ error: string;
+}
+
+@Injectable()
+export class TargetService {
+ public targets$: Observable<ITarget[]>;
+ public curTarget$: Observable<ITarget>;
+ public terminalOutput$ = <Subject<ITerminalOutput>>new Subject();
+ public terminalExit$ = <Subject<ITerminalExit>>new Subject();
+
+ private _tgtsList: ITarget[] = [];
+ private tgtsSubject = <BehaviorSubject<ITarget[]>>new BehaviorSubject(this._tgtsList);
+ private _current: ITarget;
+ private curTgtSubject = <BehaviorSubject<ITarget>>new BehaviorSubject(this._current);
+ private curServerID;
+ private termSocket: SocketIOClient.Socket;
+
+ constructor(private xdsSvr: XDSAgentService) {
+ this._current = null;
+ this.targets$ = this.tgtsSubject.asObservable();
+ this.curTarget$ = this.curTgtSubject.asObservable();
+
+ this.xdsSvr.XdsConfig$.subscribe(cfg => {
+ if (!cfg || cfg.servers.length < 1) {
+ return;
+ }
+
+ // FIXME support multiple server
+ this.curServerID = cfg.servers[0].id;
+
+ // Load initial targets list
+ this.xdsSvr.getTargets(this.curServerID).subscribe((targets) => {
+ this._tgtsList = [];
+ targets.forEach(p => {
+ this._addTarget(p, true);
+ });
+
+ // TODO: get previous val from xds-config service / cookie
+ if (this._tgtsList.length > 0) {
+ this._current = this._tgtsList[0];
+ this.curTgtSubject.next(this._current);
+ }
+
+ this.tgtsSubject.next(this._tgtsList);
+ });
+ });
+
+ // Add listener on targets creation, deletion and change events
+ this.xdsSvr.onTargetAdd().subscribe(tgt => this._addTarget(tgt));
+ this.xdsSvr.onTargetDelete().subscribe(tgt => this._delTarget(tgt));
+ this.xdsSvr.onTargetChange().subscribe(tgt => this._updateTarget(tgt));
+
+ // Register events to forward terminal Output and Exit
+ this.xdsSvr.onSocketConnect().subscribe(socket => {
+ this.termSocket = socket;
+
+ // Handle terminal output
+ socket.on('term:output', data => {
+ const termOut = <ITerminalOutput>{
+ termID: data.termID,
+ timestamp: data.timestamp,
+ stdout: atob(data.stdout),
+ stderr: atob(data.stderr),
+ };
+ this.terminalOutput$.next(termOut);
+ });
+
+ // Handle terminal exit event
+ socket.on('term:exit', data => {
+ this.terminalExit$.next(Object.assign({}, <ITerminalExit>data));
+ });
+
+ });
+ }
+
+ setCurrent(p: ITarget): ITarget | undefined {
+ if (!p) {
+ this._current = null;
+ return undefined;
+ }
+ return this.setCurrentById(p.id);
+ }
+
+ setCurrentById(id: string): ITarget | undefined {
+ const p = this._tgtsList.find(item => item.id === id);
+ if (p) {
+ this._current = p;
+ this.curTgtSubject.next(this._current);
+ }
+ return this._current;
+ }
+
+ getCurrent(): ITarget {
+ return this._current;
+ }
+
+ getTargetById(id: string): ITarget | undefined {
+ const t = this._tgtsList.find(item => item.id === id);
+ return t;
+ }
+
+ add(tgt: ITarget): Observable<ITarget> {
+ return this.xdsSvr.addTarget(this.curServerID, tgt);
+ }
+
+ delete(tgt: ITarget): Observable<ITarget> {
+ const idx = this._getTargetIdx(tgt.id);
+ const delTgt = tgt;
+ if (idx === -1) {
+ throw new Error('Invalid target id (id=' + tgt.id + ')');
+ }
+ return this.xdsSvr.deleteTarget(this.curServerID, tgt.id)
+ .map(res => delTgt);
+ }
+
+ setSettings(tgt: ITarget): Observable<ITarget> {
+ return this.xdsSvr.updateTarget(this.curServerID, tgt);
+ }
+
+ terminalOpen(tgtID: string, termID: string, cfg?: IXDSTargetTerminal): Observable<IXDSTargetTerminal> {
+ if (termID === '' || termID === undefined) {
+ // create a new terminal when no termID is set
+ if (cfg === undefined) {
+ cfg = <IXDSTargetTerminal>{
+ name: 'ssh to ' + this.getTargetById(tgtID).name,
+ type: TerminalType.SSH,
+ };
+ }
+ return this.xdsSvr.createTerminalTarget(this.curServerID, tgtID, cfg)
+ .flatMap(res => {
+ return this.xdsSvr.openTerminalTarget(this.curServerID, tgtID, res.id);
+ });
+ } else {
+ return this.xdsSvr.openTerminalTarget(this.curServerID, tgtID, termID);
+ }
+ }
+
+ terminalClose(tgtID, termID: string): Observable<IXDSTargetTerminal> {
+ return this.xdsSvr.closeTerminalTarget(this.curServerID, tgtID, termID);
+ }
+
+ terminalWrite(data: string) {
+ if (this.termSocket) {
+ this.termSocket.emit('term:input', btoa(data));
+ }
+ }
+
+ terminalResize(tgtID, termID: string, cols, rows: number): Observable<IXDSTargetTerminal> {
+ return this.xdsSvr.resizeTerminalTarget(this.curServerID, tgtID, termID, cols, rows);
+ }
+
+ /*** Private functions ***/
+
+ private _isUsableTarget(p) {
+ return p && (p.status === TargetStatus.Enable);
+ }
+
+ private _getTargetIdx(id: string): number {
+ return this._tgtsList.findIndex((item) => item.id === id);
+ }
+
+ private _addTarget(tgt: ITarget, noNext?: boolean): ITarget {
+
+ tgt.isUsable = this._isUsableTarget(tgt);
+
+ // add new target
+ this._tgtsList.push(tgt);
+
+ // sort target array
+ this._tgtsList.sort((a, b) => {
+ if (a.name < b.name) {
+ return -1;
+ }
+ if (a.name > b.name) {
+ return 1;
+ }
+ return 0;
+ });
+
+ if (!noNext) {
+ this.tgtsSubject.next(this._tgtsList);
+ }
+
+ return tgt;
+ }
+
+ private _delTarget(tgt: ITarget) {
+ const idx = this._tgtsList.findIndex(item => item.id === tgt.id);
+ if (idx === -1) {
+ if (isDevMode) {
+ /* tslint:disable:no-console */
+ console.log('Warning: Try to delete target unknown id: tgt=', tgt);
+ }
+ return;
+ }
+ const delId = this._tgtsList[idx].id;
+ this._tgtsList.splice(idx, 1);
+ if (delId === this._current.id) {
+ this.setCurrent(this._tgtsList[0]);
+ }
+ this.tgtsSubject.next(this._tgtsList);
+ }
+
+ private _updateTarget(tgt: ITarget) {
+ const i = this._getTargetIdx(tgt.id);
+ if (i >= 0) {
+ this._tgtsList[i].status = tgt.status;
+ this._tgtsList[i].isUsable = this._isUsableTarget(tgt);
+ this.tgtsSubject.next(this._tgtsList);
+ }
+ }
+
+}
Code Review / src / xds / xds-agent.git / blobdiff