occaecatidicta/packages/omelox-admin/lib/client/client.ts

/*!
 * Omelox -- commandLine Client
 * Copyright(c) 2015 fantasyni <fantasyni@163.com>
 * MIT Licensed
 */

 import { EventEmitter } from 'events';



import {MqttClient} from '../protocol/mqtt/mqttClient';
import * as protocol from '../util/protocol';
// let io = require('socket.io-client');
import * as utils from '../util/utils';
import { Callback } from '../util/constants';

export interface AdminClientOption {username?: string ; password?: string; md5?: boolean; }
export type RequestMsg =
{
    clientId?: string;
    username?: string;
} & any;
export type Listener = (...args: any[]) => void;

export class AdminClient {
    static ST_INITED = 1;
    static ST_CONNECTED = 2;
    static ST_REGISTERED = 3;
    static ST_CLOSED = 4;

    id = '';
    reqId = 1;
    callbacks: {[respId: string]: Callback} = {};
    _listeners: {[evt: string]: Listener[]} = {};
    state = AdminClient.ST_INITED;
    socket: MqttClient;
    username = '';
    password = '';
    md5 = false;
    constructor(opt: AdminClientOption) {
        this.id = '';
        this.reqId = 1;
        this.callbacks = {};
        this._listeners = {};
        this.state = AdminClient.ST_INITED;
        this.socket = null;
        opt = opt || {};
        this.username = opt['username'] || '';
        this.password = opt['password'] || '';
        this.md5 = opt['md5'] || false;
    }

    connect(id: string, host: string, port: number, cb: (msg?: any) => void) {
        this.id = id;
        let self = this;

        console.log('try to connect ' + host + ':' + port);
        this.socket = new MqttClient({
            id: id
        });

        this.socket.connect(host, port);

        // this.socket = io.connect('http://' + host + ':' + port, {
        //     'force new connection': true,
        //     'reconnect': false
        // });

        this.socket.on('connect',  () => {
            self.state = AdminClient.ST_CONNECTED;
            if (self.md5) {
                self.password = utils.md5(self.password);
            }
            self.doSend('register', {
                type: 'client',
                id: id,
                username: self.username,
                password: self.password,
                md5: self.md5
            });
        });

        this.socket.on('register',  (res) => {
            if (res.code !== protocol.PRO_OK) {
                cb(res.msg);
                return;
            }

            self.state = AdminClient.ST_REGISTERED;
            cb();
        });

        this.socket.on('client',  (msg) => {
            msg = protocol.parse(msg);
            if (msg.respId) {
                // response for request
                let cb = self.callbacks[msg.respId];
                delete self.callbacks[msg.respId];
                if (cb && typeof cb === 'function') {
                    cb(msg.error, msg.body);
                }
            } else if (msg.moduleId) {
                // notify
                self.emit(msg.moduleId, msg);
            }
        });

        this.socket.on('error', function (err) {
            if (self.state < AdminClient.ST_CONNECTED) {
                cb(err);
            }

            self.emit('error', err);
        });

        this.socket.on('disconnect',  (reason) => {
            this.state = AdminClient.ST_CLOSED;
            self.emit('close');
        });
    }

    request(moduleId: string, msg ?: RequestMsg, cb?: Callback) {
        let id = this.reqId++;
        // something dirty: attach current client id into msg
        msg = msg || {};
        msg.clientId = this.id;
        msg.username = this.username;
        let req = protocol.composeRequest(id, moduleId, msg);
        this.callbacks[id] = cb;
        this.doSend('client', req);
        // this.socket.emit('client', req);
    }

    notify(moduleId: string, msg: RequestMsg) {
        // something dirty: attach current client id into msg
        msg = msg || {};
        msg.clientId = this.id;
        msg.username = this.username;
        let req = protocol.composeRequest(null, moduleId, msg);
        this.doSend('client', req);
        // this.socket.emit('client', req);
    }

    command(command: string, moduleId: string, msg: RequestMsg, cb: Callback) {
        let id = this.reqId++;
        msg = msg || {};
        msg.clientId = this.id;
        msg.username = this.username;
        let commandReq = protocol.composeCommand(id, command, moduleId, msg);
        this.callbacks[id] = cb;
        this.doSend('client', commandReq);
        // this.socket.emit('client', commandReq);
    }

    doSend(topic: string, msg: any) {
        this.socket.send(topic, msg);
    }

    on(event: string, listener: Listener) {
        this._listeners[event] = this._listeners[event] || [];
        this._listeners[event].push(listener);
    }

    emit(event: string , ... args: any[]) {
        let _listeners = this._listeners[event];
        if (!_listeners || !_listeners.length) {
            return;
        }

        let listener: Listener;
        for (let i = 0, l = _listeners.length; i < l; i++) {
            listener = _listeners[i];
            if (typeof listener === 'function') {
                listener.apply(null, args);
            }
        }
    }
}