VFS_cron.cpp

Go to the documentation of this file.

 
#include <QDateTime>
#include <QTimer>
#include <QThread>
 
#include "VFS.h"
#include "VFS_cron.h"
#include "VFS_base/VFS_icons.h"
 
VFS_cron::VFS_cron(QString crontab)//, QString settings)
: VFS_node()
, _cronID(-1)
{
        //Q_UNUSED(settings)
 
        parseCrontab(crontab);
 
        connect(VFS::root(),SIGNAL(initialized()),this,SLOT(initialize()));
}
 
VFS_cron::~VFS_cron()
{
        //destructor
}
 
VFS_node *VFS_cron::find(VFS_request *r)
{
        if (_crontab.contains(r->_path))
                return this;
        //else
        //      printf("VFS_cron not subpath: %s\n",qUtf8Printable(r->_path));
 
        if (r->_metadata["createIfMissing"].toBool())
                return this;
 
        if (r->_path == "")
                return this;
 
        return VFS_node::find(r);
}
 
QString VFS_cron::reportDetails()
{
        QMutexLocker l(&_lock);
 
        QStringList r;
        QMapIterator<QString, crontime> i(_crontab);
        while (i.hasNext()) {
            i.next();
            r << i.key() + ":\n"+i.value().toString();
        }
 
        if (r.isEmpty())
                return "(no events)";
 
        return r.join("\n");
}
 
bool VFS_cron::isContainer()
{
        return true;
}
 
QByteArray VFS_cron::icon()
{
        return VFS_icons::get("clock");
}
 
void VFS_cron::initialize()
{
        QTime now = QTime::currentTime();
        QTime next = QTime::currentTime();
        next.setHMS(next.hour(),next.minute(),next.second(),0);
        next = next.addSecs(1);
 
        //int w = 1000 - now.msec() - 10;
        int w = now.msecsTo(next) - 5;
        w = qMax(0,w);
 
        QTimer::singleShot(w,Qt::PreciseTimer,this,SLOT(startCron()));                  //try to start at the beginning of the wall-clock second
}
 
void VFS_cron::startCron()
{
        //A sleep loop in case the timer fired early... may want to use QThread::wait() instead
        QTime now = QTime::currentTime();
        while (now.msec() != 0)
        {       QThread::usleep(1);
                now = QTime::currentTime();
        }
 
        _cronID = startTimer(1000,Qt::PreciseTimer);
}
 
void VFS_cron::timerEvent(QTimerEvent *event)
{
        Q_UNUSED(event)
 
        if (!_crontab.size())                                   //only if we have events to track
                return;
 
        if (!_subscribers.size())                               //only if we have subscribers
                return;
 
        //QDateTime now = QDateTime::currentDateTimeUtc();      //how do we deal with time zones?
        QDateTime now = QDateTime::currentDateTime();
        QTime nowt = now.time();
        QDate nowd = now.date();
        quint8 second = nowt.second();
        quint8 minute = nowt.minute();
        quint8 hour = nowt.hour();
        quint8 date = nowd.day();
        quint8 month = nowd.month();
        quint8 weekday = nowd.dayOfWeek() % 7;  // Sunday = 0
        quint16 year = nowd.year();
 
        for( QMultiMap<QString, crontime>::iterator i = _crontab.begin();
                i != _crontab.end();
                ++i
        )
        {
                QString event = i.key();
                crontime time = i.value();
 
                if (_subscribers.contains(event))               //only if we have subscribers
                if (time.matches(second,minute,hour,date,month,weekday,year))
                {
                        VFS::LOG( QString("%1 event: '%2' %3").arg(className()).arg(event).arg(now.toString()), 9, "cron" );
 
                        //printf("event:   %s\n%s",qUtf8Printable(event),qUtf8Printable(time.toString()));
 
                        QJsonObject o;
                        o["time"] = QDateTime::currentDateTime().toMSecsSinceEpoch();
 
                        VFS_request *r = createRequest(VFS_request::diff,event,"cron",QJsonDocument(o));
                        r->_metadata["type"] = "cron";
                        emit diff(this,r);
                        delete r;
                }
        }
}
 
void VFS_cron::parseCrontab(QString tab)
{
        QStringList entries = tab.split("|",Qt::SkipEmptyParts);
        QString entry;
        QString event;
 
        for (int i=0;i<entries.length();i++)
        {
                QStringList e = entries[i].split(":",Qt::SkipEmptyParts);
                if (e.length() != 2)
                        VFS::ERROR( QString("%1 bad crontab entry: \"%2\"").arg(className()).arg(entries[i]) );
                else
                {
                        event = e[0].trimmed();
                        crontime time(e[1]);
 
                        if (time.valid())
                                _crontab.insert(event,time);
                }
        }
}
 
void VFS_cron::subscribe(VFS_request *r)
{
        //FIXME: if two subscriptions to the same event have different crontimes, the second entry
        //               will not be created... _crontab.contains() is not a complete enough test because
        //               of insertMulti below.
 
        if (!_crontab.contains(r->_path))
        if (r->_metadata["createIfMissing"].toBool())
        {
                QJsonObject o = r->_data.object();
 
                for(QJsonObject::iterator i=o.begin();
                        i!=o.end();
                        ++i
                )
                {
                        QString event = i.key();
                        crontime time(i.value().toString());
 
                        if (time.valid())
                        {       _crontab.insert(event,time);
                                //VFS::WARN( QString("Adding crontab entry: %1\n%2").arg(event).arg(time.toString()) );
                        }
                        //else
                        //      VFS::WARN( "Not adding invalid crontab entry..." );
                }
        }
 
        if (_crontab.contains(r->_path) || r->_path == "")
                VFS_node::subscribe(r);
        else
        {       r->_success = false;
                r->_reason = QString("%1 unknown event: '%2'.  Not subscribing.").arg(className()).arg(r->_path);
        }
}
 
void VFS_cron::ls(VFS_request *r)
{
        read(r);
}
 
void VFS_cron::read(VFS_request *r)
{
        if (r->_path == "")
        {
                QVariantMap o;
 
                for( QMultiMap<QString, crontime>::iterator i = _crontab.begin();
                        i != _crontab.end();
                        ++i
                )
                {
                        o[i.key()] = false;                                             //entries are not containers, so false.
                }
 
                r->_data = QJsonDocument::fromVariant(o);
                r->_success = true;
                return;
        }
 
        if (_crontab.contains(r->_path))
        {
                QVariantMap o;
 
                if (r->_requestType == VFS_request::read)
                        o["crontime"] = _crontab.value(r->_path).toCrontime();
                else if (r->_requestType == VFS_request::ls)
                {       //leave o empty, which is equivalent to having no children
                }
 
                r->_data = QJsonDocument::fromVariant(o);
                r->_success = true;
                return;
        }
 
        r->_success = false;
        r->_reason = QString("%1 unknown path/event: '%2'.  Can't read.").arg(className()).arg(r->_path);
}
 
void VFS_cron::unsubscribe(VFS_request *r)
{
        //there's actually nothing to do here... unsubscription based on path will happen automagically
 
        VFS_node::unsubscribe(r);
}
 
VFS_cron::crontime::crontime(QString spec)
//, _valid(false)
{
        QString c = spec.trimmed();
        QStringList fields = c.split(QRegExp("\\s+"),Qt::SkipEmptyParts);
 
        _valid = true;
 
        _seconds = parseField(fields.value(0,"*"));
        _minutes = parseField(fields.value(1,"*"));
        _hours =   parseField(fields.value(2,"*"));
        _dates =   parseField(fields.value(3,"*"));
        _months =  parseField(fields.value(4,"*"));
        _weekdays = parseField(fields.value(5,"*"));
        _years =   parseYear(fields.value(6,"*"));
 
        _dates[0] = true;
        _months[0] = true;
}
 
quint64 VFS_cron::crontime::parseField(QString field)
{
        quint64 mask = 0;
 
        QStringList parts = field.split(",",Qt::SkipEmptyParts);
 
        for(int i=0;i<parts.length();i++)
                mask |= parseRange(parts[i]);
 
        return mask;
}
 
quint64 VFS_cron::crontime::parseRange(QString range)
{
        quint64 mask = 0;
 
        if (range.contains('*'))
                return mask = 0xFFFFFFFFFFFFFFFF;
 
        QStringList r = range.split("-",Qt::SkipEmptyParts);
 
        if (r.length() == 1)
        {
                bool ok;
                int v = r[0].trimmed().toInt(&ok);
                if (ok && v>=0)
                        mask |= (ulong) 1 << v;
        }
        else if (r.length() == 2)
        {
                bool ok1,ok2;
                int s = r[0].trimmed().toInt(&ok1);
                int e = r[1].trimmed().toInt(&ok2);
                int start = qMin(s,e);
                int end = qMax(s,e);
 
                if (ok1 && ok2 && start>=0 && end>=0)
                        for (int i=start;i<=end;i++)
                                mask |= 1 << i;
                else
                {       VFS::ERROR( QString("%1 bad crontab range: \"%2\"").arg("crontime").arg(range) );
                        _valid = false;
                }
        }
        else
        {       VFS::ERROR( QString("%1 bad crontab range: \"%2\"").arg("crontime").arg(range) );
                _valid = false;
        }
 
        return mask;
}
 
QList<quint16> VFS_cron::crontime::parseYear(QString y)
{
        QList<quint16> l;
 
        if (y.contains("*"))
                return l;                                       //an empty list matches all years
 
        QStringList parts = y.split(",",Qt::SkipEmptyParts);
        quint16 v;
 
        for (int i=0;i<parts.length();i++)
        {
                QString part = parts[i];
                QStringList r = part.split("-",Qt::SkipEmptyParts);
 
                if (r.length() == 1)
                {
                        bool ok;
                        v = r[0].trimmed().toInt(&ok);
                        if (ok)
                                l << v;
                }
                else if (r.length() == 2)
                {
                        bool ok1;
                        bool ok2;
                        int s = r[0].trimmed().toInt(&ok1);
                        int e = r[0].trimmed().toInt(&ok2);
                        int start = qMin(s,e);
                        int end = qMax(s,e);
 
                        if (ok1 && ok2 && start>=0 && end>=0)
                                for (int i=start; i<=end; i++)
                                        l << i;
                        else
                        {       VFS::ERROR( QString("%1 bad crontab range: \"%2\"").arg("crontime").arg(part) );
                                _valid = false;
                        }
                }
                else
                {       VFS::ERROR( QString("%1 bad crontab range: \"%2\"").arg("crontime").arg(part) );
                        _valid = false;
                }
        }
 
        return l;
}
 
bool VFS_cron::crontime::valid()
{
        return _valid;
}
 
bool VFS_cron::crontime::matches(quint8 s, quint8 m, quint8 h, quint8 d, quint8 mo, quint8 w, quint16 y)
{
        if (
                ( _valid )                                      &&
                ( _years.isEmpty() || _years.contains(y) )      &&
                ( _weekdays[w] )                                &&
                ( _months[mo] )                                 &&
                ( _dates[d] )                                   &&
                ( _hours[h] )                                   &&
                ( _minutes[m] )                                 &&
                ( _seconds[s] )
         )
                return true;
 
        return false;
}
 
QString VFS_cron::crontime::toString() const
{
        std::string s;
 
        s += "Seconds:  "+_seconds.to_string() + "\n";
        s += "Minutes:  "+_minutes.to_string() + "\n";
        s += "Hours:    "+_hours.to_string() + "\n";
        s += "Dates:    "+_dates.to_string() + "\n";
        s += "Months:   "+_months.to_string() + "\n";
        s += "Weekdays: "+_weekdays.to_string() + "\n";
 
        s += "Years:    ";
 
        QString q = QString::fromStdString(s);
 
        if (_years.length())
                for(int i=0; i<_years.length(); i++)
                        q += QString::number(_years[i]) + (i==_years.length()-1?",":"");
        else
                q += "(all years)";
 
        q += "\n";
 
        return q;
}
 
QString VFS_cron::crontime::toCrontime() const
{
        QString t;
 
        t += toCrontimeString("seconds") + " ";
        t += toCrontimeString("minutes") + " ";
        t += toCrontimeString("hours") + " ";
        t += toCrontimeString("dates") + " ";
        t += toCrontimeString("months") + " ";
        t += toCrontimeString("weekdays") + " ";
        t += toCrontimeString("years");
 
        return t;
}
 
QString VFS_cron::crontime::toCrontimeString(QString which) const
{
        QString s;
 
        if (which == "seconds") {       if (_seconds.all())
                                                s = "*";
                                        else
                                                for (size_t i=0;i<_seconds.size(); i++)
                                                        s += QString("%1,").arg(i);
                                }
 
        if (which == "minutes") {       if (_minutes.all())
                                                s = "*";
                                        else
                                                for (size_t i=0;i<_minutes.size(); i++)
                                                        s += QString("%1,").arg(i);
                                }
 
        if (which == "hours")   {       if (_hours.all())
                                                s = "*";
                                        else
                                                for (size_t i=0;i<_hours.size(); i++)
                                                        s += QString("%1,").arg(i);
                                }
 
        if (which == "dates")   {       if (_dates.all())
                                                s = "*";
                                        else
                                                for (size_t i=1;i<_dates.size(); i++)
                                                        s += QString("%1,").arg(i);
                                }
 
        if (which == "months")  {       if (_months.all())
                                                s = "*";
                                        else
                                                for (size_t i=1;i<_months.size(); i++)
                                                        s += QString("%1,").arg(i);
                                }
 
        if (which == "weekdays"){       if (_weekdays.all())
                                                s = "*";
                                        else
                                                for (size_t i=0;i<_weekdays.size(); i++)
                                                        s += QString("%1,").arg(i);
                                }
 
        if (which == "years")   {       if (_years.isEmpty())
                                                s = "*";
                                        else
                                                for (int i=0;i<_years.size(); i++)
                                                        s += QString("%1,").arg(_years[i]);
                                }
 
        if (s.endsWith(','))
                s.chop(1);
 
        return s;
}