ICPRequestHandlerFactory.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "ICPRequestHandlerFactory.h"
#include "isiscrpt.h"
#include "../svn-revision.h"

class RootHandler : public Poco::Net::HTTPRequestHandler
{
private:
        const ISISCRPT_STRUCT* m_crpt;

public:
        RootHandler(const ISISCRPT_STRUCT* crpt) : m_crpt(crpt) { }
        void handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response);
};

class DataHandler : public Poco::Net::HTTPRequestHandler
{
private:
        const ISISCRPT_STRUCT* m_crpt;
public:
        DataHandler(const ISISCRPT_STRUCT* crpt) : m_crpt(crpt) { }
        void handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response);
};


ICPRequestHandlerFactory::ICPRequestHandlerFactory(const ISISCRPT_STRUCT* crpt) : m_crpt(crpt)
{
}

Poco::Net::HTTPRequestHandler* ICPRequestHandlerFactory::createRequestHandler(const Poco::Net::HTTPServerRequest& request)
{
        if (request.getURI() == "/")
        {
                return new RootHandler(m_crpt);
        }
        else
        {
                return new DataHandler(m_crpt);
        }
}

static void outputValue(std::ostream& os, const std::string& name, const std::string& units, double value)
{
        os << Poco::format("<%s units=\"%s\">%f</%s>\n", name, units, value, name);     
}       

static void outputValue(std::ostream& os, const std::string& name, const std::string& units, int value)
{
        os << Poco::format("<%s units=\"%s\">%d</%s>\n", name, units, value, name);     
}       

static void outputValue(std::ostream& os, const std::string& name, const std::string& units, unsigned int value)
{
        os << Poco::format("<%s units=\"%s\">%u</%s>\n", name, units, value, name);     
}       

static void outputValue(std::ostream& os, const std::string& name, const std::string& units, const std::string& value)
{
        os << Poco::format("<%s units=\"%s\">%s</%s>\n", name, units, value, name);     
}       

static void outputTimeValue(std::ostream& os, const std::string& name, time_t value)
{
        char time_buffer[128];
        strftime(time_buffer, sizeof(time_buffer), "%H:%M, %a %d %b", localtime(&value));
        os << Poco::format("<%s units=\"\" fromepoch=\"%lu\" iso=\"%s\">%s</%s>\n", name, (unsigned long)value, 
                Poco::DateTimeFormatter::format(Poco::Timestamp::fromEpochTime(value), "%Y-%m-%dT%H:%M:%S%z"), 
                std::string(time_buffer), name);        
}

static const char* nagios_status[] = { "OK", "WARNING", "CRITICAL", "UNKNOWN" };

static const char* nagios_shutter_val[] = { "CLOSED and RUNNING", "CLOSED", "OPEN" };

void RootHandler::handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)
{
        Poco::Util::Application& app = Poco::Util::Application::instance();
//      app.logger().information("Request from " + request.clientAddress().toString());
        response.setChunkedTransferEncoding(true);
        response.setContentType("text/xml");
        std::ostream& ostr = response.send();
        const nagios_t& nagios = m_crpt->nagios;
        ostr << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        ostr << "<values>\n";
        outputValue(ostr, "VeroPercent", "%", nagios.veto_percent);
        outputValue(ostr, "BeamCurrent", "uA", m_crpt->beam_current);
        outputValue(ostr, "TotalUAmps", "uAh", m_crpt->update_good_uamph);
        outputValue(ostr, "GoodFramesTotal", "frames", m_crpt->update_good_frames);
        outputValue(ostr, "RawFramesTotal", "frames", m_crpt->update_raw_frames);
        outputValue(ostr, "RunNumber", "", m_crpt->run_number);
        outputValue(ostr, "RunStatus", "", runstatus_names[m_crpt->run_status]);
        outputValue(ostr, "SEStatus", "", sestatus_names[m_crpt->se_status]);
        outputValue(ostr, "CurrentPeriod", "", m_crpt->update_period + 1);
        outputValue(ostr, "RunDurationTotal", "seconds", m_crpt->update_duration);
        outputValue(ostr, "WaitTime", "minutes", nagios.wait_mins);
        outputTimeValue(ostr, "StartTime", m_crpt->start_time);
        outputTimeValue(ostr, "StopTime", m_crpt->stop_time);
        outputTimeValue(ostr, "ResumeTime", m_crpt->resume_time);
        outputTimeValue(ostr, "ICPStartTime", m_crpt->icp_start_time);
        outputValue(ostr, "CountRate", "MEv /s", m_crpt->count_rate);
        outputValue(ostr, "InstName", "", m_crpt->inst_name);
        outputValue(ostr, "TotalDAECounts", "MEv", (float)m_crpt->update_total_counts / (float)1e6);
        outputValue(ostr, "MonitorCounts", "counts", m_crpt->monitor_sum[0]);
        outputValue(ostr, "RunTitle", "", m_crpt->long_title);
        outputValue(ostr, "RBNumber", "", m_crpt->rb_number);
        outputValue(ostr, "EventModeCardFraction", "", m_crpt->eventModeCardFraction());
        outputValue(ostr, "BeamlineStatus", "", nagios_status[nagios.shutter_status]);
        outputValue(ostr, "DAEStatus", "", nagios_status[nagios.dae_status]);
        outputValue(ostr, "WaitStatus", "", nagios_status[nagios.wait_status]);
        outputValue(ostr, "ShutterVal", "", nagios_shutter_val[nagios.shutter_val]);
        outputValue(ostr, "NumberOfPeriods", "", m_crpt->nper);
        outputValue(ostr, "UserName", "", m_crpt->user_name);
        outputValue(ostr, "NDataDae", "", m_crpt->n_data_dae);
        outputValue(ostr, "DAEType", "", ISISDAE::DAEType_desc[m_crpt->dae_type]);
        outputValue(ostr, "ICPSVNRevision", "", ICPSVN_Revision);
        outputValue(ostr, "ICPFullVersion", "", 
                Poco::format("SVN revision %s (%s, %s %s, %s)", ICPSVN_Revision, ICPSVN_Date, ICPSVN_Mixed, ICPSVN_Range, ICPSVN_Modified));
        ostr << "</values>\n";
}

void DataHandler::handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)
{
        Poco::Util::Application& app = Poco::Util::Application::instance();
//      app.logger().information("Request from " + request.clientAddress().toString());
        response.setChunkedTransferEncoding(true);
        response.setContentType("text/plain");
        std::ostream& ostr = response.send();
        const nagios_t& nagios = m_crpt->nagios;
        const std::string& item = request.getURI();
        if ("/VeroPercent" == item)
        {
                ostr << nagios.veto_percent;
        }
        else if ("/ShutterStatus" == item)
        {
                ostr << nagios.shutter_status;
        }
        else if ("/ShutterVal" == item)
        {
                ostr << nagios.shutter_val;
        }
        else if ("/DAEStatus" == item)
        {
                ostr << nagios.dae_status;
        }
}