node-universe/dist/src/lib/star/index.d.ts

基于 Nodejs 环境的一款微服务框架，原理来自于宇宙中的恒星，行星，卫星等系统。

import { GenericObject } from '../../typings';
import { LoggerInstance } from '../../typings/logger';
import { Serialize } from '../../typings/serializers';
import { ServiceSchema, ServiceSettingSchema } from '../../typings/service';
import { MCallCallingOptions, StarMCallActionParams, StarOptions } from '../../typings/star';
import EventEmitter2 from 'eventemitter2';
import Context from '../context';
import { Regenerator, ServiceNotFoundError } from '../error';
import { LoggerFactory } from '../logger/factory';
import MiddlewareHandler from '../middleware/handler';
import { Registry } from '../registry';
import Transit from '../transit';
import Service from './service';
import { MetricRegistry } from '../metrics';
import ServiceItem from '../registry/service-item';
import { ServiceSearchObj } from '../../typings/star/service';
import { Validator } from '../../typings/validator';
import Tracer from '../tracing/tracer';
export default class Star {
    static UNIVERSE_VERSION: string;
    static PROTOCOL_VERSION: string;
    static INTERNAL_MIDDLEWARES: string[];
    options: StarOptions;
    namespace: string | null;
    nodeID: string | null;
    metadata: GenericObject;
    instanceID: string;
    started: boolean;
    stopping: boolean;
    logger: LoggerInstance | null;
    loggerFactory: LoggerFactory | null;
    transit: Transit | null;
    serializer: Serialize | null;
    cacher: any;
    errorRegenerator: Regenerator | null;
    ContextFactory: any;
    ServiceFactory: any;
    metrics: MetricRegistry | null;
    registry: Registry | null;
    validator: Validator | null;
    tracer: Tracer | null;
    middlewares: MiddlewareHandler | null;
    services: Service[];
    _closeFn: any;
    Promise: any;
    localBus: EventEmitter2 | null;
    constructor(options: StarOptions);
    start(): Promise<void>;
    stop(): Promise<any>;
    fatal(message: string, error?: any, needQuit?: boolean): void;
    repl(): any;
    getLogger(mod: string, props?: any): any;
    errorHandler(error: Error, info: any): void;
    generateUid(): string;
    findNextActionEndpoint(actionName: string, options: GenericObject, context: Context): import("../registry/endpoint/item").default | ServiceNotFoundError;
    call(actionName: string, params?: GenericObject, options?: GenericObject): Promise<any>;
    callWithoutBalancer(actionName: string, params?: GenericObject, options?: GenericObject): Promise<any>;
    _getLocalActionEndpoint(actionName: string, ctx?: Context): import("../registry/endpoint/item").default;
    mcall(def: Array<StarMCallActionParams> | Record<string, StarMCallActionParams>, opts?: MCallCallingOptions): Promise<any[] | GenericObject>;
    getConstructorName(obj: any): string | undefined;
    getCpuUsage(): Promise<{
        avg: number;
        usages: number[];
    }>;
    broadcastLocal(eventName: string, payload?: any, options?: GenericObject): Promise<void>;
    broadcast(eventName: string, payload?: any, options?: GenericObject): Promise<any[]> | undefined;
    emit(eventName: string, payload?: any, options?: GenericObject): Promise<void> | Promise<any[]> | undefined;
    emitLocalServices(ctx: Context): Promise<any>;
    ping(nodeID: string | string[], timeout?: number): Promise<unknown>;
    isMetricsEnabled(): boolean | undefined;
    private registerUniverseMetrics;
    isTracingEnabled(): any;
    registerMiddlewares(userMiddlewares: any): void;
    wrapMethod(name: string, handler: Function, bindTo?: any, options?: Object): Function | undefined;
    callMiddlewareHook(name: string, args: Array<any>, options?: any): any;
    callMiddlewareHookSync(name: string, args: Array<any>, options?: any): any;
    getLocalNodeInfo(): any;
    getHealthStatus(): {
        cpu: any;
        memory: any;
        os: {
            uptime: number;
            type: string;
            release: string;
            hostname: string;
            arch: string;
            platform: NodeJS.Platform;
            user: {};
        };
        process: {
            pid: number;
            memory: NodeJS.MemoryUsage;
            uptime: number;
            argv: string[];
        };
        client: {
            type: string;
            version: string;
            langVersionL: string;
        };
        net: {
            ip: string[];
        };
        time: {
            now: number;
            iso: string;
            utc: string;
        };
    };
    getEventGroups(eventName: string): (string | null)[] | undefined;
    hasEventListener(eventName: string): boolean;
    getEventListeners(eventName: string): any[] | undefined;
    createService(schema: any, schemaMods?: any): any;
    registerLocalService(registryItem: ServiceItem): null;
    destroyService(service: string | Service | GenericObject): Promise<void>;
    getLocalService(name: string | ServiceSearchObj, version?: string | number): Service<ServiceSettingSchema> | undefined;
    _restarService(service: Service): Promise<void | undefined>;
    normalizeSchemaConstructor(schema: any): any;
    addLocalService(service: Service<ServiceSettingSchema>): void;
    servicesChanged(localService: boolean): void;
    localServiceChanged(): void;
    registerInternalServices(options: boolean | {
        [key: string]: Partial<ServiceSchema>;
    }): void;
    waitForServices(serviceNames: any | any[], timeout?: number | undefined, interval?: number | undefined, logger?: LoggerInstance | null): Promise<unknown>;
    loadServices(folder?: string, fileMask?: string): number;
    loadService(filePath: string): any;
}