File indexing completed on 2024-04-21 14:46:03

 /*
     SPDX-FileCopyrightText: 2012 Jasem Mutlaq <mutlaqja@ikarustech.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "drivermanager.h"
 
 #include "config-kstars.h"
 
 #include "clientmanager.h"
 #include "driverinfo.h"
 #include "guimanager.h"
 #include "indilistener.h"
 #include "kspaths.h"
 #include "kstars.h"
 #include "indidbus.h"
 #include "kstarsdata.h"
 #include "Options.h"
 #include "servermanager.h"
 #include "ui_indihostconf.h"
 #include "auxiliary/ksnotification.h"
 
 #include <basedevice.h>
 
 #ifndef KSTARS_LITE
 #include <KMessageBox>
 #include <KActionCollection>
 #include <KNotifications/KNotification>
 #endif
 
 #include <QTcpServer>
 #include <QtConcurrent>
 #include <indi_debug.h>
 
 #define INDI_MAX_TRIES 2
 #define ERRMSG_SIZE    1024
 
 DriverManagerUI::DriverManagerUI(QWidget *parent) : QFrame(parent)
 {
     setupUi(this);
 
     localTreeWidget->setSortingEnabled(false);
     localTreeWidget->setRootIsDecorated(true);
 
     clientTreeWidget->setSortingEnabled(false);
 
     runningPix = QIcon::fromTheme("system-run");
     stopPix    = QIcon::fromTheme("dialog-cancel");
     localMode  = QIcon::fromTheme("computer");
     serverMode = QIcon::fromTheme("network-server");
 
     connected    = QIcon::fromTheme("network-connect");
     disconnected = QIcon::fromTheme("network-disconnect");
 
     connect(localTreeWidget, &QTreeWidget::itemDoubleClicked, this,
             &DriverManagerUI::makePortEditable);
 }
 
 void DriverManagerUI::makePortEditable(QTreeWidgetItem *selectedItem, int column)
 {
     // If it's the port column, then make it user-editable
     if (column == ::DriverManager::LOCAL_PORT_COLUMN)
         selectedItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable |
                                Qt::ItemIsEnabled);
 
     localTreeWidget->editItem(selectedItem, ::DriverManager::LOCAL_PORT_COLUMN);
 }
 
 DriverManager *DriverManager::_DriverManager = nullptr;
 INDIDBus *DriverManager::_INDIDBus = nullptr;
 
 DriverManager *DriverManager::Instance()
 {
     if (_DriverManager == nullptr)
     {
         _DriverManager = new DriverManager(KStars::Instance());
         _INDIDBus = new INDIDBus(KStars::Instance());
 
         qRegisterMetaType<QSharedPointer<DriverInfo>>("QSharedPointer<DriverInfo>");
     }
 
     return _DriverManager;
 }
 
 void DriverManager::release()
 {
     delete (_DriverManager);
     delete (_INDIDBus);
     _DriverManager = nullptr;
     _INDIDBus = nullptr;
 }
 
 DriverManager::DriverManager(QWidget *parent) : QDialog(parent)
 {
 #ifdef Q_OS_OSX
     setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
 #endif
 
     currentPort = Options::serverPortStart() - 1;
 
     QVBoxLayout *mainLayout = new QVBoxLayout;
     ui                      = new DriverManagerUI(this);
     mainLayout->addWidget(ui);
     setLayout(mainLayout);
     setWindowTitle(i18nc("@title:window", "Device Manager"));
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &DriverManager::close);
 
     connect(ui->addB, &QPushButton::clicked, this, &DriverManager::addINDIHost);
     connect(ui->modifyB, &QPushButton::clicked, this, &DriverManager::modifyINDIHost);
     connect(ui->removeB, &QPushButton::clicked, this, &DriverManager::removeINDIHost);
 
     connect(ui->connectHostB, &QPushButton::clicked, this, &DriverManager::activateHostConnection);
     connect(ui->disconnectHostB, &QPushButton::clicked, this, &DriverManager::activateHostDisconnection);
     connect(ui->runServiceB, &QPushButton::clicked, this, &DriverManager::activateRunService);
     connect(ui->stopServiceB, &QPushButton::clicked, this, &DriverManager::activateStopService);
     connect(ui->localTreeWidget,  &QTreeWidget::itemClicked, this, &DriverManager::updateLocalTab);
     connect(ui->clientTreeWidget, &QTreeWidget::itemClicked, this, &DriverManager::updateClientTab);
     connect(ui->localTreeWidget, &QTreeWidget::expanded, this, &DriverManager::resizeDeviceColumn);
 
     // Do not use KSPaths here, this is for INDI
     if (Options::indiDriversDir().isEmpty())
         Options::setIndiDriversDir(
             QStandardPaths::locate(QStandardPaths::GenericDataLocation, "indi",
                                    QStandardPaths::LocateDirectory));
 
     readXMLDrivers();
 
     readINDIHosts();
 
     m_CustomDrivers = new CustomDrivers(this, driversList);
 
     updateCustomDrivers();
 
 #ifdef Q_OS_WIN
     ui->localTreeWidget->setEnabled(false);
 #endif
 }
 
 DriverManager::~DriverManager()
 {
     clearServers();
 }
 
 void DriverManager::processDeviceStatus(const QSharedPointer<DriverInfo> &driver)
 {
     if (driver.isNull() || driver->getDriverSource() == GENERATED_SOURCE)
         return;
 
     QString currentDriver;
     ServerMode mode        = connectionMode;
     ServerManager *manager = driver->getServerManager();
     bool dState            = false;
     bool cState            = false;
 
     if (driver->getDriverSource() != HOST_SOURCE)
     {
         if (ui->localTreeWidget->currentItem())
             currentDriver = ui->localTreeWidget->currentItem()->text(LOCAL_NAME_COLUMN);
 
         for (auto &item : ui->localTreeWidget->findItems(
                     driver->getLabel(), Qt::MatchExactly | Qt::MatchRecursive))
         {
             item->setText(LOCAL_VERSION_COLUMN, driver->getVersion());
 
             if (manager)
                 mode = manager->getMode();
 
             dState = driver->getServerState();
             cState = driver->getClientState() && dState;
 
             bool locallyAvailable = false;
             if (driver->getAuxInfo().contains("LOCALLY_AVAILABLE"))
                 locallyAvailable =
                     driver->getAuxInfo().value("LOCALLY_AVAILABLE", false).toBool();
 
             switch (mode)
             {
                 case SERVER_ONLY:
                     if (locallyAvailable)
                     {
                         ui->runServiceB->setEnabled(!dState);
                         ui->stopServiceB->setEnabled(dState);
                         item->setIcon(LOCAL_STATUS_COLUMN,
                                       dState ? ui->runningPix : ui->stopPix);
                     }
                     else
                     {
                         ui->runServiceB->setEnabled(false);
                         ui->stopServiceB->setEnabled(false);
                     }
 
                     if (dState)
                     {
                         item->setIcon(LOCAL_MODE_COLUMN, ui->serverMode);
                         if (manager)
                         {
                             item->setText(LOCAL_PORT_COLUMN, QString::number(manager->getPort()));
                         }
                     }
                     else
                     {
                         item->setIcon(LOCAL_MODE_COLUMN, QIcon());
                         item->setText(LOCAL_PORT_COLUMN, QString::number(driver->getUserPort()));
                     }
 
                     break;
 
                 case SERVER_CLIENT:
                     if (locallyAvailable)
                     {
                         ui->runServiceB->setEnabled(!cState);
                         ui->stopServiceB->setEnabled(cState);
                         item->setIcon(LOCAL_STATUS_COLUMN,
                                       cState ? ui->runningPix : ui->stopPix);
                     }
                     else
                     {
                         ui->runServiceB->setEnabled(false);
                         ui->stopServiceB->setEnabled(false);
                     }
 
                     if (cState)
                     {
                         item->setIcon(LOCAL_MODE_COLUMN, ui->localMode);
 
                         if (manager)
                         {
                             item->setText(LOCAL_PORT_COLUMN, QString::number(manager->getPort()));
                         }
                     }
                     else
                     {
                         item->setIcon(LOCAL_MODE_COLUMN, QIcon());
                         const auto port = driver->getUserPort() == -1 ? QString() : QString::number(driver->getUserPort());
                         item->setText(LOCAL_PORT_COLUMN, port);
                     }
 
                     break;
             }
 
             // Only update the log if the current driver is selected
             if (currentDriver == driver->getLabel())
             {
                 ui->serverLogText->clear();
                 ui->serverLogText->append(driver->getServerBuffer());
             }
         }
     }
     else
     {
         for (auto &item : ui->clientTreeWidget->findItems(driver->getName(), Qt::MatchExactly,
                 HOST_NAME_COLUMN))
         {
             if (driver->getClientState())
             {
                 item->setIcon(HOST_STATUS_COLUMN, ui->connected);
                 ui->connectHostB->setEnabled(false);
                 ui->disconnectHostB->setEnabled(true);
             }
             else
             {
                 item->setIcon(HOST_STATUS_COLUMN, ui->disconnected);
                 ui->connectHostB->setEnabled(true);
                 ui->disconnectHostB->setEnabled(false);
             }
         }
     }
 }
 
 void DriverManager::getUniqueHosts(const QList<QSharedPointer<DriverInfo>> &dList,
                                    QList<QList<QSharedPointer<DriverInfo>>> &uHosts)
 {
     bool found = false;
 
     // Iterate over all drivers
     for (auto &dv : dList)
     {
         QList<QSharedPointer<DriverInfo>> uList;
 
         // Let's see for drivers with identical hosts and ports
         for (auto &idv : dList)
         {
             // If we get a match between port and hostname, we add it to the list
             if ((dv->getHost() == idv->getHost() && dv->getPort() == idv->getPort()))
             {
                 // Check if running already
                 if (dv->getClientState() || dv->getServerState())
                 {
                     int ans = KMessageBox::warningContinueCancel(
                                   nullptr,
                                   i18n("Driver %1 is already running, do you want to restart it?",
                                        dv->getLabel()));
                     if (ans == KMessageBox::Cancel)
                         continue;
                     else
                     {
                         QList<QSharedPointer<DriverInfo>> stopList;
                         stopList.append(dv);
                         stopDevices(stopList);
                     }
                 }
 
                 found = false;
 
                 // Check to see if the driver already been added elsewhere
                 for (auto &qdi : uHosts)
                 {
                     for (QSharedPointer<DriverInfo>di : qdi)
                     {
                         if (di == idv)
                         {
                             found = true;
                             break;
                         }
                     }
                 }
 
                 if (found == false)
                     uList.append(idv);
             }
         }
 
         if (uList.empty() == false)
             uHosts.append(uList);
     }
 }
 
 void DriverManager::startDevices(const QList<QSharedPointer<DriverInfo>> &dList)
 {
     ServerManager *serverManager = nullptr;
     int port = -1;
 
     QList<QList<QSharedPointer<DriverInfo>>> uHosts;
     getUniqueHosts(dList, uHosts);
 
     qCDebug(KSTARS_INDI) << "INDI: Starting local drivers...";
 
     for (auto &qdv : uHosts)
     {
         if (qdv.empty())
             continue;
 
         port = qdv.at(0)->getPort();
         auto host = qdv.at(0)->getHost();
 
         // Select random port within range is none specified.
         if (port == -1)
             port = getINDIPort(port);
 
         if (port <= 0)
         {
             emit serverFailed(host, port, i18n("Cannot start INDI server: port error."));
             return;
         }
 
         serverManager = new ServerManager(host, port);
 
         if (serverManager == nullptr)
         {
             emit serverFailed(host, port, i18n("Failed to create local INDI server"));
             return;
         }
 
         servers.append(serverManager);
         serverManager->setPendingDrivers(qdv);
         serverManager->setMode(connectionMode);
 
         connect(serverManager, &ServerManager::newServerLog, this, &DriverManager::updateLocalTab, Qt::UniqueConnection);
         connect(serverManager, &ServerManager::started, this, &DriverManager::setServerStarted, Qt::UniqueConnection);
         connect(serverManager, &ServerManager::failed, this, &DriverManager::setServerFailed, Qt::UniqueConnection);
         connect(serverManager, &ServerManager::terminated, this, &DriverManager::setServerTerminated, Qt::UniqueConnection);
 
         serverManager->start();
     }
 }
 
 void DriverManager::startLocalDrivers(ServerManager *serverManager)
 {
     connect(serverManager, &ServerManager::driverStarted, this, &DriverManager::processDriverStartup, Qt::UniqueConnection);
     connect(serverManager, &ServerManager::driverFailed, this, &DriverManager::processDriverFailure, Qt::UniqueConnection);
     QtConcurrent::run(serverManager, &ServerManager::startDriver, serverManager->pendingDrivers().first());
 }
 
 void DriverManager::processDriverStartup(const QSharedPointer<DriverInfo> &driver)
 {
     emit driverStarted(driver);
 
     auto manager = driver->getServerManager();
     // Do we have more pending drivers?
     if (manager->pendingDrivers().count() > 0)
     {
         QtConcurrent::run(manager, &ServerManager::startDriver, manager->pendingDrivers().first());
         return;
     }
 
     // Nothing to do more if SERVER ONLY
     if (connectionMode == SERVER_ONLY)
     {
         return;
     }
 
     // Otherwise proceed to start Client Manager
     startClientManager(manager->managedDrivers(), manager->getHost(), manager->getPort());
 }
 
 void DriverManager::processDriverFailure(const QSharedPointer<DriverInfo> &driver, const QString &message)
 {
     emit driverFailed(driver, message);
 
     qCWarning(KSTARS_INDI) << "Driver" << driver->getName() << "failed to start. Retrying in 5 seconds...";
 
     QTimer::singleShot(5000, this, [driver]()
     {
         auto manager = driver->getServerManager();
         // Do we have more pending drivers?
         if (manager->pendingDrivers().count() > 0)
         {
             QtConcurrent::run(manager, &ServerManager::startDriver, manager->pendingDrivers().first());
             return;
         }
     });
 }
 
 void DriverManager::startClientManager(const QList<QSharedPointer<DriverInfo>> &qdv, const QString &host, int port)
 {
     auto clientManager = new ClientManager();
 
     for (auto &dv : qdv)
         clientManager->appendManagedDriver(dv);
 
     connect(clientManager, &ClientManager::started, this, &DriverManager::setClientStarted, Qt::UniqueConnection);
     connect(clientManager, &ClientManager::failed, this, &DriverManager::setClientFailed, Qt::UniqueConnection);
     connect(clientManager, &ClientManager::terminated, this, &DriverManager::setClientTerminated, Qt::UniqueConnection);
 
     clientManager->setServer(host.toLatin1().constData(), port);
 
     GUIManager::Instance()->addClient(clientManager);
     INDIListener::Instance()->addClient(clientManager);
 
     clientManager->establishConnection();
 }
 
 void DriverManager::stopDevices(const QList<QSharedPointer<DriverInfo>> &dList)
 {
     qCDebug(KSTARS_INDI) << "INDI: Stopping local drivers...";
 
     // #1 Disconnect all clients
     for (QSharedPointer<DriverInfo>dv : dList)
     {
         ClientManager *cm = dv->getClientManager();
 
         if (cm == nullptr)
             continue;
 
         cm->removeManagedDriver(dv);
 
         if (cm->count() == 0)
         {
             GUIManager::Instance()->removeClient(cm);
             INDIListener::Instance()->removeClient(cm);
             cm->disconnectServer();
             clients.removeOne(cm);
             cm->deleteLater();
 
             KStars::Instance()->slotSetTelescopeEnabled(false);
             KStars::Instance()->slotSetDomeEnabled(false);
         }
     }
 
     // #2 Disconnect all servers
     for (QSharedPointer<DriverInfo>dv : dList)
     {
         ServerManager *sm = dv->getServerManager();
 
         if (sm != nullptr)
         {
             sm->stopDriver(dv);
 
             if (sm->size() == 0)
             {
                 sm->stop();
                 servers.removeOne(sm);
                 sm->deleteLater();
             }
         }
     }
 
     // Reset current port
     currentPort = Options::serverPortStart() - 1;
 
     updateMenuActions();
 }
 
 void DriverManager::disconnectClients()
 {
     for (auto &clientManager : clients)
     {
         clientManager->disconnectAll();
         clientManager->disconnect();
     }
 }
 
 void DriverManager::clearServers()
 {
     for (auto &serverManager : servers)
         serverManager->stop();
 
     qDeleteAll(servers);
 }
 
 void DriverManager::activateRunService()
 {
     processLocalTree(true);
 }
 
 void DriverManager::activateStopService()
 {
     processLocalTree(false);
 }
 
 void DriverManager::activateHostConnection()
 {
     processRemoteTree(true);
 }
 
 void DriverManager::activateHostDisconnection()
 {
     processRemoteTree(false);
 }
 
 ClientManager *DriverManager::getClientManager(const QSharedPointer<DriverInfo> &driver)
 {
     auto cm = driver->getClientManager();
     if (cm)
         return cm;
     // If no client manager found for the driver, return the first client manager on the same host and port number
     else if (!clients.isEmpty())
     {
         auto host = driver->getHost();
         auto port = driver->getPort();
         auto it = std::find_if(clients.begin(), clients.end(), [host, port](const auto & oneClient)
         {
             return oneClient->getHost() == host && oneClient->getPort() == port;
         }
                               );
         if (it != clients.end())
             return *it;
     }
 
     return nullptr;
 }
 
 void DriverManager::updateLocalTab()
 {
     if (ui->localTreeWidget->currentItem() == nullptr)
         return;
 
     QString currentDriver = ui->localTreeWidget->currentItem()->text(LOCAL_NAME_COLUMN);
 
     auto device = std::find_if(driversList.begin(), driversList.end(), [currentDriver](const auto & oneDriver)
     {
         return currentDriver == oneDriver->getLabel();
     });
     if (device != driversList.end())
         processDeviceStatus(*device);
 }
 
 void DriverManager::updateClientTab()
 {
     QTreeWidgetItem *item = ui->clientTreeWidget->currentItem();
 
     if (item == nullptr)
         return;
 
     auto hostname = item->text(HOST_NAME_COLUMN);
     int port = item->text(HOST_PORT_COLUMN).toInt();
 
     auto device = std::find_if(driversList.begin(), driversList.end(), [hostname, port](const auto & oneDriver)
     {
         return hostname == oneDriver->getName() && port == oneDriver->getPort();
     });
     if (device != driversList.end())
         processDeviceStatus(*device);
 }
 
 void DriverManager::processLocalTree(bool dState)
 {
     QList<QSharedPointer<DriverInfo>> processed_devices;
 
     int port;
     bool portOK = false;
 
     connectionMode = ui->localR->isChecked() ? SERVER_CLIENT : SERVER_ONLY;
 
     for (auto &item : ui->localTreeWidget->selectedItems())
     {
         for (auto &device : driversList)
         {
             port = -1;
 
             //device->state = (dev_request == DriverInfo::DEV_TERMINATE) ? DriverInfo::DEV_START : DriverInfo::DEV_TERMINATE;
             if (item->text(LOCAL_NAME_COLUMN) == device->getLabel() &&
                     device->getServerState() != dState)
             {
                 processed_devices.append(device);
 
                 // N.B. If multiple devices are selected to run under one device manager
                 // then we select the port for the first device that has a valid port
                 // entry, the rest are ignored.
                 if (port == -1 && item->text(LOCAL_PORT_COLUMN).isEmpty() == false)
                 {
                     port = item->text(LOCAL_PORT_COLUMN).toInt(&portOK);
                     // If we encounter conversion error, we abort
                     if (portOK == false)
                     {
                         KSNotification::error(i18n("Invalid port entry: %1", item->text(LOCAL_PORT_COLUMN)));
                         return;
                     }
                 }
 
                 device->setHostParameters("localhost", port);
             }
         }
     }
 
     if (processed_devices.empty())
         return;
 
     if (dState)
         startDevices(processed_devices);
     else
         stopDevices(processed_devices);
 }
 
 void DriverManager::setClientFailed(const QString &message)
 {
     auto client = qobject_cast<ClientManager*>(sender());
 
     if (client == nullptr)
         return;
 
     auto host = client->getHost();
     auto port = client->getPort();
 
     KNotification::beep();
 
     emit clientFailed(host, port, message);
 
     GUIManager::Instance()->removeClient(client);
     INDIListener::Instance()->removeClient(client);
 
     KSNotification::event(QLatin1String("IndiServerMessage"), message, KSNotification::INDI);
 
     clients.removeOne(client);
     client->deleteLater();
 
     if (connectionMode == SERVER_CLIENT)
         activateStopService();
 
     updateMenuActions();
     updateLocalTab();
 }
 
 void DriverManager::setClientTerminated(const QString &message)
 {
     auto client = qobject_cast<ClientManager*>(sender());
 
     if (client == nullptr)
         return;
 
     auto host = client->getHost();
     auto port = client->getPort();
 
     KNotification::beep();
 
     emit clientTerminated(host, port, message);
 
     GUIManager::Instance()->removeClient(client);
     INDIListener::Instance()->removeClient(client);
 
     KSNotification::event(QLatin1String("IndiServerMessage"), message, KSNotification::INDI, KSNotification::Alert);
 
     clients.removeOne(client);
     client->deleteLater();
 
     updateMenuActions();
     updateLocalTab();
     updateClientTab();
 }
 
 void DriverManager::setServerStarted()
 {
     auto manager = qobject_cast<ServerManager*>(sender());
     qCDebug(KSTARS_INDI) << "INDI: INDI Server started locally on port " << manager->getPort();
     startLocalDrivers(manager);
     emit serverStarted(manager->getHost(), manager->getPort());
 }
 
 void DriverManager::setServerFailed(const QString &message)
 {
     auto server = qobject_cast<ServerManager *>(sender());
 
     if (server == nullptr)
         return;
 
     for (auto &dv : driversList)
     {
         if (dv->getServerManager() == server)
         {
             dv->reset();
         }
     }
 
     if (server->getMode() == SERVER_ONLY)
         KSNotification::error(message);
 
     emit serverFailed(server->getHost(), server->getPort(), message);
     servers.removeOne(server);
     server->deleteLater();
 
     updateLocalTab();
 }
 
 void DriverManager::setServerTerminated(const QString &message)
 {
     auto server = qobject_cast<ServerManager *>(sender());
 
     if (server == nullptr)
         return;
 
     for (auto &dv : driversList)
     {
         if (dv->getServerManager() == server)
         {
             dv->reset();
         }
     }
 
     if (server->getMode() == SERVER_ONLY)
         KSNotification::error(message);
 
     emit serverTerminated(server->getHost(), server->getPort(), message);
     servers.removeOne(server);
     server->deleteLater();
 
     updateLocalTab();
 }
 
 void DriverManager::processRemoteTree(bool dState)
 {
     QTreeWidgetItem *currentItem = ui->clientTreeWidget->currentItem();
     if (!currentItem)
         return;
 
     for (auto &dv : driversList)
     {
         if (dv->getDriverSource() != HOST_SOURCE)
             continue;
 
         //qDebug() << Q_FUNC_INFO << "Current item port " << currentItem->text(HOST_PORT_COLUMN) << " current dev " << dv->getName() << " -- port " << dv->getPort() << Qt::endl;
         //qDebug() << Q_FUNC_INFO << "dState is : " << (dState ? "True" : "False") << Qt::endl;
 
         if (currentItem->text(HOST_NAME_COLUMN) == dv->getName() &&
                 currentItem->text(HOST_PORT_COLUMN).toInt() == dv->getPort())
         {
             // Nothing changed, return
             if (dv->getClientState() == dState)
                 return;
 
             // connect to host
             if (dState)
                 connectRemoteHost(dv);
             // Disconnect form host
             else
                 disconnectRemoteHost(dv);
         }
     }
 }
 
 void DriverManager::connectRemoteHost(const QSharedPointer<DriverInfo> &driver)
 {
     auto host = driver->getHost();
     auto port = driver->getPort();
 
     auto clientManager = new ClientManager();
 
     clientManager->appendManagedDriver(driver);
 
     connect(clientManager, &ClientManager::started, this, &DriverManager::setClientStarted, Qt::UniqueConnection);
     connect(clientManager, &ClientManager::failed, this, &DriverManager::setClientFailed, Qt::UniqueConnection);
     connect(clientManager, &ClientManager::terminated, this, &DriverManager::setClientTerminated, Qt::UniqueConnection);
 
     clientManager->setServer(host.toLatin1().constData(), port);
 
     GUIManager::Instance()->addClient(clientManager);
     INDIListener::Instance()->addClient(clientManager);
 
     clientManager->establishConnection();
 }
 
 void DriverManager::setClientStarted()
 {
     auto clientManager = qobject_cast<ClientManager *>(sender());
     if (clientManager == nullptr)
         return;
 
     clients.append(clientManager);
     updateLocalTab();
     updateMenuActions();
 
     KSNotification::event(QLatin1String("ConnectionSuccessful"),
                           i18n("Connected to INDI server"));
 
     emit clientStarted(clientManager->getHost(), clientManager->getPort());
 }
 
 bool DriverManager::disconnectRemoteHost(const QSharedPointer<DriverInfo> &driver)
 {
     ClientManager *clientManager = driver->getClientManager();
 
     if (clientManager)
     {
         clientManager->removeManagedDriver(driver);
         clientManager->disconnectAll();
         GUIManager::Instance()->removeClient(clientManager);
         INDIListener::Instance()->removeClient(clientManager);
         clients.removeOne(clientManager);
         clientManager->deleteLater();
         updateMenuActions();
         return true;
     }
 
     return false;
 }
 
 void DriverManager::resizeDeviceColumn()
 {
     ui->localTreeWidget->resizeColumnToContents(0);
 }
 
 void DriverManager::updateMenuActions()
 {
     // We iterate over devices, we enable INDI Control Panel if we have any active device
     // We enable capture image sequence if we have any imaging device
 
     QAction *tmpAction = nullptr;
     bool activeDevice  = false;
 
     if (clients.size() > 0)
         activeDevice = true;
 
     tmpAction = KStars::Instance()->actionCollection()->action("indi_cpl");
     if (tmpAction != nullptr)
     {
         //qDebug() << Q_FUNC_INFO << "indi_cpl action set to active" << Qt::endl;
         tmpAction->setEnabled(activeDevice);
     }
 }
 
 int DriverManager::getINDIPort(int customPort)
 {
 #ifdef Q_OS_WIN
     qWarning() << "INDI server is currently not supported on Windows.";
     return -1;
 #else
     int lastPort = Options::serverPortEnd();
     bool success = false;
     currentPort++;
 
     // recycle
     if (currentPort > lastPort)
         currentPort = Options::serverPortStart();
 
     QTcpServer temp_server;
 
     if (customPort != -1)
     {
         success = temp_server.listen(QHostAddress::LocalHost, customPort);
         if (success)
         {
             temp_server.close();
             return customPort;
         }
         else
             return -1;
     }
 
     for (; currentPort <= lastPort; currentPort++)
     {
         success = temp_server.listen(QHostAddress::LocalHost, currentPort);
         if (success)
         {
             temp_server.close();
             return currentPort;
         }
     }
     return -1;
 #endif
 }
 
 bool DriverManager::readINDIHosts()
 {
     QString indiFile("indihosts.xml");
     //QFile localeFile;
     QFile file;
     char errmsg[1024];
     char c;
     LilXML *xmlParser = newLilXML();
     XMLEle *root      = nullptr;
     XMLAtt *ap        = nullptr;
     QString hName, hHost, hPort;
 
     lastGroup = nullptr;
     file.setFileName(KSPaths::locate(QStandardPaths::AppLocalDataLocation, indiFile));
     if (file.fileName().isEmpty() || !file.open(QIODevice::ReadOnly))
     {
         delLilXML(xmlParser);
         return false;
     }
 
     while (file.getChar(&c))
     {
         root = readXMLEle(xmlParser, c, errmsg);
 
         if (root)
         {
             // Get host name
             ap = findXMLAtt(root, "name");
             if (!ap)
             {
                 delLilXML(xmlParser);
                 return false;
             }
 
             hName = QString(valuXMLAtt(ap));
 
             // Get host name
             ap = findXMLAtt(root, "hostname");
 
             if (!ap)
             {
                 delLilXML(xmlParser);
                 return false;
             }
 
             hHost = QString(valuXMLAtt(ap));
 
             ap = findXMLAtt(root, "port");
 
             if (!ap)
             {
                 delLilXML(xmlParser);
                 return false;
             }
 
             hPort = QString(valuXMLAtt(ap));
 
             QSharedPointer<DriverInfo> dv(new DriverInfo(hName));
             dv->setHostParameters(hHost, hPort.toInt());
             dv->setDriverSource(HOST_SOURCE);
 
             connect(dv.get(), &DriverInfo::deviceStateChanged, this, [dv, this]()
             {
                 processDeviceStatus(dv);
             });
 
             driversList.append(dv);
 
             QTreeWidgetItem *item = new QTreeWidgetItem(ui->clientTreeWidget, lastGroup);
             lastGroup = item;
             item->setIcon(HOST_STATUS_COLUMN, ui->disconnected);
             item->setText(HOST_NAME_COLUMN, hName);
             item->setText(HOST_PORT_COLUMN, hPort);
 
             delXMLEle(root);
         }
         else if (errmsg[0])
         {
             qDebug() << Q_FUNC_INFO << errmsg;
             delLilXML(xmlParser);
             return false;
         }
     }
 
     delLilXML(xmlParser);
 
     return true;
 }
 
 bool DriverManager::readXMLDrivers()
 {
     QDir indiDir;
     QString driverName;
 
     QString driversDir = Options::indiDriversDir();
 #ifdef Q_OS_OSX
     if (Options::indiDriversAreInternal())
         driversDir =
             QCoreApplication::applicationDirPath() + "/../Resources/DriverSupport";
 #endif
 
     if (indiDir.cd(driversDir) == false)
     {
         KSNotification::error(i18n("Unable to find INDI drivers directory: %1\nPlease "
                                    "make sure to set the correct "
                                    "path in KStars configuration",
                                    driversDir));
         return false;
     }
 
     indiDir.setNameFilters(QStringList() << "indi_*.xml"
                            << "drivers.xml");
     indiDir.setFilter(QDir::Files | QDir::NoSymLinks);
     QFileInfoList list = indiDir.entryInfoList();
 
     for (auto &fileInfo : list)
     {
         if (fileInfo.fileName().endsWith(QLatin1String("_sk.xml")))
             continue;
 
         processXMLDriver(fileInfo.absoluteFilePath());
     }
 
     // JM 2022.08.24: Process local source last as INDI sources should have higher priority than KStars own database.
     processXMLDriver(QLatin1String(":/indidrivers.xml"));
 
     return true;
 }
 
 void DriverManager::processXMLDriver(const QString &driverName)
 {
     QFile file(driverName);
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
     {
         KSNotification::error(i18n("Failed to open INDI Driver file: %1", driverName));
         return;
     }
 
     char errmsg[ERRMSG_SIZE];
     char c;
     LilXML *xmlParser = newLilXML();
     XMLEle *root      = nullptr;
     XMLEle *ep        = nullptr;
 
     if (driverName.endsWith(QLatin1String("drivers.xml")))
         driverSource = PRIMARY_XML;
     else
         driverSource = THIRD_PARTY_XML;
 
     while (file.getChar(&c))
     {
         root = readXMLEle(xmlParser, c, errmsg);
 
         if (root)
         {
             // If the XML file is using the INDI Library v1.3+ format
             if (!strcmp(tagXMLEle(root), "driversList"))
             {
                 for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
                 {
                     if (!buildDeviceGroup(ep, errmsg))
                         prXMLEle(stderr, ep, 0);
                 }
             }
             // If using the older format
             else
             {
                 if (!buildDeviceGroup(root, errmsg))
                     prXMLEle(stderr, root, 0);
             }
 
             delXMLEle(root);
         }
         else if (errmsg[0])
         {
             qCDebug(KSTARS_INDI) << QString(errmsg);
             delLilXML(xmlParser);
             return;
         }
     }
 
     delLilXML(xmlParser);
 }
 
 bool DriverManager::buildDeviceGroup(XMLEle *root, char errmsg[])
 {
     XMLAtt *ap;
     XMLEle *ep;
     QString groupName;
     QTreeWidgetItem *group;
     DeviceFamily groupType = KSTARS_TELESCOPE;
 
     // avoid overflow
     if (strlen(tagXMLEle(root)) > 1024)
         return false;
 
     // Get device grouping name
     ap = findXMLAtt(root, "group");
 
     if (!ap)
     {
         snprintf(errmsg, ERRMSG_SIZE, "Tag %.64s does not have a group attribute",
                  tagXMLEle(root));
         return false;
     }
 
     groupName = valuXMLAtt(ap);
     groupType = DeviceFamilyLabels.key(groupName);
 
 #ifndef HAVE_CFITSIO
     // We do not create these groups if we don't have CFITSIO support
     if (groupType == KSTARS_CCD || groupType == KSTARS_VIDEO)
         return true;
 #endif
 
     // Find if the group already exists
     QList<QTreeWidgetItem *> treeList =
         ui->localTreeWidget->findItems(groupName, Qt::MatchExactly);
     if (!treeList.isEmpty())
         group = treeList[0];
     else
         group = new QTreeWidgetItem(ui->localTreeWidget, lastGroup);
 
     group->setText(0, groupName);
     lastGroup = group;
 
     for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
     {
         if (!buildDriverElement(ep, group, groupType, errmsg))
             return false;
     }
 
     return true;
 }
 
 bool DriverManager::buildDriverElement(XMLEle *root, QTreeWidgetItem *DGroup,
                                        DeviceFamily groupType, char errmsg[])
 {
     XMLAtt *ap;
     XMLEle *el;
     QString label;
     QString driver;
     QString version;
     // N.B. NOT an i18n string.
     QString manufacturer("Others");
     QString name;
     QString port;
     QString skel;
     QVariantMap vMap;
     //double focal_length(-1), aperture(-1);
 
     ap = findXMLAtt(root, "label");
     if (!ap)
     {
         snprintf(errmsg, ERRMSG_SIZE, "Tag %.64s does not have a label attribute",
                  tagXMLEle(root));
         return false;
     }
 
     label = valuXMLAtt(ap);
 
     // Label is unique, so if we have the same label, we simply ignore
     if (findDriverByLabel(label) != nullptr)
         return true;
 
     ap = findXMLAtt(root, "manufacturer");
     if (ap)
         manufacturer = valuXMLAtt(ap);
 
     // Search for optional port attribute
     ap = findXMLAtt(root, "port");
     if (ap)
         port = valuXMLAtt(ap);
 
     // Search for skel file, if any
     // Search for optional port attribute
     ap = findXMLAtt(root, "skel");
     if (ap)
         skel = valuXMLAtt(ap);
 
     // Find MDPD: Multiple Devices Per Driver
     ap = findXMLAtt(root, "mdpd");
     if (ap)
     {
         bool mdpd = false;
         mdpd      = (QString(valuXMLAtt(ap)) == QString("true")) ? true : false;
         vMap.insert("mdpd", mdpd);
     }
 
     el = findXMLEle(root, "driver");
 
     if (!el)
         return false;
 
     driver = pcdataXMLEle(el);
 
     ap = findXMLAtt(el, "name");
     if (!ap)
     {
         snprintf(errmsg, ERRMSG_SIZE, "Tag %.64s does not have a name attribute",
                  tagXMLEle(el));
         return false;
     }
 
     name = valuXMLAtt(ap);
 
     el = findXMLEle(root, "version");
 
     if (!el)
         return false;
 
     version        = pcdataXMLEle(el);
     bool versionOK = false;
     version.toDouble(&versionOK);
     if (versionOK == false)
         version = "1.0";
 
     bool driverIsAvailable = checkDriverAvailability(driver);
 
     vMap.insert("LOCALLY_AVAILABLE", driverIsAvailable);
     QIcon remoteIcon = QIcon::fromTheme("network-modem");
 
     QTreeWidgetItem *device = new QTreeWidgetItem(DGroup);
 
     device->setText(LOCAL_NAME_COLUMN, label);
     if (driverIsAvailable)
         device->setIcon(LOCAL_STATUS_COLUMN, ui->stopPix);
     else
         device->setIcon(LOCAL_STATUS_COLUMN, remoteIcon);
     device->setText(LOCAL_VERSION_COLUMN, version);
     device->setText(LOCAL_PORT_COLUMN, port);
 
     //if ((driverSource == PRIMARY_XML) && driversStringList.contains(driver) == false)
     if (groupType == KSTARS_TELESCOPE && driversStringList.contains(driver) == false)
         driversStringList.append(driver);
 
     QSharedPointer<DriverInfo> dv(new DriverInfo(name));
 
     dv->setLabel(label);
     dv->setVersion(version);
     dv->setExecutable(driver);
     dv->setManufacturer(manufacturer);
     dv->setSkeletonFile(skel);
     dv->setType(groupType);
     dv->setDriverSource(driverSource);
     dv->setUserPort(port.isEmpty() ? 7624 : port.toInt());
     dv->setAuxInfo(vMap);
 
     connect(dv.get(), &DriverInfo::deviceStateChanged, this, [dv, this]()
     {
         processDeviceStatus(dv);
     });
 
     driversList.append(dv);
 
     return true;
 }
 
 bool DriverManager::checkDriverAvailability(const QString &driver)
 {
     QString indiServerDir = Options::indiServer();
     if (Options::indiServerIsInternal())
         indiServerDir = QCoreApplication::applicationDirPath();
     else
         indiServerDir = QFileInfo(Options::indiServer()).dir().path();
 
     QFile driverFile(indiServerDir + '/' + driver);
 
     if (driverFile.exists() == false)
         return (!QStandardPaths::findExecutable(indiServerDir + '/' + driver).isEmpty());
 
     return true;
 }
 
 void DriverManager::updateCustomDrivers()
 {
     for (const QVariantMap &oneDriver : m_CustomDrivers->customDrivers())
     {
         QSharedPointer<DriverInfo> dv(new DriverInfo(oneDriver["Name"].toString()));
         dv->setLabel(oneDriver["Label"].toString());
         dv->setUniqueLabel(dv->getLabel());
         dv->setExecutable(oneDriver["Exec"].toString());
         dv->setVersion(oneDriver["Version"].toString());
         dv->setManufacturer(oneDriver["Manufacturer"].toString());
         dv->setType(DeviceFamilyLabels.key(oneDriver["Family"].toString()));
         dv->setDriverSource(CUSTOM_SOURCE);
 
         bool driverIsAvailable = checkDriverAvailability(oneDriver["Exec"].toString());
         QVariantMap vMap;
         vMap.insert("LOCALLY_AVAILABLE", driverIsAvailable);
         dv->setAuxInfo(vMap);
 
         driversList.append(dv);
     }
 }
 
 // JM 2018-07-23: Disabling the old custom drivers method
 #if 0
 void DriverManager::updateCustomDrivers()
 {
     QString label;
     QString driver;
     QString version;
     QString name;
     QTreeWidgetItem *group     = nullptr;
     QTreeWidgetItem *widgetDev = nullptr;
     QVariantMap vMap;
     QSharedPointer<DriverInfo>drv = nullptr;
 
     // Find if the group already exists
     QList<QTreeWidgetItem *> treeList = ui->localTreeWidget->findItems("Telescopes", Qt::MatchExactly);
     if (!treeList.isEmpty())
         group = treeList[0];
     else
         return;
 
     KStarsData::Instance()->logObject()->readAll();
 
     // Find custom telescope to ADD/UPDATE
     foreach (OAL::Scope *s, *(KStarsData::Instance()->logObject()->scopeList()))
     {
         name = label = s->name();
 
         if (s->driver() == i18n("None"))
             continue;
 
         // If driver already exists, just update values
         if ((drv = findDriverByLabel(label)))
         {
             if (s->aperture() > 0 && s->focalLength() > 0)
             {
                 vMap.insert("TELESCOPE_APERTURE", s->aperture());
                 vMap.insert("TELESCOPE_FOCAL_LENGTH", s->focalLength());
                 drv->setAuxInfo(vMap);
             }
 
             drv->setExecutable(s->driver());
 
             continue;
         }
 
         driver  = s->driver();
         version = QString("1.0");
 
         QTreeWidgetItem *device = new QTreeWidgetItem(group);
         device->setText(LOCAL_NAME_COLUMN, QString(label));
         device->setIcon(LOCAL_STATUS_COLUMN, ui->stopPix);
         device->setText(LOCAL_VERSION_COLUMN, QString(version));
 
         QSharedPointer<DriverInfo>dv = new DriverInfo(name);
 
         dv->setLabel(label);
         dv->setExecutable(driver);
         dv->setVersion(version);
         dv->setType(KSTARS_TELESCOPE);
         dv->setDriverSource(EM_XML);
 
         if (s->aperture() > 0 && s->focalLength() > 0)
         {
             vMap.insert("TELESCOPE_APERTURE", s->aperture());
             vMap.insert("TELESCOPE_FOCAL_LENGTH", s->focalLength());
             dv->setAuxInfo(vMap);
         }
 
         connect(dv, SIGNAL(deviceStateChanged(DriverInfo*)), this, SLOT(processDeviceStatus(DriverInfo*)));
         driversList.append(dv);
     }
 
     // Find custom telescope to REMOVE
     foreach (QSharedPointer<DriverInfo>dev, driversList)
     {
         // If it's from primary xml file or it is in a running state, continue.
         if (dev->getDriverSource() != EM_XML || dev->getClientState())
             continue;
 
         if (KStarsData::Instance()->logObject()->findScopeByName(dev->getName()))
             continue;
 
         // Find if the group already exists
         QList<QTreeWidgetItem *> devList =
             ui->localTreeWidget->findItems(dev->getLabel(), Qt::MatchExactly | Qt::MatchRecursive);
         if (!devList.isEmpty())
         {
             widgetDev = devList[0];
             group->removeChild(widgetDev);
         }
         else
             return;
 
         driversList.removeOne(dev);
         delete (dev);
     }
 }
 #endif
 
 void DriverManager::addINDIHost()
 {
     QDialog hostConfDialog;
     Ui::INDIHostConf hostConf;
     hostConf.setupUi(&hostConfDialog);
     hostConfDialog.setWindowTitle(i18nc("@title:window", "Add Host"));
     bool portOk = false;
 
     if (hostConfDialog.exec() == QDialog::Accepted)
     {
         QSharedPointer<DriverInfo> hostItem(new DriverInfo(hostConf.nameIN->text()));
 
         hostConf.portnumber->text().toInt(&portOk);
 
         if (portOk == false)
         {
             KSNotification::error(i18n("Error: the port number is invalid."));
             return;
         }
 
         hostItem->setHostParameters(hostConf.hostname->text(),
                                     hostConf.portnumber->text().toInt());
 
         //search for duplicates
         //for (uint i=0; i < ksw->data()->INDIHostsList.count(); i++)
         foreach (QSharedPointer<DriverInfo>host, driversList)
             if (hostItem->getName() == host->getName() &&
                     hostItem->getPort() == host->getPort())
             {
                 KSNotification::error(i18n("Host: %1 Port: %2 already exists.",
                                            hostItem->getName(), hostItem->getPort()));
                 return;
             }
 
         hostItem->setDriverSource(HOST_SOURCE);
 
         connect(hostItem.get(), &DriverInfo::deviceStateChanged, this, [hostItem, this]()
         {
             processDeviceStatus(hostItem);
         });
 
         driversList.append(hostItem);
 
         QTreeWidgetItem *item = new QTreeWidgetItem(ui->clientTreeWidget);
         item->setIcon(HOST_STATUS_COLUMN, ui->disconnected);
         item->setText(HOST_NAME_COLUMN, hostConf.nameIN->text());
         item->setText(HOST_PORT_COLUMN, hostConf.portnumber->text());
     }
 
     saveHosts();
 }
 
 void DriverManager::modifyINDIHost()
 {
     QDialog hostConfDialog;
     Ui::INDIHostConf hostConf;
     hostConf.setupUi(&hostConfDialog);
     hostConfDialog.setWindowTitle(i18nc("@title:window", "Modify Host"));
 
     QTreeWidgetItem *currentItem = ui->clientTreeWidget->currentItem();
 
     if (currentItem == nullptr)
         return;
 
     for (auto &host : driversList)
     {
         if (currentItem->text(HOST_NAME_COLUMN) == host->getName() &&
                 currentItem->text(HOST_PORT_COLUMN).toInt() == host->getPort())
         {
             hostConf.nameIN->setText(host->getName());
             hostConf.hostname->setText(host->getHost());
             hostConf.portnumber->setText(QString::number(host->getPort()));
 
             if (hostConfDialog.exec() == QDialog::Accepted)
             {
                 host->setName(hostConf.nameIN->text());
                 host->setHostParameters(hostConf.hostname->text(),
                                         hostConf.portnumber->text().toInt());
 
                 currentItem->setText(HOST_NAME_COLUMN, hostConf.nameIN->text());
                 currentItem->setText(HOST_PORT_COLUMN, hostConf.portnumber->text());
 
                 saveHosts();
                 return;
             }
         }
     }
 }
 
 void DriverManager::removeINDIHost()
 {
     if (ui->clientTreeWidget->currentItem() == nullptr)
         return;
 
     foreach (QSharedPointer<DriverInfo>host, driversList)
         if (ui->clientTreeWidget->currentItem()->text(HOST_NAME_COLUMN) ==
                 host->getName() &&
                 ui->clientTreeWidget->currentItem()->text(HOST_PORT_COLUMN).toInt() ==
                 host->getPort())
         {
             if (host->getClientState())
             {
                 KSNotification::error(
                     i18n("You need to disconnect the client before removing it."));
                 return;
             }
 
             if (KMessageBox::warningContinueCancel(
                         nullptr,
                         i18n("Are you sure you want to remove the %1 client?",
                              ui->clientTreeWidget->currentItem()->text(HOST_NAME_COLUMN)),
                         i18n("Delete Confirmation"),
                         KStandardGuiItem::del()) != KMessageBox::Continue)
                 return;
 
             driversList.removeOne(host);
             delete (ui->clientTreeWidget->currentItem());
             break;
         }
 
     saveHosts();
 }
 
 void DriverManager::saveHosts()
 {
     QFile file;
     QString hostData;
 
     //determine filename in local user KDE directory tree.
     file.setFileName(QDir(KSPaths::writableLocation(QStandardPaths::AppLocalDataLocation))
                      .filePath("indihosts.xml"));
 
     if (!file.open(QIODevice::WriteOnly))
     {
         KSNotification::sorry(i18n("Unable to write to file 'indihosts.xml'\nAny changes "
                                    "to INDI hosts configurations will not be saved."),
                               i18n("Could Not Open File"));
         return;
     }
 
     QTextStream outstream(&file);
 
     //for (uint i= 0; i < ksw->data()->INDIHostsList.count(); i++)
     foreach (QSharedPointer<DriverInfo>host, driversList)
     {
         if (host->getDriverSource() != HOST_SOURCE)
             continue;
 
         hostData = "<INDIHost name='";
         hostData += host->getName();
         hostData += "' hostname='";
         hostData += host->getHost();
         hostData += "' port='";
         hostData += QString::number(host->getPort());
         hostData += "' />\n";
 
         outstream << hostData;
     }
 
     file.close();
 }
 
 QSharedPointer<DriverInfo> DriverManager::findDriverByName(const QString &name)
 {
     auto driver = std::find_if(driversList.begin(), driversList.end(), [name](auto & oneDriver)
     {
         return oneDriver->getName() == name;
     });
 
     if (driver != driversList.end())
         return *driver;
     else
         return QSharedPointer<DriverInfo>();
 }
 
 QSharedPointer<DriverInfo> DriverManager::findDriverByLabel(const QString &label)
 {
     auto driver = std::find_if(driversList.begin(), driversList.end(), [label](auto & oneDriver)
     {
         return oneDriver->getLabel() == label;
     });
 
     if (driver != driversList.end())
         return *driver;
     else
         return QSharedPointer<DriverInfo>();
 }
 
 QSharedPointer<DriverInfo> DriverManager::findDriverByExec(const QString &exec)
 {
     auto driver = std::find_if(driversList.begin(), driversList.end(), [exec](auto & oneDriver)
     {
         return oneDriver->getLabel() == exec;
     });
 
     if (driver != driversList.end())
         return *driver;
     else
         return QSharedPointer<DriverInfo>();
 }
 
 QString DriverManager::getUniqueDeviceLabel(const QString &label)
 {
     int nset            = 0;
     QString uniqueLabel = label;
 
     for (auto &cm : clients)
     {
         auto devices = cm->getDevices();
 
         for (auto &dv : devices)
         {
             if (label == QString(dv.getDeviceName()))
                 nset++;
         }
     }
     if (nset > 0)
         uniqueLabel = QString("%1 %2").arg(label).arg(nset + 1);
 
     return uniqueLabel;
 }
 
 QJsonArray DriverManager::getDriverList() const
 {
     QJsonArray driverArray;
 
     for (const auto &drv : driversList)
         driverArray.append(drv->toJson());
 
     return driverArray;
 }
 
 bool DriverManager::restartDriver(const QSharedPointer<DriverInfo> &driver)
 {
     for (auto &oneServer : servers)
     {
         if (oneServer->contains(driver))
         {
             return oneServer->restartDriver(driver);
         }
     }
 
     return false;
 }