RequestServiceTimer.cc

// RequestServiceTimer.cc
 
// This file is part of bes, A C++ back-end server implementation framework
// for the OPeNDAP Data Access Protocol.
 
// Copyright (c) 2022 OPeNDAP, Inc
// Authors:
//      ndp         Nathan Potter <ndp@opendap.org>
//      dan         Dan Holloway  <dholloway@opendap.org>
//
// This library 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
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
#include "config.h"
 
#include <string>
#include <iostream>
#include <mutex>
#include <sstream>
 
#include "BESDebug.h"
#include "BESTimeoutError.h"
#include "RequestServiceTimer.h"
 
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
 
using std::string;
using std::endl;
using std::ostream;
 
using namespace std::chrono;
 
#define MODULE "bes"
#define prolog string("RequestServiceTimer::").append(__func__).append("() - ")
 
RequestServiceTimer *RequestServiceTimer::d_instance = nullptr;
static std::once_flag d_rst_init_once;
 
RequestServiceTimer *
RequestServiceTimer::TheTimer()
{
    std::call_once(d_rst_init_once,RequestServiceTimer::initialize_instance);
    return d_instance;
}
 
void RequestServiceTimer::initialize_instance() {
    d_instance = new RequestServiceTimer();
#ifdef HAVE_ATEXIT
    atexit(delete_instance);
#endif
}
 
void RequestServiceTimer::delete_instance() {
    delete d_instance;
    d_instance = nullptr;
}
 
void RequestServiceTimer::start(milliseconds timeout_ms){
    std::lock_guard<std::recursive_mutex> lock_me(d_rst_lock_mutex);
 
    if(timeout_ms > milliseconds{0}){
        timeout_enabled = true;
        d_bes_timeout = timeout_ms;
    }
    else {
        timeout_enabled = false;
        d_bes_timeout = milliseconds{0};
    }
    start_time = steady_clock::now();
}
 
milliseconds RequestServiceTimer::elapsed() const {
    std::lock_guard<std::recursive_mutex> lock_me(d_rst_lock_mutex);
    return duration_cast<milliseconds>(steady_clock::now() - start_time);
}
 
milliseconds RequestServiceTimer::remaining() const {
    std::lock_guard<std::recursive_mutex> lock_me(d_rst_lock_mutex);
    milliseconds remaining{0};
    BESDEBUG(MODULE, prolog << "init remaining: " << remaining.count() <<  endl);
    if (timeout_enabled) {
        BESDEBUG(MODULE, prolog << "timeout enabled" << endl);
        remaining = d_bes_timeout - elapsed();
    }
    else {
        BESDEBUG(MODULE, prolog << "timeout disabled" << endl);
    }
    return remaining;
}
 
bool RequestServiceTimer::is_expired() const {
    std::lock_guard<std::recursive_mutex> lock_me(d_rst_lock_mutex);
    return timeout_enabled && (remaining() <= milliseconds {0});
}
 
void RequestServiceTimer::disable_timeout(){
    std::lock_guard<std::recursive_mutex> lock_me(d_rst_lock_mutex);
    timeout_enabled = false;
}
 
string RequestServiceTimer::dump(bool pretty) const {
    std::stringstream ss;
    if(!pretty){ ss<<"["; }
    ss << "RequestServiceTimer(" << (void *)this << ") - ";
    if(pretty){ ss << endl << "  "; }
    ss << "bes_timeout: " << d_bes_timeout.count() << "ms ";
    if(pretty){ ss << endl << "  "; }
    ss << "start_time: " << duration_cast<seconds>(start_time.time_since_epoch()).count() << "s ";
    if(pretty){ ss << endl << "  "; }
    ss << "is_timeout_enabled(): " << (is_timeout_enabled() ?"true ":"false ");
    if(pretty){ ss << endl << "  "; }
    ss << "elapsed(): " << elapsed().count() << "ms ";
    if(pretty){ ss << endl << "  "; }
    ss << "remaining(): " << remaining().count() << "ms ";
    if(pretty){ ss << endl << "  "; }
    ss << "is_expired(): " <<  (is_expired()?"true":"false");
    if(pretty){ ss << endl; }else{ ss << "]"; }
    return ss.str();
}
 
void RequestServiceTimer::dump( ostream &strm ) const
{
    strm << dump() << endl;
}
 
 
void RequestServiceTimer::throw_if_timeout_expired(const string &message, const string &file, const int line)
{
    if (is_expired()) {
        double time_out_seconds = d_bes_timeout.count()/1000.00;
        std::stringstream errMsg;
        errMsg << "The request that you submitted timed out. The server was unable to begin transmitting a response in ";
        errMsg << "the time allowed. Requests processed by this server must begin transmitting a response in less ";
        errMsg << "than " << time_out_seconds << " seconds. ";
 
        errMsg << "Some things you can try: Reissue the request but change the amount of data requested. ";
        errMsg << "You may reduce the size of the request by choosing just the variables you need and/or by ";
        errMsg << "using the DAP index based array sub-setting syntax to additionally limit the amount of data requested. ";
        errMsg << "You can also try requesting a different encoding for the response. If you asked for the response ";
        errMsg << "to be encoded as a NetCDF-3 or NetCDF-4 file be aware that these response encodings are not " <<
                  "streamable. In order ";
        errMsg << "to build these responses the server must write the entire response to a temporary file before it can ";
        errMsg << "begin to send the response to the requesting client. Changing to a different encoding, such as DAP4 ";
        errMsg << "data, may allow the server to successfully respond to your request. ";
 
        errMsg << "The service component that ran out of time said: " <<  message;
 
        throw BESTimeoutError(errMsg.str(), file, line);
    }
}