pubo-node 1.0.157 → 1.0.159

package/es/child-process/index.js

@@ -1,157 +0,0 @@
-import { exec } from 'child_process';
-import { loop, waitFor } from 'pubo-utils';
-// 获取进程名称
-export function getProcessName(pid) {
-    return new Promise((resolve, reject) => {
-        exec(`grep "Name:" /proc/${pid}/status`, (err, data) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve(data);
-            }
-        });
-    });
-}
-// 获取进程 cpu 使用率
-export function getProcessCpuUseByPid(pid) {
-    return new Promise((resolve) => {
-        exec(`ps -p ${pid} -o %cpu=`, (err, stdout) => {
-            if (err) {
-                resolve(-1);
-            }
-            else {
-                resolve(parseFloat(stdout.toString()));
-            }
-        });
-    });
-}
-// 获取进程 command 使用率
-export function getProcessCommandByPid(pid) {
-    return new Promise((resolve) => {
-        exec(`ps -p ${pid} -o command=`, (err, stdout) => {
-            if (err) {
-                resolve('');
-            }
-            else {
-                resolve(stdout.toString().split('\n')[0]);
-            }
-        });
-    });
-}
-// 判断进程是否死亡
-export async function isProcessDied(pid) {
-    const used = await getProcessCpuUseByPid(pid);
-    return used < 0;
-}
-// 获取子进程
-export function getProcessByPpid(pid) {
-    return new Promise((resolve) => {
-        exec(`ps -o pid --no-headers --ppid ${pid}`, (err, stdout) => {
-            if (err) {
-                resolve([]);
-            }
-            else {
-                resolve(stdout
-                    .split('\n')
-                    .filter((item) => !!item)
-                    .map((item) => parseFloat(item.trim())));
-            }
-        });
-    });
-}
-// 获取进程树
-export const getProcessTree = async (pid, tree) => {
-    let isRoot = false;
-    if (!tree) {
-        isRoot = true;
-        tree = { pid, children: [] };
-    }
-    const pidList = await getProcessByPpid(pid);
-    for (const id of pidList) {
-        const item = { pid: id, children: [] };
-        await getProcessTree(id, item);
-        tree.children.push(item);
-    }
-    if (isRoot) {
-        return tree;
-    }
-    else {
-        tree = null;
-        return null;
-    }
-};
-// 杀死进程
-async function _SIGKILL(pid, signal = 2, times = 1) {
-    if (times > 5) {
-        throw new Error('SIGKILL 失败. times > 5');
-    }
-    exec(`kill -${signal} ${pid}`);
-    try {
-        await waitFor(async () => isProcessDied(pid), { checkTime: 100, timeout: 4000 });
-    }
-    catch (err) {
-        await _SIGKILL(pid, 9, times + 1);
-    }
-}
-// 广度优先遍历进程树，将pid放入tmp
-const flatProcessTree = (tree, tmp) => {
-    if (tree.children) {
-        tmp.push(...tree.children.map((item) => item.pid));
-        tree.children.forEach((item) => flatProcessTree(item, tmp));
-    }
-    tree = null;
-    tmp = null;
-};
-export async function SIGKILL(pid, signal = 2) {
-    if (process.platform === 'win32') {
-        return new Promise((resolve) => {
-            exec(`taskkill /pid ${pid} /T /F`, resolve);
-        });
-    }
-    let tree = await getProcessTree(pid);
-    // 获取所有进程PID,从叶到根
-    const tmp = [tree.pid];
-    flatProcessTree(tree, tmp);
-    tmp.reverse();
-    tree = null;
-    for (const item of tmp) {
-        await _SIGKILL(item, signal);
-    }
-    return 'success';
-}
-// 子进程心跳包
-export const heartbeat = () => {
-    if (typeof process.send !== 'function') {
-        return;
-    }
-    loop(async () => {
-        await new Promise((resolve) => {
-            process.send({ type: 'beat', timestamp: new Date().valueOf() }, resolve);
-        });
-    }, 6000);
-};
-const parseAudioCard = (v) => {
-    let card = /card \d/.exec(v) ?? ['card 1'];
-    card = parseInt(card[0].replace('card ', ''), 10);
-    let device = /device \d/.exec(v) ?? ['device 0'];
-    device = parseInt(device[0].replace('device ', ''), 10);
-    return { text: v, index: `hw:${card},${device}` };
-};
-export const getAudioCards = (filter = '') => {
-    return new Promise((resolve, reject) => {
-        exec(`arecord -l`, (err, stdout) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                const arr = stdout
-                    .toString()
-                    .split('\n')
-                    .filter((item) => item.includes('card') && (filter ? item.includes(filter) : true))
-                    .map((item) => parseAudioCard(item));
-                resolve(arr);
-            }
-        });
-    });
-};

package/es/file-system/index.d.ts

@@ -1,26 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type EventEmitter from 'events';
-import * as fs from 'fs';
-interface PuboFileSystemInterface {
-    read: <TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer?: TBuffer, offset?: number, length?: number, position?: fs.ReadPosition | null) => Promise<[number, TBuffer]>;
-    stat: (path: fs.PathLike) => Promise<fs.Stats>;
-    readFile: (path: fs.PathOrFileDescriptor, options?: ({
-        encoding?: null;
-        flag?: string;
-    } & EventEmitter.Abortable) | null) => Promise<Buffer>;
-    writeFile: (file: fs.PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: fs.WriteFileOptions) => Promise<void>;
-    readdir: (path: fs.PathLike, options?: BufferEncoding | {
-        encoding: BufferEncoding | null;
-        withFileTypes: false;
-    } | null) => Promise<string[]>;
-    open: (path: fs.PathLike, flags?: fs.OpenMode, mode?: fs.Mode | null) => Promise<number>;
-    close: (fd: number) => Promise<void>;
-    mkdir: (path: fs.PathLike, options?: fs.MakeDirectoryOptions) => Promise<void>;
-    rm: (path: fs.PathLike) => Promise<void>;
-    write: <TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, offset?: number | null, length?: number | null, position?: number | null) => Promise<void>;
-}
-export declare const PuboFileSystem: PuboFileSystemInterface;
-export {};

package/es/file-system/index.js

@@ -1,28 +0,0 @@
-import * as fs from 'fs';
-const callback2promise = (fn) => {
-    return (...args) => new Promise((resolve, reject) => {
-        fn(...args, (err, ...rest) => {
-            if (err) {
-                reject(err);
-            }
-            if (rest.length < 2) {
-                resolve(rest[0]);
-            }
-            else {
-                resolve([...rest]);
-            }
-        });
-    });
-};
-export const PuboFileSystem = {
-    read: callback2promise(fs.read),
-    readFile: callback2promise(fs.readFile),
-    writeFile: callback2promise(fs.writeFile),
-    readdir: callback2promise(fs.readdir),
-    open: callback2promise(fs.open),
-    close: callback2promise(fs.close),
-    write: callback2promise(fs.write),
-    stat: callback2promise(fs.stat),
-    mkdir: callback2promise(fs.mkdir),
-    rm: callback2promise(fs.rm),
-};

package/es/ftp-client/index.d.ts

@@ -1,66 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Stream } from 'stream';
-export interface FtpFile {
-    name: string;
-    owner: string;
-    group: string;
-    size: number;
-    date: Date;
-    type: string;
-}
-export interface FtpConnectOptions {
-    user: string;
-    host: string;
-    password: string;
-    driver: any;
-}
-type GetFile = (path: string) => Promise<Buffer>;
-type PutFile = (input: string | Buffer | Stream, path: string) => Promise<string>;
-type DeleteFile = (path: string) => Promise<string>;
-type ListFiles = (path: string) => Promise<FtpFile[]>;
-type RenameFile = (path: string, old: string) => Promise<string>;
-export interface FtpClientInterface {
-    get: GetFile;
-    put: PutFile;
-    delete: DeleteFile;
-    list: ListFiles;
-    rename: RenameFile;
-}
-export declare class FtpClient implements FtpClientInterface {
-    private readonly driver;
-    private readonly options;
-    private readonly state;
-    private client;
-    private _len;
-    id: string;
-    constructor({ driver, ...options }: FtpConnectOptions);
-    get len(): number;
-    set len(n: number);
-    put: (...args: any[]) => Promise<any>;
-    delete: (...args: any[]) => Promise<any>;
-    list: (...args: any[]) => Promise<any>;
-    rename: (...args: any[]) => Promise<any>;
-    private connect;
-    private close;
-    private run;
-    private bind;
-    get(...args: any[]): Promise<Buffer>;
-}
-export declare class FtpClientPool implements FtpClientInterface {
-    private readonly options;
-    private readonly maxConnection;
-    private readonly pool;
-    constructor({ maxConnection, ...options }: {
-        maxConnection?: number;
-    } & FtpConnectOptions);
-    get: (...args: any[]) => Promise<any>;
-    put: (...args: any[]) => Promise<any>;
-    delete: (...args: any[]) => Promise<any>;
-    list: (...args: any[]) => Promise<any>;
-    rename: (...args: any[]) => Promise<any>;
-    get len(): number;
-    private get client();
-    private bind;
-}
-export {};

package/es/ftp-client/index.js

@@ -1,135 +0,0 @@
-import { random, waitFor } from 'pubo-utils';
-export class FtpClient {
-    driver;
-    options;
-    state = { running: false, connected: false, destroyed: false, connecting: false };
-    client;
-    _len = 0;
-    id = random();
-    constructor({ driver, ...options }) {
-        this.driver = driver;
-        this.options = options;
-    }
-    get len() {
-        return this._len;
-    }
-    set len(n) {
-        this._len = n;
-        if (this._len < 1) {
-            this.close();
-        }
-    }
-    put = this.bind('put');
-    delete = this.bind('delete');
-    list = this.bind('list');
-    rename = this.bind('rename');
-    async connect() {
-        if (!this.client) {
-            this.client = new this.driver();
-        }
-        this.state.destroyed = false;
-        if (this.state.connecting) {
-            await waitFor(() => this.state.connected, { checkTime: 1000, timeout: 10000 });
-            return 'connected';
-        }
-        this.state.connecting = true;
-        return new Promise((resolve, reject) => {
-            this.client.once('ready', () => {
-                this.state.connected = true;
-                resolve('connected');
-                this.state.connecting = false;
-            });
-            this.client.once('error', (err) => {
-                reject(err);
-                this.close();
-            });
-            this.client.connect({ ...this.options });
-        });
-    }
-    close() {
-        this.client.end();
-        this.state.connected = false;
-        this.state.destroyed = true;
-        this.state.connecting = false;
-        this.client = null;
-    }
-    async run({ fn, args }) {
-        this.len += 1;
-        if (!this.state.connected) {
-            await this.connect();
-        }
-        if (this.state.running) {
-            await waitFor(() => !this.state.running, { checkTime: 1000, timeout: 6000000 });
-        }
-        this.state.running = true;
-        return new Promise((resolve, reject) => {
-            this.client[fn](...args, (err, res) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(res);
-                }
-            });
-        });
-    }
-    bind(fn) {
-        return async (...args) => {
-            const res = await this.run({ fn, args });
-            this.state.running = false;
-            this.len -= 1;
-            return res;
-        };
-    }
-    async get(...args) {
-        let res = Buffer.alloc(0);
-        const stream = await this.run({ fn: 'get', args });
-        return new Promise((resolve) => {
-            stream.on('data', (chunk) => {
-                res = Buffer.concat([res, chunk], res.byteLength + chunk.byteLength);
-            });
-            stream.on('end', () => {
-                resolve(res);
-                this.state.running = false;
-                this.len -= 1;
-            });
-        });
-    }
-}
-export class FtpClientPool {
-    options;
-    maxConnection;
-    pool = [];
-    constructor({ maxConnection = 5, ...options }) {
-        this.options = options;
-        this.maxConnection = maxConnection;
-    }
-    get = this.bind('get');
-    put = this.bind('put');
-    delete = this.bind('delete');
-    list = this.bind('list');
-    rename = this.bind('rename');
-    get len() {
-        return this.pool.length;
-    }
-    get client() {
-        if (this.pool.length < this.maxConnection) {
-            const client = new FtpClient(this.options);
-            this.pool.push(client);
-            return client;
-        }
-        this.pool.sort((a, b) => a.len - b.len);
-        return this.pool[0];
-    }
-    bind(fn) {
-        return async (...args) => {
-            const client = this.client;
-            const res = await client[fn](...args);
-            if (client.len < 1) {
-                const index = this.pool.findIndex((item) => item.id === client.id);
-                this.pool.splice(index, 1);
-            }
-            return res;
-        };
-    }
-}

package/es/grpc/index.d.ts

@@ -1,28 +0,0 @@
-/// <reference types="node" />
-export interface CreateClientProps {
-    url: string;
-    options?: any;
-    ServiceImp: any;
-    Grpc: any;
-    cert?: Buffer;
-}
-declare class GrpcClient {
-    private readonly url;
-    private readonly options;
-    private readonly Grpc;
-    private readonly credentials;
-    private client;
-    private _timeout;
-    connections: number;
-    constructor({ url, options, Grpc, cert }: any);
-    request(service: any, method: any, data: any): Promise<Buffer>;
-    _request({ service, method, data }: {
-        service: any;
-        method: any;
-        data: any;
-    }): Promise<Buffer>;
-    close(): void;
-}
-export declare const GrpcList: GrpcClient[];
-export declare function createRpcClient<T>({ url, options, ServiceImp, Grpc, cert }: CreateClientProps): T;
-export {};

package/es/grpc/index.js

@@ -1,103 +0,0 @@
-const passThrough = (argument) => argument;
-class GrpcClient {
-    url;
-    options;
-    Grpc;
-    credentials;
-    client;
-    _timeout;
-    connections = 0;
-    constructor({ url, options = {}, Grpc, cert }) {
-        const opt = { 'grpc.max_send_message_length': -1, 'grpc.max_receive_message_length': -1, ...options };
-        const credentials = cert ? Grpc.credentials.createSsl(cert) : Grpc.credentials.createInsecure();
-        this.url = url;
-        this.Grpc = Grpc;
-        this.credentials = credentials;
-        this.options = opt;
-        this.options.timeout = this.options.timeout ?? 10000;
-        Grpc = null;
-        options = null;
-        cert = null;
-    }
-    async request(service, method, data) {
-        if (this._timeout) {
-            clearTimeout(this._timeout);
-            this._timeout = null;
-        }
-        this.connections += 1;
-        if (!this.client) {
-            this.client = new this.Grpc.Client(this.url, this.credentials, this.options);
-        }
-        let error;
-        let result = Buffer.alloc(0);
-        try {
-            result = await this._request({ service, method, data });
-        }
-        catch (err) {
-            error = err;
-        }
-        service = null;
-        method = null;
-        data = null;
-        this.connections -= 1;
-        if (this.connections < 0) {
-            this.connections = 0;
-        }
-        if (this.connections < 1) {
-            if (this._timeout) {
-                clearTimeout(this._timeout);
-                this._timeout = null;
-            }
-            this._timeout = setTimeout(() => this.close(), 60000);
-        }
-        if (error) {
-            console.log(error);
-            this.close();
-            throw new Error('grpc connection error.');
-        }
-        return result;
-    }
-    _request({ service, method, data }) {
-        return new Promise((resolve, reject) => {
-            let _ended = false;
-            const _timeout = setTimeout(() => {
-                _ended = true;
-                this.close();
-                console.log('rpc request timeout');
-                reject(new Error('timeout'));
-            }, this.options.timeout);
-            const onResponse = (err, res) => {
-                if (_ended) {
-                    return;
-                }
-                else {
-                    clearTimeout(_timeout);
-                }
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(res);
-                }
-            };
-            this.client.makeUnaryRequest(`/${service}/${method}`, passThrough, passThrough, data ? Buffer.from(data) : Buffer.alloc(0), onResponse);
-        });
-    }
-    close() {
-        if (this._timeout) {
-            clearTimeout(this._timeout);
-            delete this._timeout;
-        }
-        this.client?.close();
-        this.client = null;
-        delete this.client;
-    }
-}
-export const GrpcList = [];
-export function createRpcClient({ url, options = {}, ServiceImp, Grpc, cert }) {
-    const client = new GrpcClient({ url, options, Grpc, cert });
-    GrpcList.push(client);
-    Grpc = null;
-    options = null;
-    return new ServiceImp({ request: client.request.bind(client) });
-}

package/es/index.d.ts

@@ -1,8 +0,0 @@
-export { JsonStorage } from './storage/json';
-export { FtpClient, FtpClientPool, FtpConnectOptions, FtpFile } from './ftp-client';
-export { createRpcClient, GrpcList } from './grpc';
-export { SIGKILL, isProcessDied, getProcessName, getProcessTree, getProcessByPpid, getProcessCpuUseByPid, getProcessCommandByPid, heartbeat, } from './child-process';
-export { isPortAvailable } from './utils';
-export { getWifiName, getNetworks } from './utils/network';
-export { RosTopicManager, RosTopic } from './ros/topic';
-export { PuboFileSystem } from './file-system';

package/es/index.js

@@ -1,8 +0,0 @@
-export { JsonStorage } from './storage/json';
-export { FtpClient, FtpClientPool } from './ftp-client';
-export { createRpcClient, GrpcList } from './grpc';
-export { SIGKILL, isProcessDied, getProcessName, getProcessTree, getProcessByPpid, getProcessCpuUseByPid, getProcessCommandByPid, heartbeat, } from './child-process';
-export { isPortAvailable } from './utils';
-export { getWifiName, getNetworks } from './utils/network';
-export { RosTopicManager, RosTopic } from './ros/topic';
-export { PuboFileSystem } from './file-system';

package/es/ros/topic.d.ts

@@ -1,20 +0,0 @@
-import { Emitter } from 'pubo-utils';
-export declare class RosTopic {
-    topic: string;
-    messageType: string;
-    emitter: Emitter;
-    private subscribed;
-    private readonly dog;
-    private readonly strSplit;
-    private subscribeChildProcess;
-    constructor(topic: any, messageType: any);
-    private onTimeout;
-    private onData;
-    subscribe(): Promise<void>;
-    unsubscribe(): Promise<void>;
-    publish(payload: any): Promise<unknown>;
-}
-export declare const RosTopicManager: {
-    cache: never[];
-    getTopic: (topic: any, messageType: any) => RosTopic;
-};

package/es/ros/topic.js

@@ -1,80 +0,0 @@
-import { exec, spawn } from 'child_process';
-import { Emitter, WatchDog, StringSplit, sleep } from 'pubo-utils';
-import * as YAML from 'yaml';
-import { SIGKILL } from '../child-process';
-export class RosTopic {
-    topic;
-    messageType;
-    emitter = new Emitter();
-    subscribed = false;
-    dog = new WatchDog({ limit: 10, onTimeout: this.onTimeout.bind(this) });
-    strSplit = new StringSplit('---');
-    subscribeChildProcess;
-    constructor(topic, messageType) {
-        this.topic = topic;
-        this.messageType = messageType;
-        this.subscribed = false;
-        this.emitter = new Emitter();
-    }
-    async onTimeout() {
-        if (!this.subscribed) {
-            return;
-        }
-        await this.unsubscribe();
-        await sleep(1000);
-        await this.subscribe();
-    }
-    onData(data) {
-        const tmp = this.strSplit.split(data.toString()).slice(-1)[0];
-        if (!tmp) {
-            return;
-        }
-        this.dog.feed();
-        const res = YAML.parse(tmp);
-        this.emitter.emit('message', res);
-    }
-    async subscribe() {
-        if (this.subscribeChildProcess) {
-            return;
-        }
-        this.subscribed = true;
-        this.dog.init();
-        this.subscribeChildProcess = spawn(`rostopic`, ['echo', this.topic]);
-        this.subscribeChildProcess.stdout.on('data', this.onData.bind(this));
-        this.subscribeChildProcess.stderr.on('data', (buf) => console.log(buf.toString()));
-    }
-    async unsubscribe() {
-        if (!this.subscribeChildProcess) {
-            return;
-        }
-        this.dog.stop();
-        this.subscribed = false;
-        await SIGKILL(this.subscribeChildProcess.pid);
-        this.subscribeChildProcess = null;
-    }
-    publish(payload) {
-        const data = YAML.stringify(payload);
-        return new Promise((resolve, reject) => {
-            exec(`rostopic pub -1 ${this.topic} ${this.messageType} "${data}"`, (err, stdout) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(stdout);
-                }
-            });
-        });
-    }
-}
-export const RosTopicManager = {
-    cache: [],
-    getTopic: function (topic, messageType) {
-        const tmp = this.cache.find((item) => item.topic === topic);
-        if (tmp) {
-            return tmp;
-        }
-        const instance = new RosTopic(topic, messageType);
-        this.cache.push(instance);
-        return instance;
-    },
-};

package/es/storage/json.d.ts

@@ -1,15 +0,0 @@
-export interface JsonStorageOptions {
-    initialState?: any;
-    defaultState?: any;
-}
-export declare class JsonStorage {
-    private readonly instance;
-    private readonly queue;
-    constructor(path: string, options?: JsonStorageOptions);
-    private getState;
-    private setState;
-    get(key?: string): Promise<any>;
-    set(key: string, values: any): Promise<void>;
-    merge(values: any): Promise<void>;
-    remove(key: string): Promise<void>;
-}