qprocessscheduler.cpp

Go to the documentation of this file.

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qprocessscheduler_p.h"
#include <QtQmlDom/private/qqmldom_utils_p.h>
 
QT_BEGIN_NAMESPACE
 
namespace QmlLsp {
 
Q_STATIC_LOGGING_CATEGORY(schedulerLog, "qt.languageserver.qprocessscheduler")
 
using namespace Qt::StringLiterals;
 
/*!
  \internal
  \class QProcessScheduler
 
  \brief Runs multiple processes sequentially via a QProcess, and signals once they are done.
 
  QProcessScheduler runs multiple programs sequentially through a QProcess, and emits the \c done
  signal once all programs finished. Use schedule(programs, id) to add new programs to be run. The
  id is used to signal their completion. Duplicate programs that already are in the queue are not
  re-added to the queue.
 */
QProcessScheduler::QProcessScheduler()
{
    QObject::connect(&m_process, &QProcess::finished, this, &QProcessScheduler::processNext);
    QObject::connect(&m_process, &QProcess::errorOccurred, this,
                     &QProcessScheduler::onErrorOccurred);
}
QProcessScheduler::~QProcessScheduler()
{
    QObject::disconnect(&m_process, nullptr);
    m_process.kill();
    m_process.waitForFinished();
}
 
void QProcessScheduler::schedule(const QList<Command> &list, const Id &id)
{
    m_queue.enqueue(StartMarker{ id });
    for (const auto &x : list) {
        const QueueElement queueElement{ x };
        if (!m_queue.contains(queueElement))
            m_queue.enqueue(queueElement);
    }
    m_queue.enqueue(EndMarker{ id });
    if (!m_isRunning)
        processNext();
}
 
static bool isStartMarkerOf(const QProcessScheduler::QueueElement &e,
                            const QProcessScheduler::Id &id)
{
    const auto startMarker = std::get_if<QProcessScheduler::StartMarker>(&e);
    if (!startMarker)
        return false;
    return startMarker->id == id;
}
 
static bool isEndMarkerOf(const QProcessScheduler::QueueElement &e, const QProcessScheduler::Id &id)
{
    const auto endMarker = std::get_if<QProcessScheduler::EndMarker>(&e);
    if (!endMarker)
        return false;
    return endMarker->id == id;
}
 
void QProcessScheduler::cancel(const Id &id)
{
    auto removeQueueElementsForStartMarkerIt = [this, &id](auto begin) {
        auto end = std::find_if(begin, m_queue.cend(),
                                std::bind(isEndMarkerOf, std::placeholders::_1, id));
 
        // also include the marker during erase
        if (end != m_queue.cend())
            std::advance(end, 1);
        m_queue.erase(begin, end);
    };
 
    if (m_current != id) {
        const auto begin = std::find_if(m_queue.cbegin(), m_queue.cend(),
                                        std::bind(isStartMarkerOf, std::placeholders::_1, id));
        removeQueueElementsForStartMarkerIt(begin);
        emit cancelled(id);
        return;
    }
 
    {
        QObject::disconnect(&m_process, &QProcess::finished, this, &QProcessScheduler::processNext);
        QObject::disconnect(&m_process, &QProcess::errorOccurred, this,
                            &QProcessScheduler::onErrorOccurred);
        // note: kill and waitForFinished triggers the finished signal, which we don't want to trigger
        m_process.kill();
        m_process.waitForFinished();
        removeQueueElementsForStartMarkerIt(m_queue.cbegin());
        QObject::connect(&m_process, &QProcess::finished, this, &QProcessScheduler::processNext);
        QObject::connect(&m_process, &QProcess::errorOccurred, this,
                         &QProcessScheduler::onErrorOccurred);
    }
 
    emit cancelled(id);
    processNext();
}
 
void QProcessScheduler::processNext()
{
    m_isRunning = m_queue.size() > 0;
    if (!m_isRunning)
        return;
 
    std::visit(qOverloadedVisitor{
                       [this](const StartMarker &start) {
                           emit started(start.id);
                           m_current = start.id;
                           processNext();
                       },
                       [this](const EndMarker &end) {
                           m_current.reset();
                           emit done(end.id);
                           processNext();
                       },
                       [this](const Command &command) {
                           m_process.setProgram(command.program);
                           m_process.setArguments(command.arguments);
                           m_process.setProcessEnvironment(command.customEnvironment);
                           m_process.start();
                       },
               },
               m_queue.dequeue());
}
 
void QProcessScheduler::onErrorOccurred(QProcess::ProcessError error)
{
    qCDebug(schedulerLog) << "Process" << m_process.program() << m_process.arguments().join(" "_L1)
                          << "had an error:" << error;
    processNext();
}
 
} // namespace QmlLsp
 
QT_END_NAMESPACE