onirii/lib/service/rabbit/rabbit-manager-service.d.ts

Universal queue SDK

import { RabbitManagerExchangeInterface } from '../../interface/rabbit-manager/rabbit-manager-exchange-interface';
import { RabbitManagerHealthInterface } from '../../interface/rabbit-manager/rabbit-manager-health-interface';
import { RabbitManagerQueueInterface } from '../../interface/rabbit-manager/rabbit-manager-queue-interface';
import { RabbitManagerVhostInterface } from '../../interface/rabbit-manager/rabbit-manager-vhost-interface';
import { RMChannel } from '../../model/rabbit-manager/rabbit-manager-channel-namespace';
import { RMConnect } from '../../model/rabbit-manager/rabbit-manager-connect-namespace';
import { RMExchange } from '../../model/rabbit-manager/rabbit-manager-exchange-namespace';
import { RMHealth } from '../../model/rabbit-manager/rabbit-manager-health-namespace';
import { RMVhost } from '../../model/rabbit-manager/rabbit-manager-vhost-namespace';
import { RabbitManager } from '../../model/rabbit-manager/rebbit-manager-namespace';
export declare class RabbitManagerService implements RabbitManagerHealthInterface, RabbitManagerVhostInterface, RabbitManagerExchangeInterface, RabbitManagerQueueInterface {
    private readonly logger;
    private readonly managerApi;
    private readonly instanceName;
    private readonly apiRequester;
    /**
     * Constructor
     *
     * @param {string} name identify name
     * @param {string} managerApi manager api
     * @param {string} auth manager auth
     */
    constructor(name: string, managerApi?: string, auth?: string);
    /**
     * Check target manager service status, this method is not a necessary init method just for check
     *
     * @return {Promise<void>}
     */
    ready(): Promise<boolean>;
    /**
     * Get all system alarms
     *
     * @return {Promise<any>} if cant connect to server specific return [false]
     */
    checkAlarms(): Promise<any>;
    /**
     * Check Certificate
     *
     * @param {number} leftTime left expire time
     * @param {"days" | "weeks" | "months" | "years"} unit time unit
     * @return {Promise<any>} if cant connect to server specific return [false]
     */
    checkCertificate(leftTime: number, unit: 'days' | 'weeks' | 'months' | 'years'): Promise<any>;
    /**
     * Check all local alarms
     *
     * @return {Promise<any>} if cant connect to server specific return [false]
     */
    checkLocalAlarms(): Promise<any>;
    /**
     * Check node mirror sync status
     *
     * @return {Promise<HealthCheckBaseRs | boolean>} if cant connect to server specific return [false]
     */
    checkNodeMirrorSyncCritical(): Promise<RMHealth.HealthCheckBaseRs | boolean>;
    /**
     * Check node quorum status
     *
     * @return {Promise<HealthCheckBaseRs | boolean>} if cant connect to server specific return [false]
     */
    checkNodeQuorumCritical(): Promise<RMHealth.HealthCheckBaseRs>;
    /**
     * Check port health
     *
     * @param {number} port target port
     * @return {Promise<HealthCheckPortRs | boolean>} if cant connect to server specific return [false]
     */
    checkPortHealth(port: number): Promise<RMHealth.HealthCheckPortRs | boolean>;
    /**
     * check server protocol status
     *
     * @param {"amqp091" | "amqp10" | "mqtt" | "stomp" | "web-mqtt" | "web-stomp"} name target protocol
     * @return {Promise<HealthCheckProtocolRs | boolean>} if cant connect to server specific return [false]
     */
    checkProtocol(name: 'amqp091' | 'amqp10' | 'mqtt' | 'stomp' | 'web-mqtt' | 'web-stomp'): Promise<RMHealth.HealthCheckProtocolRs | boolean>;
    /**
     * Check all vhost status
     *
     * @return {Promise<any>} if cant connect to server specific return [false]
     */
    checkVirtualHosts(): Promise<any>;
    /**
     * Create a new vhost
     *
     * @param {string} name vhost name
     * @param {CreateVhostParams} params create options
     * @return {Promise<boolean>}
     */
    createVhost(name: string, params?: RMVhost.CreateVhostParams): Promise<boolean>;
    /**
     * Delete vhost
     *
     * Note::If checkImmediately = false this method will always return true
     *
     * @param {string} name target vhost name
     * @param {boolean} checkImmediately check deleted?
     * @param {CreateVhostParams} params delete options
     * @return {Promise<boolean>}
     */
    deleteVhost(name: string, checkImmediately?: boolean, params?: any): Promise<boolean>;
    /**
     * Get vhost status
     *
     * @return {Promise<>} if cant connect to server or vhost not exist specific return [false]
     */
    getVhost(): Promise<RMVhost.VhostDataModel[]>;
    getVhost(name: string): Promise<RMVhost.VhostDataModel | boolean>;
    /**
     * Get vhost all connection list
     *
     * @param {string} name vhost name
     * @return {Promise<RMConnect.VhostConnectionsStatus[] | boolean>} if cant connect to server or vhost not exist specific return [false]
     */
    getVhostConnection(name: string): Promise<RMConnect.VhostConnectionsStatus[] | boolean>;
    /**
     * Get vhost all opening channel list
     *
     * @param {string} name vhost name
     * @param {RabbitManager.PaginationParams} options paginationParams
     * @return {Promise<RMChannel.VhostChannelStatus[] | boolean>} if cant connect to server or vhost not exist specific return [false]
     */
    getVhostOpenChannels(name: string, options?: RabbitManager.PaginationParams): Promise<RMChannel.VhostChannelStatus[] | boolean>;
    /**
     * Start rabbit node
     * @param {string} vhostName target vhost name
     * @param {string} nodeName target node name
     * @return {Promise<any>}
     */
    startNode(vhostName: string, nodeName: string): Promise<any>;
    /**
     * Create exchange
     *
     * @param {string} vhost target vhost
     * @param {string} name new exchange name
     * @param {RMExchange.CreateOptions} options create exchange options
     * @return {Promise<boolean>} if already exist return false and print warn
     */
    createExchange(vhost: string, name: string, options: RMExchange.CreateOptions): Promise<boolean>;
    /**
     * Delete Exchange
     *
     * Note:: If checkImmediately = false this method will always return true
     *
     * @param {string} vhost target vhost name
     * @param {string} name target exchange name
     * @param {boolean} checkImmediately check deleted?
     * @param {RMExchange.DeleteOptions} options delete options
     * @return {Promise<boolean>}
     */
    deleteExchange(vhost: string, name: string, checkImmediately?: boolean, options?: RMExchange.DeleteOptions): Promise<boolean>;
    /**
     * Get exchange status
     *
     * @return {Promise<RMExchange.ExchangeStatusModel[] | RMExchange.ExchangeStatusModel | boolean>} if cant connect to server or exchange    not exist specific return [false]
     */
    getExchange(): Promise<RMExchange.ExchangeStatusModel[]>;
    getExchange(vhost: string): Promise<RMExchange.ExchangeStatusModel[]>;
    getExchange(vhost: string, name: string): Promise<RMExchange.ExchangeStatusModel | boolean>;
}