mythsystem.cpp

Go to the documentation of this file.

/* -*- Mode: c++ -*-
 *  Class MythSystem
 *
 *  Copyright (C) Daniel Kristjansson 2013
 *  Copyright (C) Gavin Hurlbut 2012
 *  Copyright (C) Issac Richards 2008
 *
 *   This program 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 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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 this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */
 
// C++ headers
#include <cstdint>
#include <csignal> // for SIGXXX
 
// Qt headers
#include <QChar> // Fix Qt6 GCC SFINAE warning
#include <QByteArray>
#include <QIODevice>
#include <QStringList>
#include <utility>
 
// MythTV headers
#include "mythsystemlegacy.h"
#include "mythsystem.h"
#include "exitcodes.h"
 
class MythSystemLegacyWrapper : public MythSystem
{
  public:
    static MythSystemLegacyWrapper *Create(
        const QStringList &args,
        uint flags,
        const QString& startPath,
        Priority /*cpuPriority*/,
        Priority /*diskPriority*/)
    {
        if (args.empty())
            return nullptr;
 
        auto *legacy = new MythSystemLegacy(args.join(" "), flags);
 
        if (!startPath.isEmpty())
            legacy->SetDirectory(startPath);
 
        uint ac = kMSAutoCleanup | kMSRunBackground;
        if ((ac & flags) == ac)
        {
            legacy->Run();
            return nullptr;
        }
 
        auto *wrapper = new MythSystemLegacyWrapper(legacy, flags);
 
        // TODO implement cpuPriority and diskPriority
        return wrapper;
    }
 
    ~MythSystemLegacyWrapper(void) override
    {
        MythSystemLegacyWrapper::Wait(0ms);
    }
 
    uint GetFlags(void) const override // MythSystem
    {
        return m_flags;
    }
 
    QString GetStartingPath(void) const override // MythSystem
    {
        return m_legacy->GetDirectory();
    }
 
    Priority GetCPUPriority(void) const override // MythSystem
    {
        return kNormalPriority;
    }
 
    Priority GetDiskPriority(void) const override // MythSystem
    {
        return kNormalPriority;
    }
 
    bool Wait(std::chrono::milliseconds timeout) override // MythSystem
    {
        if (timeout >= 1s)
            timeout = timeout + 500ms;
        else if (timeout == 0ms)
            timeout = 0ms;
        else
            timeout = 1s;
        uint legacy_wait_ret = m_legacy->Wait(duration_cast<std::chrono::seconds>(timeout));
        return GENERIC_EXIT_RUNNING != legacy_wait_ret;
    }
 
    QIODevice *GetStandardInputStream(void) override // MythSystem
    {
        if (!(kMSStdIn & m_flags))
            return nullptr;
 
        if (!m_legacy->GetBuffer(0)->isOpen() &&
            !m_legacy->GetBuffer(0)->open(QIODevice::WriteOnly))
        {
            return nullptr;
        }
 
        return m_legacy->GetBuffer(0);
    }
 
    QIODevice *GetStandardOutputStream(void) override // MythSystem
    {
        if (!(kMSStdOut & m_flags))
            return nullptr;
 
        Wait(0ms); // legacy getbuffer is not thread-safe, so wait
 
        if (!m_legacy->GetBuffer(1)->isOpen() &&
            !m_legacy->GetBuffer(1)->open(QIODevice::ReadOnly))
        {
            return nullptr;
        }
 
        return m_legacy->GetBuffer(1);
    }
 
    QIODevice *GetStandardErrorStream(void) override // MythSystem
    {
        if (!(kMSStdErr & m_flags))
            return nullptr;
 
        Wait(0ms); // legacy getbuffer is not thread-safe, so wait
 
        if (!m_legacy->GetBuffer(2)->isOpen() &&
            !m_legacy->GetBuffer(2)->open(QIODevice::ReadOnly))
        {
            return nullptr;
        }
 
        return m_legacy->GetBuffer(2);
    }
 
    void Signal(MythSignal sig) override // MythSystem
    {
        m_legacy->Signal(sig);
    }
 
    int GetExitCode(void) const override // MythSystem
    {
        // FIXME doesn't actually know why program exited.
        //       if program returns 142 then we will forever
        //       think it is running even though it is not.
        int status = m_legacy->GetStatus();
        if (GENERIC_EXIT_RUNNING == status)
            return -2;
        if (GENERIC_EXIT_KILLED == status)
            return -1;
        return status;
    }
 
  private:
    MythSystemLegacyWrapper(MythSystemLegacy *legacy, uint flags) :
        m_legacy(legacy), m_flags(flags)
    {
        m_legacy->Run();
    }
 
  private:
    QScopedPointer<MythSystemLegacy> m_legacy;
    uint m_flags;
};
 
MythSystem *MythSystem::Create(
    const QStringList &args,
    uint flags,
    const QString& startPath,
    Priority cpuPriority,
    Priority diskPriority)
{
    return MythSystemLegacyWrapper::Create(
        args, flags, startPath, cpuPriority, diskPriority);
}
 
MythSystem *MythSystem::Create(
    const QString& args,
    uint flags,
    const QString& startPath,
    Priority cpuPriority,
    Priority diskPriority)
{
    return MythSystem::Create(
        args.simplified().split(' '), flags, startPath,
        cpuPriority, diskPriority);
}