JustMotion/src/common.cpp

//    This file is part of Motion Watch.

//    Motion Watch 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.

//    Motion Watch 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.

#include "common.h"

QString getParam(const QString &key, const QStringList &args)
{
    // this can be used by command objects to pick out parameters
    // from a command line that are pointed by a name identifier
    // example: -i /etc/some_file, this function should pick out
    // "/etc/some_file" from args if "-i" is passed into key.

    QString ret;

    int pos = args.indexOf(QRegularExpression(key, QRegularExpression::CaseInsensitiveOption));

    if (pos != -1)
    {
        // key found.

        if ((pos + 1) <= (args.size() - 1))
        {
            // check ahead to make sure pos + 1 will not go out
            // of range.

            if (!args[pos + 1].startsWith("-"))
            {
                // the "-" used throughout this application
                // indicates an argument so the above 'if'
                // statement will check to make sure it does
                // not return another argument as a parameter
                // in case a back-to-back "-arg -arg" is
                // present.

                ret = args[pos + 1];
            }
        }
    }

    return ret;
}

QByteArray genMD5(const QByteArray &bytes)
{
    QCryptographicHash hasher(QCryptographicHash::Md5);

    hasher.addData(bytes); return hasher.result();
}

QByteArray genMD5(const QString &path)
{
    QFile file(path);

    if (file.open(QFile::ReadOnly))
    {
        return genMD5(file.readAll());
    }
    else
    {
        return genMD5(QByteArray("EMPTY"));
    }
}

QStringList lsFilesInDir(const QString &path, const QString &ext)
{
    QStringList filters;

    filters << "*" + ext;

    QDir dirObj(path);

    dirObj.setFilter(QDir::Files);
    dirObj.setNameFilters(filters);
    dirObj.setSorting(QDir::Name);

    return dirObj.entryList();
}

QStringList lsDirsInDir(const QString &path)
{
    QDir dirObj(path);

    dirObj.setFilter(QDir::Dirs | QDir::NoDotAndDotDot);
    dirObj.setSorting(QDir::Name);

    return dirObj.entryList();
}

void enforceMaxEvents(shared_t *share)
{
    auto names = lsFilesInDir("events", ".mp4");

    while (names.size() > share->maxEvents)
    {
        auto nameOnly = "events/" + names[0];

        nameOnly.remove(".mp4");

        auto mp4File = nameOnly + ".mp4";
        auto imgFile = nameOnly + ".jpg";
        auto webFile = nameOnly + ".html";

        QFile::remove(mp4File);
        QFile::remove(imgFile);
        QFile::remove(webFile);

        names.removeFirst();
    }
}

void rdLine(const QString &param, const QString &line, QString *value)
{
    if (line.startsWith(param))
    {
        *value = line.mid(param.size());
    }
}

void rdLine(const QString &param, const QString &line, int *value)
{
    if (line.startsWith(param))
    {
        *value = line.mid(param.size()).toInt();
    }
}

bool rdConf(const QString &filePath, shared_t *share)
{
    QFile varFile(filePath);

    if (!varFile.open(QFile::ReadOnly))
    {
        share->retCode = ENOENT;

        QTextStream(stderr) << "err: config file: " << filePath << " does not exists or lack read permissions." << Qt::endl;
    }
    else
    {
        QString line;

        do
        {
            line = QString::fromUtf8(varFile.readLine());

            if (!line.startsWith("#"))
            {
                rdLine("cam_name = ",         line, &share->camName);
                rdLine("recording_stream = ", line, &share->recordUrl);
                rdLine("web_root = ",         line, &share->webRoot);
                rdLine("web_text = ",         line, &share->webTxt);
                rdLine("web_bg = ",           line, &share->webBg);
                rdLine("web_font = ",         line, &share->webFont);
                rdLine("max_event_secs = ",   line, &share->evMaxSecs);
                rdLine("post_secs = ",        line, &share->postSecs);
                rdLine("post_cmd = ",         line, &share->postCmd);
                rdLine("pix_thresh = ",       line, &share->pixThresh);
                rdLine("img_thresh = ",       line, &share->imgThresh);
                rdLine("frame_gap = ",        line, &share->frameGap);
                rdLine("max_events = ",       line, &share->maxEvents);
                rdLine("max_log_size = ",     line, &share->maxLogSize);
            }

        } while(!line.isEmpty());
    }

    return share->retCode == 0;
}

bool rdConf(shared_t *share)
{
    if (rdConf(share->conf, share))
    {
        if (share->camName.isEmpty())
        {
            share->camName = QFileInfo(share->conf).fileName();
        }

        share->outDir = QDir().cleanPath(share->webRoot) + "/" + share->camName;

        QDir().mkpath(share->outDir);

        if (!QDir::setCurrent(share->outDir))
        {
            QTextStream(stderr) << "err: failed to change/create the current working directory to camera folder: '" << share->outDir << "' does it exists?" << Qt::endl;

            share->retCode = ENOENT;
        }
    }

    return share->retCode == 0;
}

MultiInstance::MultiInstance(QObject *parent) : QObject(parent) {}

void MultiInstance::instStdout()
{
    for (auto &&proc : procList)
    {
        QTextStream(stdout) << proc->readAllStandardOutput();
    }
}

void MultiInstance::instStderr()
{
    for (auto &&proc : procList)
    {
        QTextStream(stderr) << proc->readAllStandardError();
    }
}

void MultiInstance::procFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
    Q_UNUSED(exitCode)
    Q_UNUSED(exitStatus)

    for (auto &&proc : procList)
    {
        if (proc->state() == QProcess::Running)
        {
            return;
        }
    }

    QCoreApplication::quit();
}

int MultiInstance::start(const QStringList &args)
{
    auto ret   = ENOENT;
    auto path  = getParam("-d", args);
    auto files = lsFilesInDir(path);

    if (!QDir(path).exists())
    {
        QTextStream(stderr) << "err: the supplied directory in -d '" << path << "' does not exists or is not a directory.";
    }
    else if (files.isEmpty())
    {
        QTextStream(stderr) << "err: no config files found in '" << path << "'";
    }
    else
    {
        for (auto &&conf : files)
        {
            auto proc = new QProcess(this);

            QStringList subArgs;

            subArgs << "-c" << conf;

            connect(proc, &QProcess::readyReadStandardOutput, this, &MultiInstance::instStdout);
            connect(proc, &QProcess::readyReadStandardError,  this, &MultiInstance::instStderr);
            connect(proc, &QProcess::finished,                this, &MultiInstance::procFinished);

            connect(QCoreApplication::instance(), &QCoreApplication::aboutToQuit, proc, &QProcess::terminate);

            proc->setProgram(APP_BIN);
            proc->setArguments(subArgs);
            proc->start();

            procList.append(proc);
        }
    }

    return ret;
}