RemoteWebUsers.cc

#include "otsdaq/WebUsersUtilities/RemoteWebUsers.h"
 
#include "otsdaq/CgiDataUtilities/CgiDataUtilities.h"
#include "otsdaq/SOAPUtilities/SOAPCommand.h"
#include "otsdaq/SOAPUtilities/SOAPParameters.h"  //must include in .h for static function
#include "otsdaq/SOAPUtilities/SOAPUtilities.h"
#include "otsdaq/XmlUtilities/HttpXmlDocument.h"
 
#include <cstdio>
#include <cstdlib>
#include <tuple>
#include <vector>
 
#include "otsdaq/SupervisorInfo/AllSupervisorInfo.h"
 
using namespace ots;
 
#undef __MF_SUBJECT__
#define __MF_SUBJECT__ "RemoteWebUsers"
 
//==============================================================================
//==============================================================================
RemoteWebUsers::RemoteWebUsers(
    xdaq::Application* application,
    XDAQ_CONST_CALL xdaq::ApplicationDescriptor* gatewaySupervisorDescriptor)
    : SOAPMessenger(application)
    , gatewaySupervisorDescriptor_(gatewaySupervisorDescriptor)
{
    ActiveUserLastUpdateTime_ = 0;   // init to never
    ActiveUserList_           = "";  // init to empty
}  // end constructor()
 
//==============================================================================
bool RemoteWebUsers::xmlRequestToGateway(cgicc::Cgicc&              cgi,
                                         std::ostringstream*        out,
                                         HttpXmlDocument*           xmldoc,
                                         const AllSupervisorInfo&   allSupervisorInfo,
                                         WebUsers::RequestUserInfo& userInfo)
{
    //__COUT__ << std::endl;
    // initialize user info parameters to failed results
    WebUsers::initializeRequestUserInfo(cgi, userInfo);
 
    XDAQ_CONST_CALL xdaq::ApplicationDescriptor* gatewaySupervisor;
 
    SOAPParameters         parameters;
    xoap::MessageReference retMsg;
 
    //**** start LOGIN GATEWAY CODE ***//
    // If TRUE, cookie code is good, and refreshed code is in cookieCode
    // Else, error message is returned in cookieCode
 
    // if Wiz or Macormaker mode, use sequence instead of cookieCode
    if(allSupervisorInfo.isWizardMode() || allSupervisorInfo.isMacroMakerMode())
    {
        // if missing CookieCode... check if in Wizard mode and using sequence
        std::string sequence =
            CgiDataUtilities::getOrPostData(cgi, "sequence");  // from GET or POST
        //__COUT__ << "sequence=" << sequence << std::endl;
        if(!sequence.length())
        {
            __COUT_ERR__ << "Invalid access attempt (@" << userInfo.ip_ << ")."
                         << std::endl;
            *out << WebUsers::REQ_NO_LOGIN_RESPONSE;
            // invalid cookie and also invalid sequence
            goto HANDLE_ACCESS_FAILURE;  // return false, access failed
        }
 
        // have sequence, try it out
 
        if(allSupervisorInfo.isWizardMode())
            gatewaySupervisor = allSupervisorInfo.getWizardInfo().getDescriptor();
        else  //is MacroMaker mode
            gatewaySupervisor = allSupervisorInfo.getAllMacroMakerTypeSupervisorInfo()
                                    .begin()
                                    ->second.getDescriptor();
 
        if(!gatewaySupervisor)
        {
            __COUT_ERR__ << "Missing gateway supervisor." << std::endl;
            *out << WebUsers::REQ_NO_LOGIN_RESPONSE;
            // sequence code present, but no wizard supervisor
            goto HANDLE_ACCESS_FAILURE;  // return false, access failed
        }
 
        parameters.addParameter("sequence", sequence);
        parameters.addParameter("IPAddress", userInfo.ip_);
        retMsg = SOAPMessenger::sendWithSOAPReply(
            gatewaySupervisor, "SupervisorSequenceCheck", parameters);
        parameters.clear();
        parameters.addParameter("Permissions");
        SOAPUtilities::receive(retMsg, parameters);
 
        userInfo.setGroupPermissionLevels(parameters.getValue("Permissions"));
 
        if(WebUsers::checkRequestAccess(
               cgi, out, xmldoc, userInfo, true /*isWizardMode*/, sequence))
            return true;  //successful sequence login!
        else
            goto HANDLE_ACCESS_FAILURE;  // return false, access failed
    }                                    //end  Wiz or Macormaker mode
 
    // else proceed with inquiry to Gateway Supervisor
 
    gatewaySupervisor = allSupervisorInfo.getGatewayInfo().getDescriptor();
 
    if(!gatewaySupervisor)
    {
        __COUT_ERR__ << "Missing gateway supervisor." << std::endl;
        *out << WebUsers::REQ_NO_LOGIN_RESPONSE;
        goto HANDLE_ACCESS_FAILURE;  // return false, access failed
    }
 
    // ---- Cookie Check Cache: attempt lookup ----
    // Bypass cache when requireLock_ and no one holds lock --
    // Gateway must auto-take lock (see GatewaySupervisor::supervisorCookieCheck).
    // Safe: requireLock_ is forced false for automatedCommand_ requests
    // (see CorePropertySupervisorBase::getRequestUserInfo), so high-freq polling always caches.
    {
        bool cacheHit = false;
        {
            std::lock_guard<std::mutex> cacheLock(cookieCheckCacheMutex_);
            auto cacheIt = cookieCheckCache_.find(userInfo.cookieCode_);
            if(cacheIt != cookieCheckCache_.end() &&
               (time(0) - cacheIt->second.cacheTime) < COOKIE_CHECK_CACHE_TTL)
            {
                if(!(userInfo.requireLock_ && cacheIt->second.userWithLock.empty()))
                {
                    userInfo.setGroupPermissionLevels(cacheIt->second.permissions);
                    userInfo.cookieCode_       = cacheIt->second.cookieCode;
                    userInfo.username_         = cacheIt->second.username;
                    userInfo.displayName_      = cacheIt->second.displayName;
                    userInfo.usernameWithLock_ = cacheIt->second.userWithLock;
                    cacheHit                   = true;
                }
            }
        }  // mutex released
 
        if(cacheHit)
        {
            if(!WebUsers::checkRequestAccess(cgi, out, xmldoc, userInfo))
                goto HANDLE_ACCESS_FAILURE;
            return true;
        }
    }
    // ---- end Cookie Check Cache lookup ----
 
    // Save original cookie code before SOAP (Gateway may refresh it in the response)
    {
        const std::string originalCookieCode = userInfo.cookieCode_;
 
        parameters.clear();
        parameters.addParameter("CookieCode", userInfo.cookieCode_);
        parameters.addParameter("RefreshOption", userInfo.automatedCommand_ ? "0" : "1");
        parameters.addParameter("IPAddress", userInfo.ip_);
        parameters.addParameter("RequireLock", userInfo.requireLock_ ? "1" : "0");
 
        retMsg = SOAPMessenger::sendWithSOAPReply(
            gatewaySupervisor, "SupervisorCookieCheck", parameters);
 
        parameters.clear();
        parameters.addParameter("CookieCode");
        parameters.addParameter("Permissions");
        parameters.addParameter("UserGroups");
        parameters.addParameter("UserWithLock");
        parameters.addParameter("Username");
        parameters.addParameter("DisplayName");
        // parameters.addParameter("ActiveSessionIndex");
        SOAPUtilities::receive(retMsg, parameters);
 
        // first extract a few things always from parameters
        //  like permissionLevel for this request... must consider allowed groups!!
        userInfo.setGroupPermissionLevels(parameters.getValue("Permissions"));
        userInfo.cookieCode_       = parameters.getValue("CookieCode");
        userInfo.username_         = parameters.getValue("Username");
        userInfo.displayName_      = parameters.getValue("DisplayName");
        userInfo.usernameWithLock_ = parameters.getValue("UserWithLock");
        // userInfo.activeUserSessionIndex_ = strtoul(parameters.getValue("ActiveSessionIndex").c_str(), 0, 0);
 
        // ---- Cookie Check Cache: store successful response ----
        if(userInfo.cookieCode_.length() == WebUsers::COOKIE_CODE_LENGTH)
        {
            std::lock_guard<std::mutex> cacheLock(cookieCheckCacheMutex_);
            cookieCheckCache_[originalCookieCode] = {time(0),
                                                     userInfo.cookieCode_,
                                                     parameters.getValue("Permissions"),
                                                     userInfo.username_,
                                                     userInfo.displayName_,
                                                     userInfo.usernameWithLock_};
 
            // Prune stale entries (bounded by active users, typically < 20)
            if(cookieCheckCache_.size() > 10)
            {
                time_t now = time(0);
                for(auto it = cookieCheckCache_.begin(); it != cookieCheckCache_.end();)
                {
                    if(now - it->second.cacheTime > 2 * COOKIE_CHECK_CACHE_TTL)
                        it = cookieCheckCache_.erase(it);
                    else
                        ++it;
                }
            }
        }
        // ---- end Cookie Check Cache store ----
    }  // end originalCookieCode scope
 
    if(!WebUsers::checkRequestAccess(cgi, out, xmldoc, userInfo))
        goto HANDLE_ACCESS_FAILURE;  // return false, access failed
    // else successful access request!
 
    return true;  // request granted
 
 
HANDLE_ACCESS_FAILURE:
 
    // print out return string on failure
    if(!userInfo.automatedCommand_)
        __COUT_ERR__ << "Failed request (requestType = " << userInfo.requestType_
                     << "): " << out->str() << __E__;
    return false;  // access failed
}  // end xmlRequestToGateway()
 
//==============================================================================
std::string RemoteWebUsers::getActiveUserList()
{
    if(time(0) - ActiveUserLastUpdateTime_ >
       ACTIVE_USERS_UPDATE_THRESHOLD)  // need to update
    {
        __COUTS__(2) << "Need to update active user list" << std::endl;
 
        xoap::MessageReference retMsg = ots::SOAPMessenger::sendWithSOAPReply(
            gatewaySupervisorDescriptor_, "SupervisorGetActiveUsers");
 
        SOAPParameters retParameters("UserList");
        SOAPUtilities::receive(retMsg, retParameters);
 
        ActiveUserLastUpdateTime_ = time(0);
        return (ActiveUserList_ = retParameters.getValue("UserList"));
    }
    else
        return ActiveUserList_;
}  // end getActiveUserList()
 
//==============================================================================
void RemoteWebUsers::getLastTableGroups(
    std::map<std::string /* group type */,
             std::tuple<std::string /*group name*/,
                        TableGroupKey,
                        std::string /* time string*/>>& theGroups)
{
    xoap::MessageReference retMsg =
        ots::SOAPMessenger::sendWithSOAPReply(gatewaySupervisorDescriptor_,
                                              "SupervisorLastTableGroupRequest",
                                              SOAPParameters("ActionOfLastGroup", "ALL"));
 
    SOAPParameters retParameters;
    retParameters.addParameter("GroupName");
    retParameters.addParameter("GroupKey");
    retParameters.addParameter("GroupAction");
    retParameters.addParameter("GroupActionTime");
    SOAPUtilities::receive(retMsg, retParameters);
 
    //parse as CSV
    std::vector<std::string> groupNames =
        StringMacros::getVectorFromString(retParameters.getValue("GroupName"), {','});
    std::vector<std::string> groupKeys =
        StringMacros::getVectorFromString(retParameters.getValue("GroupKey"), {','});
    std::vector<std::string> groupActions =
        StringMacros::getVectorFromString(retParameters.getValue("GroupAction"), {','});
    std::vector<std::string> groupTimes = StringMacros::getVectorFromString(
        retParameters.getValue("GroupActionTime"), {','});
 
    if(groupNames.size() < 2)
    {
        //expecting something like 7?
        __SS__ << "Failure in handling request for recent config group activity. "
                  "Response received was this: \n"
               << SOAPUtilities::translate(retMsg) << __E__;
        __SS_THROW__;
    }
 
    if(groupNames.size() != groupKeys.size() ||
       groupNames.size() != groupActions.size() || groupNames.size() != groupTimes.size())
    {
        __SS__ << "Illegal list size mismatch while retrieving recent config group info. "
                  "Should not be possible! Notify admins."
               << __E__;
        __SS_THROW__;
    }
 
    for(size_t i = 0; i < groupNames.size(); ++i)
    {
        theGroups[groupActions[i]] = std::make_tuple(
            groupNames[i], strtol(groupKeys[i].c_str(), 0, 0), groupTimes[i]);
    }
 
    __COUTT__ << "Done with getLastTableGroups()" << __E__;
}  // end getLastTableGroup()
 
//==============================================================================
std::pair<std::string /*group name*/, TableGroupKey> RemoteWebUsers::getLastTableGroup(
    const std::string& actionOfLastGroup, std::string& actionTimeString)
{
    actionTimeString              = "";
    xoap::MessageReference retMsg = ots::SOAPMessenger::sendWithSOAPReply(
        gatewaySupervisorDescriptor_,
        "SupervisorLastTableGroupRequest",
        SOAPParameters("ActionOfLastGroup", actionOfLastGroup));
 
    SOAPParameters retParameters;
    retParameters.addParameter("GroupName");
    retParameters.addParameter("GroupKey");
    retParameters.addParameter("GroupAction");
    retParameters.addParameter("GroupActionTime");
    SOAPUtilities::receive(retMsg, retParameters);
 
    std::pair<std::string /*group name*/, TableGroupKey> theGroup;
    if(retParameters.getValue("GroupAction") !=
       actionOfLastGroup)  // if action doesn't match.. weird
    {
        __SS__ << "Returned group action '" << retParameters.getValue("GroupAction")
               << "' does not match requested group action '" << actionOfLastGroup << ".'"
               << std::endl;
        __SS_THROW__;
    }
    // else we have an action match
 
    theGroup.first   = retParameters.getValue("GroupName");
    theGroup.second  = strtol(retParameters.getValue("GroupKey").c_str(), 0, 0);
    actionTimeString = retParameters.getValue("GroupActionTime");
    return theGroup;
}  // end getLastTableGroup()
 
//==============================================================================
void RemoteWebUsers::sendSystemMessage(const std::string& toUser,
                                       const std::string& message,
                                       bool               doEmail /*=false*/)
{
    sendSystemMessage(toUser, "" /*subject*/, message, doEmail);
}  // end sendSystemMessage)
 
//==============================================================================
void RemoteWebUsers::sendSystemMessage(const std::string& toUser,
                                       const std::string& subject,
                                       const std::string& message,
                                       bool               doEmail /*=false*/)
{
    SOAPParameters parameters;
    parameters.addParameter("ToUser", toUser);  // CSV list or *
    parameters.addParameter("Subject", subject);
    parameters.addParameter("Message", message);
    parameters.addParameter("DoEmail", doEmail ? "1" : "0");
 
    xoap::MessageReference retMsg = SOAPMessenger::sendWithSOAPReply(
        gatewaySupervisorDescriptor_, "SupervisorSystemMessage", parameters);
 
    //__COUT__ << SOAPUtilities::translate(retMsg) << __E__;
}  // end sendSystemMessage)
 
//==============================================================================
void RemoteWebUsers::makeSystemLogEntry(const std::string& entryText)
{
    SOAPParameters parameters;
    parameters.addParameter("EntryText", entryText);
 
    xoap::MessageReference retMsg = SOAPMessenger::sendWithSOAPReply(
        gatewaySupervisorDescriptor_, "SupervisorSystemLogbookEntry", parameters);
 
    //__COUT__ << SOAPUtilities::translate(retMsg) << __E__;
}  // end makeSystemLogEntry()