homebridge-config-ui-x/dist/core/homebridge-ipc/homebridge-ipc.service.js

A web based management, configuration and control platform for Homebridge.

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
import { EventEmitter } from 'node:events';
import { Inject, Injectable, ServiceUnavailableException } from '@nestjs/common';
import { ConfigService } from '../config/config.service.js';
import { Logger } from '../logger/logger.service.js';
let HomebridgeIpcService = class HomebridgeIpcService extends EventEmitter {
    logger;
    configService;
    homebridge;
    pendingShutdownTimer = null;
    permittedEvents = [
        'childBridgeMetadataResponse',
        'childBridgeStatusUpdate',
        'serverStatusUpdate',
        'matterEvent',
    ];
    constructor(logger, configService) {
        super();
        this.logger = logger;
        this.configService = configService;
    }
    setHomebridgeProcess(process) {
        this.homebridge = process;
        if (this.pendingShutdownTimer) {
            clearTimeout(this.pendingShutdownTimer);
            this.pendingShutdownTimer = null;
        }
        this.homebridge.setMaxListeners(this.homebridge.getMaxListeners() + 2);
        this.homebridge.on('message', (message) => {
            if (typeof message !== 'object' || !message.id) {
                return;
            }
            if (this.permittedEvents.includes(message.id)) {
                this.emit(message.id, message.data);
            }
        });
        this.homebridge.on('close', () => {
            this.emit('serverStatusUpdate', { status: 'down' });
        });
    }
    setHomebridgeVersion(version, modulePath) {
        this.configService.homebridgeVersion = version;
        if (modulePath) {
            this.configService.runningHomebridgeModulePath = modulePath;
        }
    }
    async requestResponse(requestEvent, responseEvent) {
        return new Promise((resolve, reject) => {
            const actionTimeout = setTimeout(() => {
                this.removeListener(responseEvent, listener);
                this.setMaxListeners(this.getMaxListeners() - 1);
                reject(new Error('The Homebridge service did not respond'));
            }, 3000);
            const listener = (data) => {
                clearTimeout(actionTimeout);
                this.setMaxListeners(this.getMaxListeners() - 1);
                resolve(data);
            };
            this.setMaxListeners(this.getMaxListeners() + 1);
            this.once(responseEvent, listener);
            try {
                this.sendMessage(requestEvent);
            }
            catch (e) {
                clearTimeout(actionTimeout);
                this.removeListener(responseEvent, listener);
                this.setMaxListeners(this.getMaxListeners() - 1);
                reject(e);
            }
        });
    }
    sendMessage(type, data) {
        if (this.homebridge && this.homebridge.connected) {
            this.homebridge.send({ id: type, data });
        }
        else {
            throw new ServiceUnavailableException('The Homebridge Service Is Unavailable');
        }
    }
    restartHomebridge() {
        if (!this.homebridge) {
            return;
        }
        if (this.pendingShutdownTimer) {
            return;
        }
        this.logger.log('Sending SIGTERM to Homebridge...');
        if (!this.homebridge.kill('SIGTERM')) {
            this.logger.error('Failed to deliver SIGTERM to Homebridge — process may already be gone or kill() was refused.');
        }
        this.pendingShutdownTimer = setTimeout(() => {
            try {
                this.logger.warn('Sending SIGKILL to Homebridge...');
                if (!this.homebridge.kill('SIGKILL')) {
                    this.logger.error('Failed to deliver SIGKILL to Homebridge — process may already be gone or kill() was refused.');
                    this.emit('serverStatusUpdate', { status: 'killFailed' });
                }
            }
            catch (e) {
                this.logger.error(`Failed to deliver SIGKILL to Homebridge: ${e.message}.`);
                this.emit('serverStatusUpdate', { status: 'killFailed' });
            }
            finally {
                this.pendingShutdownTimer = null;
            }
        }, 7000);
        this.homebridge.once('close', () => {
            if (this.pendingShutdownTimer) {
                clearTimeout(this.pendingShutdownTimer);
                this.pendingShutdownTimer = null;
            }
        });
    }
    async restartAndWaitForClose() {
        if (!this.homebridge || !this.homebridge.connected) {
            return true;
        }
        else {
            return new Promise((resolve) => {
                this.homebridge.once('close', () => {
                    resolve(true);
                });
                this.restartHomebridge();
            });
        }
    }
    async killHomebridge() {
        if (!this.homebridge) {
            return false;
        }
        this.logger.log('Sending SIGKILL to Homebridge...');
        const delivered = this.homebridge.kill('SIGKILL');
        if (!delivered) {
            this.logger.error('Failed to deliver SIGKILL to Homebridge — process may already be gone or kill() was refused.');
            this.emit('serverStatusUpdate', { status: 'killFailed' });
        }
        return delivered;
    }
};
HomebridgeIpcService = __decorate([
    Injectable(),
    __param(0, Inject(Logger)),
    __param(1, Inject(ConfigService)),
    __metadata("design:paramtypes", [Logger,
        ConfigService])
], HomebridgeIpcService);
export { HomebridgeIpcService };
//# sourceMappingURL=homebridge-ipc.service.js.map