domotz-remote-pawn/src/setup/resourceLocator.js

Domotz Agent

/** This file is part of Domotz Agent.
 * Copyright (C) 2016  Domotz Ltd
 *
 * Domotz Agent is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Domotz Agent is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Domotz Agent.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Created by Iacopo Papalini <ipapalini@domotz.com> on 16/06/15.
 */

const MODULE = 'INIT';

// External Dependencies
require('events').EventEmitter.prototype._maxListeners = 15;
var amqplib = require('amqplib');
var async = require('async');
var bodyParser = require('body-parser');
var bonjour = require('bonjour');
var childProcess = require('child_process');
var crypto = require('crypto');
var deepEqual = require('deep-equal');
var dgram = require('dgram');
var dhcpjs = require('../modules/dhcpjs');
var dns = require('dns');
var express = require('express');
var events = require('events');
var favicon = require('serve-favicon');
var fs = require('fs');
var http = require('http');
var ip = require('domotz-ip-address');
var lodash = require('lodash');
var moment = require('moment-timezone');
var natUpnp = require('domotz-nat-upnp');
var net = require('net');
var netmask = require('netmask');
var sentry;
try {
    sentry = require('@sentry/node');
} catch (e) {
    sentry = null;
}

var snmpv3Supported = false;

var firmware = require('../utils/firmware').factory(fs);
var domotzPlatform = require('../utils/platform').factory(fs);
var netSnmp;
var console = require('../utils/logging/registry').registry().getLogger('setup.resourceLocator');
var zlib = require('zlib');

try {
    console.info('Node version:  ' + domotzPlatform.getNodeVersion());

    if (domotzPlatform.isNodeVersionZero()) {
        netSnmp = require('net-snmp');
    } else {
        netSnmp = require('net-snmp-domotz');
        snmpv3Supported = true;
    }
} catch (err) {
    console.info(err);
    netSnmp = require('net-snmp');
}

var snmpNative = require('snmp-native');
var os = require('os');
var path = require('path');
var q = require('q');
var telnet = require('telnet-client');
var tftp = require('tftp');
var ssdp = require('domotz-node-ssdp');
var ssh2 = require('ssh2');
var step = require('step');
var url = require('url');
var util = require('util');
var xml2js = require('xml2js');
var xml2jsProcessor = require('xml2js/lib/processors.js');
var whois = require('node-whois');
var winston = require('winston');
var ws = require('ws');

// Internal Dependencies (no need for further initialization)
var pkgJson = require('../../package.json');

console.info('Package.json version %s', pkgJson.version);

var request = require('request');
var web = require('../../src/http/utils');

var command = require('../../src/utils/command');
var mutex = require('../../src/utils/mutex');
var time = require('../../src/utils/time');
var number = require('../../src/utils/number');
var random = require('../utils/random');
var modules = require('../utils/modules');
var dataStructure = require('../../src/utils/data_structure');
var scheduler = require('../../src/utils/scheduler');

var commandHttpRequest = require('../commands/httpRequest');
var snmpGetNative = require('../../src/commands/snmp/getNative');

function initSnmpCommon(settingsManager, domotzLog) {
    console.debug('%s - Snmp Common module initialization', MODULE);
    return require('../../src/snmp/common').factory(netSnmp, settingsManager, domotzLog);
}

function initFileManager() {
    console.debug('%s - Creating file manager', MODULE);
    return require('../persistence/file').factory(fs, q);
}

function getCacheUtils(procManager) {
    console.debug('%s - Creating cache manager', MODULE);
    return require('../persistence/cache').factory(procManager, fs);
}

function getHubConfigurator(resourceLocator) {
    console.debug('%s - Loading Agent configuration', MODULE);
    return require('../setup/configuration').factory(resourceLocator);
}

function initStatusManager(configuration, logger) {
    console.debug('%s - Initializing status manager', MODULE);
    return require('../setup/status').factory(configuration, logger);
}

function initLog(resourceLocator) {
    console.info('%s - Initializing Log', MODULE);
    return require('../setup/logger').factory(resourceLocator);
}

function initIpWrapper(resourceLocator) {
    'use strict';
    return require('../net/main_network').ipWrapper(resourceLocator);
}

function initEmergencyNetworkRestore(resourceLocator) {
    'use strict';
    return require('../network_tools/emergencyNetworkRestore').factory(resourceLocator);
}

function initExternalProcessesManager(domotzApp) {
    /**
     * For now the algorithm is very simple.
     * If openwrt only 10 executors, otherwise 100.
     */
    var cpus = process.env.DPLATFORM === 'openwrt' ? 10 : 100;
    console.debug('%s - Creating external processes executor: %d cpus', MODULE, cpus);
    var Queue = require('../external_processes/queue');
    var cpu = require('../external_processes/cpu').factory(lodash, childProcess, Queue, cpus, domotzApp);
    return require('../external_processes/proc').factory(q, fs, childProcess, cpu, domotzApp);
}

function getHostInterfaces(procManager, fileManager, resourceLocator) {
    var networkInterfaces,
        customInterfaces = require('../discovery/host/custom').factory(resourceLocator);
    var netUtilsPath = path.join(process.env.DOMOTZ_BIN_DIR, 'domotz_network_utils');
    var v2 = fileManager.getFileStats(netUtilsPath);
    var platform = os.platform();
    if (!v2) {
        var nic = require('../discovery/host/nic').factory(util, platform);
        networkInterfaces = require('../discovery/host/interfaces').factory(q, procManager, nic);
    }
    console.debug('%s - Recovering host network interfaces with %s tools. Platform ==> %s', MODULE, v2 ? 'domotz' : 'local', platform);
    return require('../discovery/host').factory(networkInterfaces, customInterfaces, resourceLocator);
}

function getAmqpListener(resourceLocator) {
    var amqpHandler = require('../amqp/handler').factory(resourceLocator);
    var amqpConnection = require('../amqp/connection').factory(resourceLocator);
    var amqpConsumer = require('../amqp/consumer').factory(amqpHandler, resourceLocator);
    console.debug('%s - Initializing AMQP listener', MODULE);
    return require('../amqp/listener').factory(amqpConnection, amqpConsumer, resourceLocator);
}

function initAvahiResolver(proc, engineRequest, devicesInfo) {
    console.debug('%s - Initializing avahi resolver', MODULE);
    var avahiCommands = require('../discovery/avahi/commands').factory();
    return require('../discovery/avahi/resolve').factory(engineRequest, devicesInfo, avahiCommands, proc);
}

function prepareNmapTranslator() {
    return require('../discovery/nmap/xml2js').factory(q, xml2js);
}

function setupPortDiscovery(resourceLocator) {
    return require('../discovery/ports/scan').factory(resourceLocator, require('../discovery/ports/tcp/utils'));
}

function setupUDPPortDiscovery(resourceLocator) {
    return require('../discovery/ports/scan').factory(resourceLocator, require('../discovery/ports/udp/utils'));
}

function setupTcpServicesMonitoring(resourcesLocator) {
    var tcpServicesParser = require('../discovery/tcp_services/parser');
    return require('../discovery/tcp_services/tcp_monitor').factory(resourcesLocator, tcpServicesParser);
}

function setupDiscoveryUtils(interfacesBindingStorage, devicesInfo) {
    return require('../discovery/utils').factory(interfacesBindingStorage, devicesInfo);
}

function setupProtocolsDiscoveryOrchestrator(domotzApp) {
    return require('../discovery/protocols/protocols_discovery_orchestrator').factory(domotzApp, domotzApp.discoverySenderFactory);
}

function setupBonjourDiscovery(domotzApp) {
    console.debug('%s - Starting Bonjour Server', MODULE);
    return require('../discovery/bonjour/bonjour_discovery').factory(domotzApp);
}

function setupUpnpDeviceDiscovery(resourceLocator) {
    var messageBuilder = require('../discovery/upnp/message').factory(resourceLocator);
    var responseParser = require('../discovery/upnp/parser').factory(resourceLocator, messageBuilder);
    var deferredRequestHandler = require('../discovery/upnp/deferred_request').factory(resourceLocator, messageBuilder);
    return require('../discovery/upnp/upnp_discovery').factory(resourceLocator, messageBuilder, responseParser, deferredRequestHandler);
}

function setupSnmpCheckStatusDiscovery(resourceLocator) {
    var commandBuilder = require('../discovery/snmp/command_builder').factory(resourceLocator);
    var snmpGetterFactory = require('../commands/snmp/get.js').command;
    return require('../discovery/snmp/snmp_check_status_discovery').factory(resourceLocator, commandBuilder, snmpGetterFactory);
}

function setupSnmpBasicDiscovery(resourceLocator) {
    var commandBuilder = require('../discovery/snmp/command_builder').factory(resourceLocator);
    var responseRendering = require('../discovery/snmp/response_processing').renderSnmpBasicData;
    var snmpGetterFactory;
    if (resourceLocator.settingsManager.useSnmpBasicDiscoveryGetChunked()) {
        snmpGetterFactory = require('../commands/snmp/getChunked.js').command;
    } else {
        snmpGetterFactory = require('../commands/snmp/get.js').command;
    }
    return require('../discovery/snmp/snmp_basic_discovery').factory(resourceLocator, commandBuilder, responseRendering, snmpGetterFactory);
}

function setupSnmpCustomDiscovery(resourceLocator) {
    var commandBuilder = require('../discovery/snmp/command_builder').factory(resourceLocator);
    var responseRendering = require('../discovery/snmp/response_processing').renderSnmpBasicData;
    var snmpGetterFactory = require('../commands/snmp/getChunked.js').command;
    return require('../discovery/snmp/snmp_custom_discovery').factory(resourceLocator, commandBuilder, responseRendering, snmpGetterFactory);
}

function setupSnmpOverlayDiscovery(resourceLocator) {
    var snmpGetterFactory;
    if (resourceLocator.settingsManager.useSnmpOverlayDiscoveryGetChunked()) {
        snmpGetterFactory = require('../commands/snmp/getChunked.js').command;
    } else {
        snmpGetterFactory = require('../commands/snmp/get.js').command;
    }

    var snmpSubtreeFactory = require('../commands/snmp/subtrees.js').command;

    return require('../discovery/snmp/snmp_overlay_discovery').factory(resourceLocator, snmpGetterFactory, snmpSubtreeFactory);
}

function setupSnmpMibDiscovery(resourceLocator) {
    var snmpGetterFactory = require('../commands/snmp/next.js').command;
    return require('../discovery/snmp/snmp_mib_discovery').factory(resourceLocator, snmpGetterFactory);
}

function setupSnmpOverlayDB(resourceLocator) {
    return require('../discovery/snmp/snmp_overlay_db').factory(resourceLocator);
}

function setupSnmpOverlayDeviceDB(resourceLocator) {
    return require('../discovery/snmp/snmp_overlay_device_db').factory(resourceLocator);
}

function setupSnmpInterfaceDiscovery(resourceLocator) {
    var commandBuilder = require('../discovery/snmp/command_builder').factory(resourceLocator);
    var responseRendering = require('../discovery/snmp/response_processing').renderSnmpInterfaceData;
    var snmpSubtreeFactory = require('../commands/snmp/subtrees.js').command;

    return require('../discovery/snmp/snmp_interface_discovery').factory(resourceLocator, commandBuilder, responseRendering, snmpSubtreeFactory);
}

function setupDhcpDiscovery(engineRequest, resourceLocator, logger) {
    logger.debug('%s - Initialize DHCP server', MODULE);
    try {
        return require('../discovery/dhcp/dhcp_discovery').factory(dhcpjs, random, resourceLocator);
    } catch (e) {
        logger.error('%s - Error running DHCP server, this discovery will be disabled', MODULE);
        return null;
    }
}

function setPeriodicalTasks(status, eventHandler, configuration, resourceLocator) {
    return require('../events/cron').factory(time, status, eventHandler, configuration, random, resourceLocator);
}

function initAPIClient(resourceLocator, endpoint) {
    console.info('%s - Creating "%s" api client.', MODULE, endpoint);
    return require('../api_client/engineRequest').factory(resourceLocator, endpoint);
}

function initEvents(events, domotzApp) {
    console.debug('%s - Creating Domotz Event Emitter', MODULE);
    return require('../events/eventHandler').factory(events, domotzApp);
}

function initDevicesCache(engineRequest, configuration) {
    console.debug('%s - Creating devices cache', MODULE);
    return require('../devices/info').factory(q, async, time, engineRequest, configuration);
}

function createWebapp(status, configuration, eventHandler, domotzApp) {
    console.debug('%s - Creating local web server', MODULE);
    var routes;
    if (process.env.BOX_REGISTRATION_OUTCOME !== 'failure') {
        routes = require('../http/routes/index').create(express, status, configuration, domotzApp);
    }
    return require('../http/app').createApp(fs, http, express, eventHandler, bodyParser, favicon, path, routes, domotzApp);
}

function createWsServer(domotzApp) {
    return require('../network_tools/wsServer').wsServer(domotzApp);
}

function setSignalHandlers(proc, log, status, domotzApp) {
    require('../setup/signals').setHandler(proc, log, status, domotzApp);
}

function initAgentEntity(resourceLocator) {
    return require('../api_client/entities/agent').factory(random, resourceLocator);
}

function initNotConfiguredAgentEntity(domotzApp, pkgJson) {
    return require('../api_client/entities/notConfiguredAgent').factory(domotzApp, pkgJson);
}

function initActivationTokenEntity(domotzApp, host, registerRequest) {
    return require('../api_client/entities/activationToken').factory(domotzApp, host, registerRequest);
}

function initEventEntity(engineRequest, resourceLocator) {
    return require('../api_client/entities/event').factory(engineRequest, resourceLocator);
}

function initSocketListener() {
    var requestHandler = require('../http/socketHandler');
    return require('../http/socketListener').socketListener(http, fs, requestHandler);
}

function setupUpnpRegistry(deepEqual) {
    return require('../upnp/upnpRegistry').registry(deepEqual);
}

function getNetInfoModule(resourceLocator) {
    var parser = require('../network_tools/netinfo_utils');
    return require('../network_tools/netinfo').factory(resourceLocator, parser);
}

function initUpnpEventHandler() {
    return require('../upnp/upnpEventHandler');
}

function setupMtrTool(resourceLocator) {
    return require('../network_tools/mtr').factory(dataStructure, resourceLocator);
}

function initUdpListener(request, resourceLocator) {
    return require('../udp/listener').factory(crypto, dgram, request, resourceLocator);
}

function getUdpUtils(resourceLocator) {
    return require('../udp/utils').factory(dgram, resourceLocator);
}

function initSshSendFactory(sshTool) {
    console.debug('%s - Initializing ssh Send driver', MODULE);
    return require('../commands/ssh/sshSendFactory').factory(async, q, sshTool, lodash);
}

function getSshTool(proc, file, resourceLocator) {
    console.debug('%s - Initialize ssh interface', MODULE);
    if (process.env.DPLATFORM === 'win') {
        return require('../network_tools/sshNode').factory(resourceLocator);
    } else {
        return require('../network_tools/ssh').factory(proc, file, resourceLocator);
    }
}

function getScpTool(file, q, childProcess, platform, log) {
    console.debug('%s - Initialize scp interface', MODULE);
    return require('../network_tools/scp').factory(file, childProcess, q, platform, log);
}

function initJamDriver(engineRequest, procManager, log, platform, interfacesBindingStorage) {
    console.debug('%s - Initializing Jam Driver', MODULE);
    if (process.env.DPLATFORM === 'luxul' && (process.env.DARCHITECTURE === 'bcm53xx' || process.env.DARCHITECTURE === 'octeon')) {
        console.debug('%s - Using Luxul Jam Driver', MODULE);
        return require('../network_tools/luxulJamDevices').jamDriver(engineRequest, path, q, log);
    } else if (platform.isNetgearRouter()) {
        return require('../network_tools/netgearRouter/netgearJamDevices').jamDriver(engineRequest, path, q, log, interfacesBindingStorage);
    } else {
        console.debug('%s - Using Fing Jam Driver', MODULE);
        return require('../network_tools/fingJamDevices').fingWrapper(childProcess, engineRequest, procManager, q, log);
    }
}

function setupNdtServersFinder(resourceLocator) {
    var distanceCalculator = require('../network_tools/speed_test/earthDistance').distanceCalculator(resourceLocator);
    return require('../network_tools/speed_test/ndtServers').factory(resourceLocator, distanceCalculator);
}

function setupSpeedTestTool(proc, configuration, mlabSpeedTest, domotzApp) {
    return require('../network_tools/speed_test/speedTest').factory(lodash, proc, dataStructure, number, configuration, mlabSpeedTest, domotzApp);
}

function setupIpConflictDetection(resourceLocator) {
    return require('../network_tools/ip_conflict/detection').factory(resourceLocator);
}

function setupDHCPRequestCounters(resourceLocator) {
    var dhcpFactory = require('../modules/dhcpRequestsCounters').factory(resourceLocator);
    dhcpFactory.loadFromFS();
    return dhcpFactory;
}

function setupMlabSpeedTestTool(proc, fileManager, log) {
    return require('../network_tools/speed_test/mlabSpeedTest').factory(q, path, proc, fileManager, log);
}

function setupNdt7SpeedTestTool(proc, platform, fileManager, log) {
    return require('../network_tools/speed_test/ndt7SpeedTest').factory(q, platform, path, proc, fileManager, log);
}

function initDiscoveryCoordinator(
    proc,
    hostInfo,
    eventHandler,
    nmapCommands,
    nmapXml2Js,
    interfacesBindingStorage,
    engineRequest,
    configuration,
    settingsManager,
    nmapBlackList,
    log,
    discoveryCounter,
    diagnostic,
    telemetry,
    utils,
    ip,
    domotzApp
) {
    'use strict';
    var ipDiscoveryParser = require('../discovery/ip_network/discovery_parser').factory(interfacesBindingStorage, hostInfo, domotzApp);
    var bindingDiscoveryFactory = require('../discovery/ip_network/bind_discovery').BindDiscoveryFactory(
        nmapCommands,
        nmapXml2Js,
        ipDiscoveryParser,
        domotzApp
    );
    var discoveryRetry = require('../discovery/ip_network/discovery_retry').factory(
        q,
        hostInfo,
        log,
        configuration,
        nmapBlackList,
        interfacesBindingStorage,
        async,
        lodash,
        bindingDiscoveryFactory,
        nmapCommands,
        ip,
        domotzApp.utils.ip
    );
    var engineReportingStrategy = require('../discovery/ip_network/engine_report_strategy').engineIpDiscoveryReportStrategyFactory(domotzApp);
    console.debug('%s - Creating device discovery coordinator', MODULE);
    return require('../discovery/ip_network/discovery_coordinator').factory(
        eventHandler,
        bindingDiscoveryFactory,
        interfacesBindingStorage,
        engineReportingStrategy,
        discoveryRetry,
        hostInfo,
        log,
        diagnostic,
        telemetry,
        utils,
        settingsManager,
        domotzApp
    );
}

function getNmapCommands(configuration, resourceLocator) {
    return require('../discovery/nmap/commands').factory(ip, configuration, resourceLocator);
}

function initBindingsCache(fileManager, engineRequest, hostInfo, resourceLocator) {
    var deviceMap = path.join(process.env.DOMOTZ_CONF_DIR, 'device_map.conf');
    console.debug('%s - Initializing discovery cache for < MAC : IP > bindings. File for custom mappping: %s', MODULE, deviceMap);
    return require('../discovery/ip_network/interfaces_binding').factory(q, util, fileManager, engineRequest, hostInfo, deviceMap, resourceLocator);
}

function setupOoklaServerFinder(domotzApp) {
    return require('../network_tools/speed_test/ooklaServers').factory(domotzApp);
}

function setupOoklaSpeedTestTool(domotzApp) {
    return require('../network_tools/speed_test/ooklaSpeedTest').factory(domotzApp);
}

function setupConnectivityChecker(domotzApp) {
    return require('../network_tools/connectivity').factory(domotzApp);
}

function setupNetworkManager(procManager, fileManager, resourceLocator) {
    return require('../network_tools/networkManager').factory(procManager, fileManager, resourceLocator);
}

function initUpnpSubscriptionManager(domotzApp) {
    return require('../upnp/upnpSubscriptionsManager').factory(domotzApp);
}

function createUpnpServer(domotzApp) {
    console.debug('%s - Creating old UPNP server for power plug management', MODULE);
    return require('../upnp/upnpHttpServer').httpServer(domotzApp);
}

function setupSettingsManager(domotzApp) {
    return require('../setup/agentSettings').settingsManager(domotzApp);
}

function setupSentryManager(domotzApp) {
    var factory = require('../utils/diagnostic/sentryManager').factory(domotzApp);
    factory.initializeSentry();
    return factory;
}

module.exports.create = function (customLogger, forcedStatus, onSuccess, onFailure) {
    require('../utils/polyfills').load();

    var domotzApp = {};

    // Npm Modules (for command or events that needs stuff at runtime)
    domotzApp.async = async;
    domotzApp.bonjour = bonjour;
    domotzApp.crypto = crypto;
    domotzApp.dhcpjs = dhcpjs;
    domotzApp.events = events;
    domotzApp.fs = fs;
    domotzApp.http = http;
    domotzApp.ip = ip;
    domotzApp.lodash = lodash;
    domotzApp.moment = moment;
    domotzApp.natUpnp = natUpnp;
    domotzApp.netSnmp = netSnmp;
    domotzApp.os = os;
    domotzApp.snmpNative = snmpNative;
    domotzApp.net = net;
    domotzApp.path = path;
    domotzApp.q = q;
    domotzApp.request = request;
    domotzApp.telnet = telnet;
    domotzApp.tftp = tftp;
    domotzApp.step = step;
    domotzApp.stringify = require('../utils/no_passwd_stringify').stringify;
    domotzApp.ssh2 = ssh2;
    domotzApp.ssdp = ssdp;
    domotzApp.url = url;
    domotzApp.util = util;
    domotzApp.xml2js = xml2js;
    domotzApp.xml2jsProcessor = xml2jsProcessor;
    domotzApp.ws = ws;
    domotzApp.whois = whois;
    domotzApp.amqplib = amqplib;
    domotzApp.winston = winston;
    domotzApp.sentry = sentry;
    domotzApp.zlib = zlib;

    try {
        domotzApp.netPing = require('net-ping');
    } catch (err) {
        console.debug('%s - net-ping module not available', MODULE);
        domotzApp.netPing = null;
    }

    console.debug('%s - Imported external dependencies', MODULE);

    // Utils
    var fileManager = initFileManager();

    domotzApp.utils = {
        childProcess: childProcess,
        random: random,
        file: fileManager,
        mutex: mutex,
        scheduler: scheduler,
        web: web,
        time: time,
        command: command,
        number: number,
        dataStructure: dataStructure,
        modules: modules,
        platform: domotzPlatform,
        firmware: firmware,
        uuid4: require('../utils/uuid').uuid4,
        stalledProcessesKiller: require('../events/handler/processCleaner'),
        ip: require('../utils/ip').factory(domotzApp),
    };

    // Agent Configuration
    var configurator = getHubConfigurator(domotzApp);
    var configuration = configurator.loadConfiguration();
    domotzApp.configurator = configurator;
    domotzApp.configuration = configuration;

    var domotzLog = initLog(domotzApp);
    domotzApp.log = customLogger || domotzLog;

    var myConsole = domotzApp.log.decorateLogs();

    var procManager = initExternalProcessesManager(domotzApp);
    var cacheUtils = getCacheUtils(procManager);
    domotzApp.utils.proc = procManager;
    domotzApp.utils.cache = cacheUtils;

    // Status Manager
    var status = initStatusManager(configuration, myConsole);

    // Internal Web Server
    if (process.env.BOX_REGISTRATION_OUTCOME === 'failure') {
        domotzApp.webapp = createWebapp(status, configuration, undefined, domotzApp);
        return domotzApp;
    }

    domotzApp.status = status;
    if (forcedStatus) {
        domotzApp.status.set(forcedStatus);
    }

    domotzApp.xml2Js = prepareNmapTranslator(q, xml2js);
    // NetworkTools
    domotzApp.networkTools = {
        dns: dns,
        netmask: netmask,
    };

    // Host Information
    var host = getHostInterfaces(procManager, fileManager, domotzApp);

    return host
        .recoverHostInfoWithRetry()
        .then(function () {
            return domotzPlatform.loadSSHInfo(myConsole);
        })
        .then(function () {
            domotzApp.DHCPRequestCounters = setupDHCPRequestCounters(domotzApp);

            domotzApp.discovery = {
                host: host,
                accumulator: require('../discovery/accumulator').factory(domotzApp),
            };

            // API Clients. For OpenAPI limit the number of Sockets
            http.globalAgent.maxSockets = 100;
            domotzApp.httpOutCache = require('../api_client/httpOutCache.js').httpOutCache(domotzApp);

            var registerRequest = initAPIClient(domotzApp, 'register');
            var userRequest = initAPIClient(domotzApp, 'user');
            var engineRequest = status.isConfigured() || status.isPassive() ? initAPIClient(domotzApp, 'agent') : null;
            domotzApp.registerRequest = registerRequest;
            domotzApp.userRequest = userRequest;
            domotzApp.engineRequest = engineRequest;
            domotzApp.snmpv3Supported = snmpv3Supported;

            // Entities
            var eventEntity = initEventEntity(engineRequest, domotzApp);

            domotzApp.configurationUpdater = require('../setup/configurationUpdater').init(domotzApp);

            domotzApp.entities = {
                agent: initAgentEntity(domotzApp),
                notConfiguredAgent: initNotConfiguredAgentEntity(domotzApp, pkgJson),
                activationToken: initActivationTokenEntity(domotzApp, host, registerRequest),
                event: eventEntity,
            };

            http.globalAgent.maxSockets = Infinity;

            // Events Management
            var eventHandler = initEvents(events, domotzApp);
            domotzApp.event = eventHandler;

            setSignalHandlers(procManager, domotzLog, status, domotzApp);

            // Package Management
            domotzApp.pkg = {
                json: pkgJson,
            };

            domotzApp.interfacesBindingStorage = null;

            if (status.isConfigured() || status.isPassive()) {
                // Device Utilities
                domotzApp.devices = {
                    info: initDevicesCache(engineRequest, configuration),
                };

                domotzApp.settingsManager = setupSettingsManager(domotzApp);
                domotzApp.settingsManager.loadSettings();

                domotzApp.utils.errorCounter = require('../utils/diagnostic/errorCounter').factory(domotzApp);
                if (domotzApp.sentry) {
                    domotzApp.utils.sentryManager = setupSentryManager(domotzApp);
                }

                // IP Discovery - Bindings Cache
                domotzApp.interfacesBindingStorage = initBindingsCache(fileManager, engineRequest, host, domotzApp);
            }

            // Web Server
            domotzApp.webapp = createWebapp(status, configuration, eventHandler, domotzApp);

            domotzApp.distanceCalculator = require('../network_tools/speed_test/earthDistance').distanceCalculator(domotzApp);

            domotzApp.utils.ipWrapper = initIpWrapper(domotzApp);
            domotzApp.emergencyNetworkRestore = initEmergencyNetworkRestore(domotzApp);

            // Write pid file since luxul hasn't got the forever process manager
            if (process.env.DPLATFORM === 'luxul' && process.env.LISTENER_PID_FILE) {
                try {
                    fs.writeFileSync(process.env.LISTENER_PID_FILE, process.pid);
                } catch (e) {
                    myConsole.error('Error writing pid file');
                }
            }

            domotzApp.winrm = require('../winrm').factory(domotzApp);

            if (status.isConfigured() || status.isPassive()) {
                domotzApp.discovery.utils = setupDiscoveryUtils(domotzApp.interfacesBindingStorage, domotzApp.devices.info);
                domotzApp.nmapBlackList = require('../discovery/nmap/blackList').factory(
                    fileManager,
                    configuration,
                    domotzApp.interfacesBindingStorage
                );
                var sshTool = getSshTool(procManager, fileManager, domotzApp);

                // Amqp manager
                domotzApp.amqpListener = getAmqpListener(domotzApp);

                //// Engine Clients
                domotzApp.heartbeatRequest = initAPIClient(domotzApp, 'agent-heartbeat');

                domotzApp.onvif = require('../net/onvif/onvif');

                domotzApp.networkTools.ipConflictDetection = setupIpConflictDetection(domotzApp);

                // SNMP Utilities
                domotzApp.snmpCommon = initSnmpCommon(domotzApp.settingsManager, domotzLog);
                domotzApp.snmpCommandBuilder = require('../discovery/snmp/command_builder').factory(domotzApp);
                domotzApp.snmpGetNative = snmpGetNative.command;
                domotzApp.snmpInterfacesNumberStorage = require('../discovery/snmp/port_number_storage').storage;
                domotzApp.snmpCommunitiesProvider = require('../discovery/snmp/communities').communitiesProviderFactory(domotzApp);

                domotzApp.periodicalTasks = setPeriodicalTasks(status, eventHandler, configuration, domotzApp);

                domotzApp.diagnostic = require('../utils/diagnostic').diagnostic(domotzApp);

                domotzApp.telemetry = require('../utils/telemetry').telemetry(domotzApp);

                // Discovery Engine
                domotzApp.discovery.counter = require('../discovery/ip_network/discovery_counter').discoveryCounter(domotzApp);
                var nmapCommands = getNmapCommands(configuration, domotzApp);
                domotzApp.discoverySenderFactory = require('../discovery/protocols/discovery_sender').factory;

                domotzApp.discovery.avahi = initAvahiResolver(procManager, engineRequest, domotzApp.devices.info);
                domotzApp.discovery.port = setupPortDiscovery(domotzApp, domotzApp.xml2Js, domotzApp.interfacesBindingStorage, nmapCommands);
                domotzApp.discovery.udp_port = setupUDPPortDiscovery(domotzApp, domotzApp.xml2Js, domotzApp.interfacesBindingStorage, nmapCommands);

                domotzApp.discovery.ip_network = {
                    discoveryCoordinator: initDiscoveryCoordinator(
                        procManager,
                        host,
                        eventHandler,
                        nmapCommands,
                        domotzApp.xml2Js,
                        domotzApp.interfacesBindingStorage,
                        engineRequest,
                        configuration,
                        domotzApp.settingsManager,
                        domotzApp.nmapBlackList,
                        domotzApp.log,
                        domotzApp.discovery.counter,
                        domotzApp.diagnostic,
                        domotzApp.telemetry,
                        domotzApp.utils,
                        domotzApp.ip,
                        domotzApp
                    ),
                };
                domotzApp.discovery.serviceFilter = require('../discovery/service_filter').service_filter(domotzApp);
                domotzApp.discovery.bigNetworkScanner = require('../discovery/ip_network/big_network').BigNetworkScannerFactory(domotzApp);
                domotzApp.discovery.dhcp_discovery = setupDhcpDiscovery(engineRequest, domotzApp, myConsole);
                domotzApp.discovery.bonjour_discovery = setupBonjourDiscovery(domotzApp);
                domotzApp.discovery.bonjourListener = require('../discovery/bonjour_2').factory(domotzApp);
                domotzApp.discovery.upnp_device_discovery = setupUpnpDeviceDiscovery(domotzApp);
                domotzApp.discovery.upnp_igd_discovery = require('../discovery/upnp/igd_discovery').factory(domotzApp, engineRequest);
                domotzApp.discovery.snmp_check_status_discovery = setupSnmpCheckStatusDiscovery(domotzApp);
                domotzApp.discovery.snmp_basic_discovery = setupSnmpBasicDiscovery(domotzApp);
                domotzApp.discovery.snmp_custom_discovery = setupSnmpCustomDiscovery(domotzApp);
                domotzApp.discovery.snmp_mib_discovery = setupSnmpMibDiscovery(domotzApp);
                domotzApp.discovery.snmp_overlay_db = setupSnmpOverlayDB(domotzApp);
                domotzApp.discovery.snmp_overlay_device_db = setupSnmpOverlayDeviceDB(domotzApp);
                domotzApp.discovery.snmp_overlay_discovery = setupSnmpOverlayDiscovery(domotzApp);
                domotzApp.discovery.snmp_interface_discovery = setupSnmpInterfaceDiscovery(domotzApp);
                domotzApp.discovery.protocols_orchestrator = setupProtocolsDiscoveryOrchestrator(domotzApp);
                domotzApp.discovery.onvifDiscovery = require('../discovery/onvif/onvif_discovery').factory(domotzApp);
                domotzApp.discovery.netbios = {
                    discovery: require('../discovery/netbios/execute').factory(domotzApp),
                    parse: require('../discovery/netbios/parse').factory(q, domotzApp.xml2Js, domotzApp),
                };
                var discoveryOsModule = require('../discovery/os/data');
                domotzApp.discovery.os = {
                    data: {
                        inspectionManager: discoveryOsModule.inspectionManagerFactory(domotzApp),
                    },
                };

                // Socket Http Server
                domotzApp.socketListener = initSocketListener(eventHandler);

                // Net Tools
                domotzApp.networkTools.netInfo = getNetInfoModule(domotzApp, host);
                domotzApp.networkTools.mtr = setupMtrTool(domotzApp);
                domotzApp.networkTools.ndtServers = setupNdtServersFinder(domotzApp);
                domotzApp.networkTools.ooklaServers = setupOoklaServerFinder(domotzApp);
                domotzApp.networkTools.ooklaSpeedTest = setupOoklaSpeedTestTool(domotzApp);
                var mlabSpeedTest = setupMlabSpeedTestTool(procManager, fileManager, domotzApp.log);
                domotzApp.networkTools.mlabSpeedTest = mlabSpeedTest;
                domotzApp.networkTools.ndt7SpeedTest = setupNdt7SpeedTestTool(procManager, domotzApp.utils.platform, fileManager, domotzApp.log);
                domotzApp.networkTools.fast = require('../network_tools/speed_test/fast');
                domotzApp.networkTools.fastSpeedTest = require('../network_tools/speed_test/fastSpeedTest').factory(domotzApp);
                domotzApp.networkTools.openvpn = require('../commands/generateOpenvpn').factory(
                    path,
                    procManager,
                    domotzApp.log,
                    fileManager,
                    q,
                    domotzApp.utils.platform
                );
                domotzApp.networkTools.openvpn
                    .getVersion()
                    .then(function () {
                        myConsole.info('OPENPVPN Version is available, starting configuration');
                        domotzApp.networkTools.openvpn.startConfiguration();
                    })
                    .catch(function () {
                        myConsole.info('OPENPVPN Version is not available');
                    });

                domotzApp.networkTools.speedTest = setupSpeedTestTool(procManager, configuration, mlabSpeedTest, domotzApp);
                domotzApp.networkTools.internetConnectionStatus = setupConnectivityChecker(domotzApp);
                domotzApp.networkTools.ssh = require('../network_tools/ssh').factory(procManager, fileManager, domotzApp);
                domotzApp.networkTools.scp = getScpTool(fileManager, q, domotzApp.utils.childProcess, domotzApp.utils.platform, domotzApp.log);
                domotzApp.networkTools.sshNode = require('../network_tools/sshNode').factory(domotzApp);
                domotzApp.networkTools.scpFactory = require('../commands/scp/scpFactory').factory(domotzApp.networkTools.scp);
                domotzApp.networkTools.systemSSH = require('../network_tools/sshSystemShellSequence').factory(domotzApp);
                domotzApp.networkTools.networkManager = setupNetworkManager(domotzApp);
                domotzApp.networkTools.nmapCommands = nmapCommands;
                domotzApp.networkTools.rtdProcessor = require('../network_tools/rtd').rtdProcessor(domotzApp);
                domotzApp.networkTools.rtd = require('../network_tools/rtd').rtdScan(domotzApp);
                domotzApp.networkTools.rtd.loadFromFS();
                domotzApp.networkTools.tftpServer = require('../network_tools/tftp').server(domotzApp);

                // TCP Services monitoring
                domotzApp.discovery.tcp_services_monitoring = setupTcpServicesMonitoring(domotzApp);

                // SSH
                domotzApp.sshSendFactory = initSshSendFactory(sshTool);

                // Http command interface
                domotzApp.commandHttpRequest = commandHttpRequest;

                // Upnp Server
                domotzApp.upnp = {
                    registry: setupUpnpRegistry(deepEqual),
                    eventHandler: initUpnpEventHandler(),
                    subscriptionsManager: initUpnpSubscriptionManager(domotzApp),
                    httpServer: createUpnpServer(domotzApp),
                };

                // Udp Listener
                domotzApp.udp = {
                    utils: getUdpUtils(domotzApp),
                    listener: initUdpListener(request, domotzApp),
                };

                // Jam Driver
                domotzApp.jamDriver = initJamDriver(
                    engineRequest,
                    procManager,
                    domotzApp.log,
                    domotzApp.utils.platform,
                    domotzApp.interfacesBindingStorage
                );

                // Self check
                domotzApp.stallWatcher = require('../external_processes/stallWatcher').init(domotzApp);

                // Local modules (e.g. Fing, Mlab)
                domotzApp.availableModules = {};

                // Sandbox Javascript runner
                domotzApp.sandboxRunner = function (data, cid, onError, onSuccess) {
                    return require('../sandbox/runner').sandboxRunner(data, domotzApp, cid, onError, onSuccess);
                };

                domotzApp.latencyMeasurement = require('../network_tools/latency/speedTest').speedTestLatency(domotzApp);
            } else {
                // Periodic Tasks
                domotzApp.periodicalTasks = setPeriodicalTasks(status, eventHandler, configuration, domotzApp);
                myConsole.warn('%s - Agent is not configured (invalid or absent conf file). Running in restricted mode', MODULE);
            }

            // Web Server
            domotzApp.webapp = createWebapp(status, configuration, eventHandler, domotzApp);

            // Web Sockets server
            domotzApp.wsServer = createWsServer(domotzApp);

            var i = 0;
            for (var property in domotzApp) {
                if (domotzApp.hasOwnProperty(property)) {
                    myConsole.verbose('%s -   --> %s;', MODULE, property);
                    i++;
                }
            }
            myConsole.info('%s - Domotz Application initialization completed. %d modules loaded', MODULE, i);
            onSuccess(domotzApp);
        })
        .catch(onFailure);
};