ZblCog.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2014 Bob Dinitto
 *
 * Filename:   ZblCog.cpp
 * Created on: 12/10/2014
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZblCog.h"
#include "ZblSprocket.h"
#include "ZblException.h"
#include "ZblFactory.h"
#include "ZblResource.h"
#include "zglobal.h"
#include <QDebug>
#include <QXmlQuery>
#include <QXmlResultItems>
#include <QXmlItem>
#include <QFile>
#include <QPluginLoader>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>


//#include <QResource>

namespace Zbl
{

ZblCog* ZblCog::m_zCog = 0;

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZblCog)

const QString ZblCog::m_commandSeparator = "::";
const QString ZblCog::m_actionMap = "map";
const QString ZblCog::m_actionQmlregister = "register";
const QString ZblCog::m_actionIgnore = "ignore";
const QString ZblCog::m_restypeInvalid = "invalid";
const QString ZblCog::m_restypeFile = "file";
const QString ZblCog::m_restypePlugin = "plugin";

const int ZblCog::m_paramcountFile = 4;
const int ZblCog::m_paramcountPlugin = 1;

ZblCog::ZblCog(QObject *parent) :
    QObject(parent)
{
    ZBL_REGISTER_LOGGED_OBJECT

    if(m_zCog)
        throw ZblException(
          "Zbl::ZblCog::Zblcore programming error: "
                "Only one instance of ZblCog class should exist per linux process.");

    m_zCog = this;
}

ZblCog::~ZblCog()
{
    QWriteLocker lock(&m_lock);

    QList<ZblSprocket*> sprockets(m_sprockets.values());

    for(int i=0; i < sprockets.size(); i++)
        delete sprockets.at(i);

    QList<ZblResource*> resources(m_resources.values());

    for(int i=0; i < resources.size(); i++)
        delete resources.at(i);

    m_zCog = NULL;
}

bool ZblCog::registerSprocket(const char* uri,
                              int versionMajor,
                              int versionMinor)
{
    zDebug() << "ZblCog::registerSprocket:"
    << ZblSprocket::sprocketTag(uri, versionMajor, versionMinor);

    ZblSprocket* sv = NULL;

    try
    {
        QWriteLocker lock(&m_lock);

        const ZblSprocket* previous = m_sprockets.value(uri, NULL);

        if(previous)
        {
           zWarning() << "ZblCog::registerSprocket FAILED: sprocket already"
            "registered as: " << previous->sprocketTag();

            return false;
        }

        sv = new ZblSprocket(uri, versionMajor, versionMinor);

        if(!sv)
        {
            zWarning() << "ZblCog::registerSprocket FAILED: can't create "
                        "sprocket object";

            return false;
        }

        m_sprockets.insert(uri, sv);

    }
    catch(...)
    {
        if(sv)
            delete sv;

        return false;
    }

    return true;
}

bool ZblCog::registerSprocketObject(
        const char* uri,
        int versionMajor,
        int versionMinor,
        const char* qmlName,
        sprocketObjectConstructor createFunc)
{
    QReadLocker lock(&m_lock);

    ZblSprocket* sprock = m_sprockets.value(uri, NULL);

    if(!sprock)
    {
        zWarning() << "ZblCog::registerSprocketObject FAILED: "
                      "no sprocket plugin is registered for uri: "
                      << uri << "; Call Zbl::ZblCog::registerSprocket "
                         "before calling this method.";
        return false;
    }

    return sprock->registerSprocketObject(
                uri, versionMajor, versionMinor, qmlName, createFunc);
}

ZblFactory* ZblCog::createFactory(
        const char* sprocketUri,
        int versionMajor,
        int versionMinor,
        QObject* parent)
{
    QReadLocker lock(&m_lock);

    ZblSprocket* s = m_sprockets.value(sprocketUri, NULL);

    if(!s)
    {
        zWarning() << "ZblCog::createFactory FAILED: no sprocket plugin "
                      "exists for uri: " << sprocketUri;
        return NULL;
    }

    ZblFactory* f = new ZblFactory(versionMajor, versionMinor, parent);

    if(!f)
    {
        zWarning() << "ZblCog::createFactory FAILED: can't construct "
                      "ZblFactory object";

        return NULL;
    }

    QList<QString> foundaryKeys(s->m_objects.keys());

    for(int i=0; i < foundaryKeys.size(); i++)
    {
        const QString qmlName(foundaryKeys.at(i));

        ZblSprockOb* sproc = s->findSprock(
         versionMajor, versionMinor, cStr(qmlName));

        if(sproc)
            f->m_objectFunctions.insert(qmlName, sproc);
    }

    if(f->m_objectFunctions.isEmpty())
    {
        zWarning() <<
        "ZblCog::createFactory WARNING: Sprocket contains no objects";
    }

    return f;
}

bool ZblCog::mapResource(
        const char* uri,
        int versionMajor,
        int versionMinor,
        const char* fileName)
{
    ZblResource* rs = NULL;

    const QString key(ZblSprocket::sprocketTag(
                          uri, versionMajor, versionMinor));

    zDebug() << "ZblCog::mapResource - mapping resource: "
                << key;

    try
    {
        QWriteLocker lock(&m_lock);

        const ZblResource* previous = m_resources.value(key, nullptr);

        if(previous)
        {
           zWarning() << "ZblCog::mapResource FAILED: resource already"
            "registered as: " << key;

            return false;
        }

        rs = new ZblResource(uri, versionMajor, versionMinor, fileName);

        if(!rs)
        {
            zWarning() << "ZblCog::registerResource FAILED: can't create "
                        "resource object for resource: " << key;

            return false;
        }

        if(!rs->validate())
        {
            zWarning() << "ZblCog::mapResource FAILED: can't locate "
                        "resource file: " << fileName <<
                        " for resource: " << key;

            delete rs;

            return false;
        }

        m_resources.insert(key, rs);

    }
    catch(...)
    {
        if(rs)
            delete rs;

        return false;
    }

    zDebug() << "ZblCog::mapResource - mapped resource: "
                << key;

    return true;
}

bool ZblCog::mapPluginResources(const char* fileName, bool qmlRegister)
{

    static const QString label("ZblCog::mapPluginResources");

    // locate zblconfig file

    if(!fileName)
    {
        zWarning() << label << " - FAILED - " <<
                      "invalid configuration file path: NULL";
        return false;
    }

    zDebug() << "Mapping plugin file resources: "
                << fileName;

    QPluginLoader loader;

    loader.setFileName(fileName);

    QJsonObject metaObject = loader.metaData();


// start debug code
    QJsonDocument doc(metaObject);

    QByteArray ba = doc.toJson();

    zDebug() << "plugin metadata = " << ba.constData();
    zDebug() << "plugin file name = " << loader.fileName();
// end debug code

    bool failed = false;

    QJsonObject metaData = metaObject.value("MetaData").toObject();

    QJsonArray resourceBundle = metaData.value("Resources").toArray();

    if(resourceBundle.isEmpty())
    {
        zWarning() << label
        << " - WARNING: plugin file %s has no resource metadata: "
        << fileName;

        return false;
    }

    zDebug() << "got resource metadata!";

    const int bundleSize = resourceBundle.size();

    for(int i=0; i < bundleSize; i++)
    {
        QJsonValue nextResource;

        nextResource = resourceBundle.at(i);

        QString uri;
        QString fileName;
        QString vMajor;
        QString vMinor;

        if(getPluginResParams(nextResource, uri, fileName, vMajor, vMinor))
        {
            zDebug() << label << "processing resource metadata: " << uri;

            bool numOK;

            int numMajor = vMajor.toInt(&numOK);

            if(!numOK)
            {
                zWarning() << label
                << " - WARNING - can't load resource, metadata has invalid value - "
                "major-version should be an integer string, ie \"1\","
                " instead it was: "
                << vMajor;



                failed = true;
                continue;
            }

            int numMinor = vMinor.toInt(&numOK);

            if(!numOK)
            {
                zWarning() << label
                << " - WARNING - can't load resource, metadata has invalid value - "
                "minor-version should be an integer string, ie \"0\","
                " instead it was: "
                << vMinor;

                failed = true;
                continue;
            }

            if(!mapResource(cStr(uri), numMajor, numMinor, cStr(fileName)))
            {
                zWarning() << label
                << " - WARNING - Zuble failed to map resource: "
                << uri;

                failed = true;
                continue;
            }
            else if(qmlRegister)
            {
                if(!registerResource(cStr(uri), numMajor, numMinor))
                {
                    zWarning() << label
                    << " - WARNING - Qt failed to register resource: "
                    << uri;

                    failed = true;
                }
            }
        }
        else
        {
            zWarning() << label
            << " - WARNING - resource metadata was invalid for plugin file: "
            << fileName;

            failed = true;
        }

    } // end for

    return !failed;
}

bool ZblCog::getPluginResParams(const QJsonValue& resourceValue,
                                QString& uri,
                                QString& fileName,
                                QString& versionMajor,
                                QString& versionMinor)
{
    static const QString uriName("uri");
    static const QString filenameName("fileName");
    static const QString vMajorName("version-major");
    static const QString vMinorName("version-minor");

    if(resourceValue.isObject())
    {
        QJsonObject resObject(resourceValue.toObject());

        if(!getPluginStringParam(resObject, uriName, uri))
            return false;
        if(!getPluginStringParam(resObject, filenameName, fileName))
            return false;
        if(!getPluginStringParam(resObject, vMajorName, versionMajor))
            return false;
        if(!getPluginStringParam(resObject, vMinorName, versionMinor))
            return false;
    }

    return true;
}

bool ZblCog::getPluginStringParam(const QJsonObject& resource,
                                  const QString& paramKey,
                                  QString& outValue)
{
    QJsonValue value;

    value = resource.value(paramKey);

    if(value.isString())
    {
        outValue = value.toString();
        return true;
    }

    return false;
}

bool ZblCog::mapConfigResources(const char* configFilePath)
{

    static const QString label("ZblCog::mapConfigResources");

    // locate zblconfig file

    if(!configFilePath)
    {
        zWarning() << "ZblCog::mapAppResources - FAILED - " <<
                      "invalid configuration file path: NULL";
        return false;
    }

    zDebug() << "Mapping configuration file resources: "
                << configFilePath;


    QFile cfg(configFilePath);

    if(!cfg.exists())
    {
        warnAbortingResourceLoad(label,
        QString("Nonexistent configuration file: %1").arg(configFilePath));

        return false;
    }

    // create query

    QXmlQuery xq;

    QUrl url(QUrl::fromLocalFile(configFilePath));

    zDebug() << label << "setting XQuery focus to config file: " << url.path();

    QString query = "declare default element namespace 'http://zuble.org/schema/zuble/zblconfig'; \n"
            "declare function local:pluginElement($action as xs:string, $pe as element()?) as xs:string* \n"
            "{ (string-join(($action,\"plugin\",\"1\"),\"::\"),xs:string($pe/filename)) }; \n"
            "declare function local:fileElement($action as xs:string, $fe as element()?) as xs:string* \n"
            "{ (string-join(($action,\"file\",\"4\"), \"::\"), \n"
            " xs:string($fe/uri), xs:string($fe/version-major), \n"
            " xs:string($fe/version-minor),xs:string($fe/filename)) }; \n"
            "for $map in /zblconfig/resources/resource-map \n"
             " let $plugin := $map/plugin let $file := $map/file \n"
            " return (if($plugin) then local:pluginElement($map/@action,$plugin) \n"
            " else if($file) then local:fileElement($map/@action,$file) \n"
            " else string-join((\"ignore\",\"invalid\",\"0\"), \"::\"))";


    bool status = xq.setFocus(url);

    if(!status)
    {
         warnAbortingResourceLoad(label,
         QString("QXmlQuery can't load configuration file: %1").arg(url.path().toUtf8().constData()));

         return false;
    }

    zDebug() << "Query=" << query;

    xq.setQuery(query);

    if(!xq.isValid())
    {
        warnAbortingResourceLoad(label,
        QString("Programming error: invalid XQuery: %1").arg(query.toUtf8().constData()));

        return false;
    }

    // evaluate results

    QStringList xmlResults;

    xq.evaluateTo(&xmlResults);

    const int count = xmlResults.count();

    zDebug() << "Dumping XQuery evaluation results ++++++++++++++++++++++++++";

    for(int x=0; x<count; x++)
        zDebug() << xmlResults.at(x).toUtf8().constData();

    //    qDebug("Evaluated to: %s", xmlResults.at(x).toUtf8().constData());

    zDebug() << "End dumping XQuery evaluation results ++++++++++++++++++++++++++";




    for(int j=0; j<count; j++)
    {
        const QStringList command(xmlResults.at(j).split(m_commandSeparator));

        //const int fieldCount = command.count();

        if(command.count() != commandFieldCount)
        {
            warnInvalidResourceCommand(label, xmlResults.at(j));

            warnAbortingResourceLoad(label, "invalid command format");

            return false;
        }

        const QString& strAction(command.at(cmdAction));
        const QString& strResourceType(command.at(cmdResourceType));
        const QString& strSize(command.at(cmdRecordSize));


        zDebug() << "Resource command - Action: " << strAction
                 << "Type: " << strResourceType
                 << "Size: " << strSize;

        bool intOK;

        const int size = strSize.toInt(&intOK);

        if(!intOK)
        {
            zWarning() <<
            "ZblCog::mapConfigResources - WARNING: invalid command format, "
            "third field should contain an integer specifying the number "
            "of command parameter strings that follow this command string "
            "in the string array: "
            << xmlResults.at(j);

            warnAbortingResourceLoad(label, "invalid command format");

            return false;
        }

        if(strAction == m_actionIgnore)
        {
            zWarning() << "ZblCog::mapConfigResources - "
                          "WARNING: invalid XML configuration file format - "
                          "an invalid XML node or text was encountered and ignored "
                          "by the XQuery.";

            j += size;

            continue;

        }
        else if(strAction != m_actionMap && strAction != m_actionQmlregister )
        {
            zWarning() << "ZblCog::mapConfigResources - "
                          "WARNING: invalid command format - skipping this command -"
                          "first field should contain a valid action string - "
                          "instead it contained: " << strAction;

            warnInvalidResourceCommand(label, xmlResults.at(j));

            j += size;

            continue;
        }

        if(strResourceType == m_restypePlugin)
        {
            if(!validateParamCount(size, m_paramcountPlugin))
            {
                warnInvalidResourceCommand(label, xmlResults.at(j));

                warnAbortingResourceLoad(label, "invalid command format");

                return false;
            }

            bool loadPlugin = strAction == m_actionQmlregister;

            if(!mapPluginResources(
                xmlResults.at(j+pluginName).toUtf8().constData(),
                loadPlugin))
            {
                zWarning() <<
                "ZblCog::mapConfigResources - "
                "WARNING: failed to map plugin resources for plugin: "
                 << xmlResults.at(j+pluginName);
            }
        }
        else if(strResourceType == m_restypeFile)
        {
            // loading a resource file

            if(!validateParamCount(size, m_paramcountFile))
            {
                warnInvalidResourceCommand(label, xmlResults.at(j));

                warnAbortingResourceLoad(label, "invalid command format");

                return false;
            }

            // convert versionMajor and versionMinor to integers

            const int versionMajor = xmlResults.at(j+fileVersionMajor).toInt(&intOK);

            if(!intOK)
            {
                zWarning() <<
                "ZblCog::mapConfigResources - WARNING: invalid file resource parameter - "
                "version-major should contain an integer specifying the major "
                "version number of the resource file to be mapped - "
                "instead it contains: "
                << xmlResults.at(j+fileVersionMajor);

                warnAbortingResourceLoad(label, "invalid parameter");

                return false;
            }

            const int versionMinor = xmlResults.at(j+fileVersionMinor).toInt(&intOK);

            if(!intOK)
            {
                zWarning() <<
                "ZblCog::mapConfigResources - WARNING: invalid file resource parameter - "
                "version-mainor should contain an integer specifying the minor "
                "version number of the resource file to be mapped - "
                "instead it contains: %s"
                << xmlResults.at(j+fileVersionMinor);

                warnAbortingResourceLoad(label, "invalid parameter");

                return false;
            }

            if(!mapResource(
                        xmlResults.at(j+fileUri).toUtf8().constData(),
                        versionMajor,
                        versionMinor,
                        xmlResults.at(j+fileName).toUtf8().constData()))
            {
                zWarning() <<
                "ZblCog::mapConfigResources - "
                "WARNING: failed to map file resources for file: "
                << xmlResults.at(j+fileName);
            }
            else if(strAction == "load")
            {

                if(!registerResource(
                            xmlResults.at(j+fileUri).toUtf8().constData(),
                            versionMajor,
                            versionMinor))
                {
                    zWarning() << "ZblCog::mapConfigResources - "
                    "WARNING: failed to register resources for uri: "
                    << xmlResults.at(j+fileUri);
                }

            }
        }
        else
        {
            // neither resource file or plugin resource was specified

            zWarning() << "ZblCog::mapConfigResources - "
                          "WARNING: invalid command format - "
                          "second field should contain a valid resource type string.";

            warnInvalidResourceCommand(label, xmlResults.at(j));

            warnAbortingResourceLoad(label, "invalid command format");

            return false;
        }

        j += size;

    } // end for

    zDebug() << "Done mapping configuration file resources";

    return true;

}

bool ZblCog::validateParamCount(int actual, int required)
{
    if(actual == required)
        return true;

    zWarning() << "ZblCog::validateParamCount - "
    "WARNING: invalid parameter count - command required "
    << required << " paramaters but " << actual << " were passed.";

    return false;

}

void ZblCog::warnInvalidResourceCommand(const QString& label, const QString& command)
{
    zWarning() << label <<
    " - WARNING: invalid resource command format - "
    "command strings should have exactly three fields as follows: "
    "[action]::[recordType]::[parameterCount] where: "
    "action=\"map\"|\"load\" resourceType=\"file\"|\"plugin\" "
    "parameterCount=[integer number of parameters following this command.]"
    " INVALID COMMAND STRING="
     << command;

 }

void ZblCog::warnAbortingResourceLoad(
        const QString& label, const QString& reason)
{
    zWarning() << label
    << " - WARNING -  ABORTING configuration resource load operation! "
    << reason;
}


QString ZblCog::getNodeName(const QXmlItem& item, const QXmlQuery& query)
{
    // TBD: deprecated! don't use QXmlItems! Qt implementation too flaky!

    QString retval;

    if(!item.isNode())
        return retval;

    QXmlNodeModelIndex index(item.toNodeModelIndex());

    const QAbstractXmlNodeModel* model = index.model();

    QXmlName name(model->name(index));

    retval = name.localName();

    return retval;

}

bool ZblCog::registerResource(
        const char* uri, int versionMajor, int versionMinor)
{


    bool status = false;

    ZblResource* rs = NULL;

    const QString key(ZblSprocket::sprocketTag(
                          uri, versionMajor, versionMinor));

    zDebug() << "ZblCog::registerResource - registering resource: "
                << key;


    try
    {
        QReadLocker lock(&m_lock);

        rs = m_resources.value(key, NULL);

        if(!rs)
        {
           zWarning() << "ZblCog::registerResource FAILED: resource not mapped: "
                      << key;

            return false;
        }

        if(!rs->validate())
        {
            zWarning() << "ZblCog::loadResource FAILED: can't access "
                        "resource file: " << rs->fileName() <<
                        " for resource: " << key;

            return false;
        }

        status = rs->load();

        //m_resources.insert(key, rs);

    }
    catch(...)
    {
         return false;
    }

    zDebug() << "ZblCog::loadResource - loadResource resource: "
                << key;

    return status;
}

bool ZblCog::isMappedResource(
        const char* uri,
        int versionMajor,
        int versionMinor)
{
    try
    {
        QReadLocker lock(&m_lock);

        if(versionMajor != -1 && versionMinor != -1)
        {
            // use both version numbers in test

            const QString key(ZblSprocket::sprocketTag(
                                  uri, versionMajor, versionMinor));

            return m_resources.contains(key);
        }

        // use no version number in test

        QString prefix(uri);
        prefix += ":";

        if(versionMajor != -1)
        {
            // add major version number to test

            prefix += QString::number(versionMajor);
            prefix += ":";
        }

        QStringList keys(m_resources.keys());

        keys = keys.filter(prefix);

        return !keys.isEmpty();
    }
    catch(...)
    {
         throw ZblException("ZblCog::isMappedResource - unknown exception");
    }

    return false;
}


QStringList ZblCog::getMappedResources()
{
    QReadLocker lock(&m_lock);

    return m_resources.keys();
}


ZblCog& ZblCog::zInit(QObject* parent)
{
    //throw ZblException("how do you like me now?");

    if(m_zCog)
        throw ZblException(
                "Zbl::ZblCog::zInstance programming error: "
                      "Singleton ZblCog object already initialized!");

    m_zCog = new ZblCog(parent);

    return *m_zCog;
}


ZblCog& ZblCog::zInstance()
{
    if(!m_zCog)
        throw ZblException(
          "Zbl::ZblCog::zInstance programming error: "
                "Singleton ZblCog object not initialized! "
                "Call ZblCog::zInit before calling this method.");

    return *m_zCog;
}


} // Zbl