VFS_httpd_browser.cpp

Go to the documentation of this file.

 
#include <QFileInfo>
#include <QCoreApplication>
#include <QHostInfo>
#include <QProcess>
 
#include "VFS_httpd_browser.h"
 
#include "qhttpserver.h"
#include "qhttprequest.h"
#include "qhttpresponse.h"
 
#include "VFS.h"
 
VFS_httpd_browser::VFS_httpd_browser(QString dataRootPath, quint16 port, QHostAddress addr, bool ssl, QString sslCertPath, QString sslKeyPath)
: VFS_httpd(port,addr,ssl,sslCertPath,sslKeyPath)
, _dataRootPath(dataRootPath)
, _dataRoot(nullptr)
{
}
 
VFS_httpd_browser::~VFS_httpd_browser()
{
}
 
void VFS_httpd_browser::handle(QHttpRequest *req, QHttpResponse *resp)
{
        VFS::LOG( QString("Request: %1").arg(req->url().toString()), 8, className() );
 
        VFS_httpd_browser_responder *r = new VFS_httpd_browser_responder(req, resp, dataRoot(), _port);         //as a new object so it can delete itself later
 
        if (r->_needsToIssueRequest)
        {
                VFS_node *_node = dataRoot();
 
                if (r->_mode == "browse")
                {
                        VFS_httpd_browser_request *t = new VFS_httpd_browser_request(VFS_request::ls,this,r);
                        QString p = r->_path.mid(strlen("/browse"));
                        p = QUrl::fromPercentEncoding(p.toUtf8());
                        t->_path = p;
                        issueRequest(_node,t);
                }
                else if (r->_mode == "report")
                {
                        VFS_httpd_browser_request *t = new VFS_httpd_browser_request(VFS_request::report,this,r);
                        QString p = r->_path.mid(strlen("/report"));
                        p = QUrl::fromPercentEncoding(p.toUtf8());
                        t->_path = p;
                        issueRequest(_node,t);
                }
                else if (r->_mode == "read")
                {
                        VFS_httpd_browser_request *t = new VFS_httpd_browser_request(VFS_request::read,this,r);
                        QString p = r->_path.mid(strlen("/read"));
                        p = QUrl::fromPercentEncoding(p.toUtf8());
                        t->_path = p;
                        issueRequest(_node,t);
                }
                else
                {
                        r->_status = 400;       //Bad Request
                        r->respond();
                }
        }
        else
                r->respond();
}
 
VFS_node *VFS_httpd_browser::dataRoot()
{
        if (_dataRoot) return _dataRoot;
 
        VFS_request r(VFS_request::none,nullptr,_dataRootPath,"httpd_browser");
        _dataRoot = VFS::root()->find(&r);
        _dataRootPath = r._path;
 
        return _dataRoot;
}
 
VFS_httpd_browser_request::VFS_httpd_browser_request(VFS_request::requestType type, VFS_node *t, VFS_httpd_browser_responder *r)
: VFS_request(type,t,"","httpd_browser")
, _m_responder(r)
{
}
 
VFS_httpd_browser_request::~VFS_httpd_browser_request()
{
        //printf("HTTP BROWSER REQUEST DELETE\n");
}
 
void VFS_httpd_browser_request::execute()
{
        //printf("HTTPD RESPONDER!\n");
 
        if (_success)
        {
                _m_responder->_data = _data;
        }
        else
        {
                _m_responder->_status = 404;
                VFS::WARN( QString("'%1' Status: %2: %3").arg(_m_responder->_path).arg(_m_responder->_status).arg(STATUS_CODES.value(_m_responder->_status)), 0, "httpd_browser" );
                VFS::WARN( _reason, 0, "httpd_browser" );
        }
 
        _m_responder->respond();
}
 
VFS_httpd_browser_responder::VFS_httpd_browser_responder(QHttpRequest *req, QHttpResponse *resp, VFS_node *node, quint16 port)
: VFS_httpd_responder(req,resp)
, _needsToIssueRequest(false)
, _done(false)
, _process(false)
, _node(node)
, _port(port)
{
        connect(_m_req, SIGNAL(data(const QByteArray&)), this, SLOT(accumulate(const QByteArray&)), Qt::UniqueConnection);
        connect(_m_resp, SIGNAL(done()), this, SLOT(done()), Qt::UniqueConnection);
 
        validatePath(_m_req->url());            //sets url and path
}
 
VFS_httpd_browser_responder::~VFS_httpd_browser_responder()
{
}
 
void VFS_httpd_browser_responder::done()
{
        _done = true;
 
        deleteLater();
}
 
void VFS_httpd_browser_responder::respond()
{
        if (_done)
                return;
 
//      connect(_m_req, SIGNAL(data(const QByteArray&)), this, SLOT(accumulate(const QByteArray&)), Qt::UniqueConnection);
        //connect(_m_req, SIGNAL(end()), this, SLOT(reply()));
        //connect(_m_req, SIGNAL(end()), _m_resp, SLOT(end()));
//      connect(_m_resp, SIGNAL(done()), this, SLOT(done()), Qt::UniqueConnection);
 
        switch(_status)
        {
                case 200:       {       QByteArray page = fetchResponse();
                                        _m_resp->setHeader("Content-Type", _mime);
                                        _m_resp->writeHead(_status);
                                        _m_resp->write(page);
                                        _m_resp->end();
                                }
                                break;
 
                default:        {       _m_resp->writeHead(_status);
                                        _m_resp->end(errorPage());
                                }
                                break;
        }
}
 
void VFS_httpd_browser_responder::validatePath(QUrl url)
{
        _url = url;
        _path = _url.path();
 
        if (_path=="/") _path="/index.rhtml";
 
        if (_path.startsWith("/browse"))
        {
                _status = 200;
                _mime = "text/html";
                _mode = "browse";
                _needsToIssueRequest = true;
        }
        else if (_path.startsWith("/report"))
        {
                _status = 200;
                _mime = "text/html";
                _mode = "report";
                _needsToIssueRequest = true;
        }
        else if (_path.startsWith("/read"))
        {
                _status = 200;
                _mime = "application/json";
                _mode = "read";
                _needsToIssueRequest = true;
        }
        else if (_path.startsWith("/status"))
        {
                _status = 200;
                _mime = "application/json";
                _mode = "status";
        }
        else if (_path.startsWith("/command"))
        {
                _status = 200;
                _mime = "text/html";
                _mode = "command";
        }
        else if (!QFile::exists(":/VFS_httpd_browser"+_path))
        {
                _status = 404;
                VFS::WARN( QString("'%1' Status: %2: %3").arg(_path).arg(_status).arg(STATUS_CODES.value(_status)), 0, "httpd_browser" );
                _mode = "error";
        }
        else
        {
                _status = 200;
                QFileInfo info(_path);
                _mime = VFS_httpd::MIME_TYPES.value(info.suffix().toLower(),QString("text/html"));
                _mode = "file";
 
                if (info.suffix().toLower()=="rhtml") _process = true;
        }
}
 
QByteArray VFS_httpd_browser_responder::fetchResponse()
{
        QByteArray reply;
 
        if (_mode == "browse")
        {
                _path.remove(0, strlen("/browse"));
                reply = lsDir();
        }
        else if (_mode == "report")
        {
                //path.remove(0, strlen("/report"));
                reply = _data.toJson();
        }
        else if (_mode == "read")
        {
                reply = _data.toJson();
        }
        else if (_mode == "status")
        {
                QStringList pp = _path.split("/",Qt::SkipEmptyParts);
                pp.removeFirst();       //chop off "/status/"
 
                QJsonObject r;
                r["outstanding"] = (qint64) VFS_request::_refcount;
                r["sample"] = (qint64) VFS_request::_sampleCount;
 
                QJsonObject c;
                c["count"] = getSystemValue("cpucount");
                c["sample"] = getSystemValue("cpusample");
 
                QJsonObject m;
                m["total"] = getSystemValue("memtotal");
                m["sample"] = getSystemValue("memsample");
 
                QJsonObject u;
                u["ms"] = VFS::uptime();
                u["string"] = VFS::uptimeString();
 
                QJsonObject s;
                s["cpu"] = c;
                s["memory"] = m;
                s["uptime"] = u;
 
                QJsonObject o;
 
                if (!pp.length())               //path=="", return all statuses
                {
                        o["requests"] = r;
                        o["system"] = s;
 
                        return QJsonDocument(o).toJson(QJsonDocument::Compact);
                }
                else if (pp[0]=="requests")
                {
                        pp.removeFirst();       //remove "requests/"
 
                        if (!pp.length())
                        {
                                return QJsonDocument(r).toJson(QJsonDocument::Compact);
                        }
                        else if (pp[0] == "outstanding")
                        {
                                QJsonObject oo {{"outstanding",r["outstanding"]}};
                                return QJsonDocument(oo).toJson(QJsonDocument::Compact);
                        }
                        else if (pp[0] == "sample")
                        {
                                QJsonObject oo {{"sample",r["sample"]}};
                                return QJsonDocument(oo).toJson(QJsonDocument::Compact);
                        }
                }
                else if (pp[0]=="system")
                {
                        pp.removeFirst();       //remove "system/"
 
                        if (!pp.length())
                        {
                                return QJsonDocument(s).toJson(QJsonDocument::Compact);
                        }
                        else if (pp[0] == "cpu")
                        {
                                return QJsonDocument(s["cpu"].toObject()).toJson(QJsonDocument::Compact);
                        }
                        else if (pp[0] == "memory")
                        {
                                return QJsonDocument(s["memory"].toObject()).toJson(QJsonDocument::Compact);
                        }
                        else if (pp[0] == "uptime")
                        {
                                return QJsonDocument(s["uptime"].toObject()).toJson(QJsonDocument::Compact);
                        }
                }
 
                _status = 404;
                VFS::WARN( QString("unknown status request: %1").arg(_path), 0, "httpd_browser" );
                return errorPage();
        }
        else if (_mode == "command")
        {
                _path.remove(0, strlen("/command/"));
 
                if (_path=="exit")
                {       QCoreApplication::exit(0);
                        reply = "";
                }
                else if (_path == "parameters")
                {
                        reply = VFS::parameters().toJson();
                }
                else
                {
                        _status = 404;
                        VFS::WARN( QString("unknown command: %1").arg(_path), 0, "httpd_browser" );
                        return errorPage();
                }
        }
        else if (_mode == "file")
        {
                QFile page(":/VFS_httpd_browser"+_path);
                if (!page.open(QIODevice::ReadOnly))
                {
                        _status = 403;
                        VFS::WARN( QString("'%1' Status: %2: %3").arg(_path).arg(_status).arg(STATUS_CODES.value(_status)), 0, "httpd_browser" );
                        return errorPage();
                }
 
                reply = page.readAll();
 
                if (_process) reply = processRHTML(reply);
        }
        else
        {
                _status = 403;
                VFS::WARN( QString("'%1' Status: %2: %3").arg(_path).arg(_status).arg(STATUS_CODES.value(_status)), 0, "httpd_browser" );
                return errorPage();
        }
 
        return reply;
}
 
// this is better:
// http://stackoverflow.com/questions/5636375/how-to-create-a-collapsing-tree-table-in-html-css-js
 
QByteArray VFS_httpd_browser_responder::lsDir()
{
        QByteArray reply;
        QString s;
        QJsonObject o = _data.object();
        QJsonObject::iterator i = o.begin();
 
        reply += "<ul class='dirListing'>\n";
 
        while (i != o.end())
        {
                QString s = i.key();
 
                //if (s.right(1) == "/")
                        reply += QString("\t<li class='vfs_node vfs_node_closed' path='"+_path+"/"+s+"'>" + s + "</li>\n").toUtf8();
                //else
                //      reply += "\t<li class='vfs_node vfs_node_file' path='"+path+s+"'><span class='permissions'>type rwxrwxrwx</span>" + s + "</li>\n";
 
                ++i;
        }
 
        reply += "</ul>\n";
 
        return reply;
}
 
QByteArray VFS_httpd_browser_responder::processRHTML(QByteArray page)
{
        QRegExp token("\\[###(.*)###\\]");
        token.setMinimal(true);
 
        //printf("PROCESSING!\n");
 
        QByteArray processed;
 
        while(token.indexIn(page) > -1)
        {
                QStringList commandArgs = token.capturedTexts()[1].split(",");                  //tokens may have arguments separated by commas
                QString command = commandArgs.takeFirst().toLower();
 
                if      (command=="hostname")           processed = QHostInfo::localHostName().toUtf8();
                else if (command=="port")               processed = QString("%1").arg(_port).toUtf8();
                else if (command=="app_path")           processed = QCoreApplication::applicationFilePath().toUtf8();
                else if (command=="arguments")          processed = QCoreApplication::arguments().join(" ").toUtf8();
                else if (command=="version")            processed = QCoreApplication::applicationVersion().toUtf8();
                else if (command=="starttime")          processed = QDateTime::fromMSecsSinceEpoch(VFS::starttime()).toString(Qt::TextDate).toUtf8();
                else if (command=="uptime")             processed = VFS::uptimeString().toUtf8();
                else if (command=="vfs_requests")       processed = QString("%1").arg(VFS_request::_refcount).toUtf8();
                else                                    processed = QString("<div class='warning'>Unknown Command: <b>%1</b></div>").arg(command).toUtf8();
 
                page = page.replace(token.pos(0),token.matchedLength(),processed);
        }
 
        return page;
}
 
QJsonValue VFS_httpd_browser_responder::getSystemValue(QString which)
{
        QString kernel = QSysInfo::kernelType().toLower();
        QString command;
        QString suffix;
 
        if (kernel == "linux")
        {
                if (which == "cpucount")
                {
                        command = "grep -c ^processor /proc/cpuinfo";
                }
                else if (which == "cpusample")
                {
                        command = "sar -u 1 1 | grep verage | perl -pe \"s/\\s+/+/g\" | cut -f 3,5 -d '+' | bc -l";
                        //command = "ps -A -o %cpu | awk '{s+=$1} END {print s/`grep -c ^processor /proc/cpuinfo`}'";   //not sure why 100- here, but not darwin
                        suffix = "%";
                }
                else if (which == "memtotal")
                {
                        command = "awk '( $1 == \"MemTotal:\" ) { print $2/1048576 }' /proc/meminfo";
                        suffix = " gb";
                }
                else if (which == "memsample")
                {
                        command = "free -b | grep Mem | perl -pe \"s/\\s+/ /g\" | cut -f 2,4 -d \" \" | perl -pe \"s/\\s+/ \\/ /\" | perl -pe \"s/(.*)/scale=10; 100*(1-1\\/(\\1))/\" | bc -l";
                        suffix = "%";
                }
        }
        else if (kernel == "darwin")
        {
                if (which == "cpucount")
                {
                        command = "sysctl -n hw.ncpu";
                }
                else if (which == "cpusample")
                {
                        command = "ps -A -o %cpu | awk '{s+=$1} END {print s}'";
                        suffix = "%";
                }
                else if (which == "memtotal")
                {
                        command = "awk '( $1 == \"MemTotal:\" ) { print $2/1048576 }' /proc/meminfo";
                        suffix = " gb";
                }
                else if (which == "memsample")
                {
                        //command = "free -b | grep Mem | perl -pe \"s/\\s+/ /g\" | cut -f 2,4 -d \" \" | perl -pe \"s/\\s+/ \\/ /\" | perl -pe \"s/(.*)/scale=10; 100*(1-1\\/(\\1))/\" | bc -l";
                        command = "memory_pressure | grep percentage | perl -pe \"s/([^\\d]*)(\\d+)([^\\d]*)/scale=20; \\2 \\/ 100\\n/\" | bc -l";
                        suffix = "%";
                }
        }
        else
                VFS::ERROR(QString("Unknown kernel: %1.  Can't fetch system value.").arg(kernel),0,"httpd_browser");
 
        if (!command.isEmpty())
        {
                QProcess process;
                process.start("bash", QStringList() << "-c" << command);
                process.waitForFinished(5000); // will wait for 5 seconds to finish
 
                QString stdout = process.readAllStandardOutput();
                QString stderr = process.readAllStandardError();
 
                //printf("stdout: %s\n",qUtf8Printable(stdout));
                //printf("stderr: %s\n",qUtf8Printable(stderr));
 
                if (!stderr.isEmpty())
                        VFS::WARN(stderr,0,"httpd_browser");
 
                return stdout.trimmed()+suffix;
        }
 
        return QJsonValue::Null;
}