bool watchdog::run() { getmilliseconds(); if (last_fire + this->major_threshold < clock_tick) { CStat::globalStat(CStat::E_WATCHDOG_MAJOR); last_trigger = clock_tick; WARNING("The major watchdog timer %dms has been tripped (%d), %d trips remaining.", major_threshold, clock_tick - last_fire, major_maxtriggers - major_triggers); if ((this->major_maxtriggers != -1) && (++major_triggers > this->major_maxtriggers)) { REPORT_ERROR("The watchdog timer has tripped the major threshold of %dms too many times (%d out of %d allowed) (%d out of %d minor %dms timeouts tripped)\n", major_threshold, major_triggers, major_maxtriggers, minor_threshold, minor_triggers, minor_maxtriggers); } } else if (last_fire + this->minor_threshold < clock_tick) { last_trigger = clock_tick; CStat::globalStat(CStat::E_WATCHDOG_MINOR); WARNING("The minor watchdog timer %dms has been tripped (%d), %d trips remaining.", minor_threshold, clock_tick - last_fire, minor_maxtriggers - minor_triggers); if ((this->minor_maxtriggers != -1) && (++minor_triggers > this->minor_maxtriggers)) { REPORT_ERROR("The watchdog timer has tripped the minor threshold of %dms too many times (%d out of %d allowed) (%d out of %d major %dms timeouts tripped)\n", minor_threshold, minor_triggers, minor_maxtriggers, major_threshold, major_triggers, major_maxtriggers); } } if (reset_interval && (major_triggers || minor_triggers) && (last_trigger + reset_interval < clock_tick)) { WARNING("Resetting watchdog timer trigger counts, as it has not been triggered in over %dms.", clock_tick - last_trigger); major_triggers = minor_triggers = 0; } last_fire = clock_tick; setPaused(); return true; }
watchdog::watchdog(int interval, int reset_interval, int major_threshold, int major_maxtriggers, int minor_threshold, int minor_maxtriggers) { this->interval = interval; this->reset_interval = reset_interval; this->major_threshold = major_threshold; this->major_maxtriggers = major_maxtriggers; this->minor_threshold = minor_threshold; this->minor_maxtriggers = minor_maxtriggers; major_triggers = 0; minor_triggers = 0; last_trigger = last_fire = getmilliseconds(); }
static size_t contentcallback(void *data, size_t size, size_t nmemb, http_t *http) { request_t *req = http->request; if (req->callback && data && !http->uninstallrequest()) // no need to store data if there is no callback anyway { if (!http->downloadstart) http->downloadstart = getmilliseconds(); size_t realsize = size*nmemb; size_t size = min<size_t>(realsize, req->maxdatalen-http->data.length()); http->data.add(data, size); int speedlimit; getspeedlimit(speedlimit); if (http->speedlimit != speedlimit) { http->speedlimit = speedlimit; curl_easy_setopt(http->curl, CURLOPT_MAX_RECV_SPEED_LARGE, (curl_off_t)http->speedlimit); } if (req->contentcallback) { if (req->nullterminatorneeded) http->data.add('\0'); int v = req->contentcallback(http->getrequestid(), req->callbackdata, http->data.getbuf(), http->data.length()-1); if (req->nullterminatorneeded) http->data.pop(); switch (v) { case 0: return 0; case 2: http->data.setsize(0); } } if (size == realsize) return realsize; } return 0; }
bool watchdog::run() { getmilliseconds(); unsigned expected_major_trigger_time = last_fire + this->major_threshold; unsigned expected_minor_trigger_time = last_fire + this->minor_threshold; bool major_watchdog_tripped = clock_tick > expected_major_trigger_time; bool minor_watchdog_tripped = clock_tick > expected_minor_trigger_time; // Check if either watchdog has taken longer than expected to run, // and if so, warn that we are overloaded. if (major_watchdog_tripped) { major_triggers++; CStat::globalStat(CStat::E_WATCHDOG_MAJOR); last_trigger = clock_tick; WARNING("Overload warning: the major watchdog timer %dms has been tripped (%d), %d trips remaining.", major_threshold, clock_tick - last_fire, major_maxtriggers - major_triggers); } else if (minor_watchdog_tripped) { minor_triggers++; last_trigger = clock_tick; CStat::globalStat(CStat::E_WATCHDOG_MINOR); WARNING("Overload warning: the minor watchdog timer %dms has been tripped (%d), %d trips remaining.", minor_threshold, clock_tick - last_fire, minor_maxtriggers - minor_triggers); } bool major_watchdog_failure = ((this->major_maxtriggers != -1) && (major_triggers > this->major_maxtriggers)); bool minor_watchdog_failure = ((this->minor_maxtriggers != -1) && (minor_triggers > this->minor_maxtriggers)); // If the watchdogs have tripped too many times, end the SIPp run. if (major_watchdog_failure) { ERROR("Overload error: the watchdog timer has tripped the major threshold of %dms too many times (%d out of %d allowed) (%d out of %d minor %dms timeouts tripped)\n", major_threshold, major_triggers, major_maxtriggers, minor_triggers, minor_maxtriggers, minor_threshold); } else if (minor_watchdog_failure) { ERROR("Overload error: the watchdog timer has tripped the minor threshold of %dms too many times (%d out of %d allowed) (%d out of %d major %dms timeouts tripped)\n", minor_threshold, minor_triggers, minor_maxtriggers, major_triggers, major_maxtriggers, major_threshold); } if ((reset_interval > 0) && (major_triggers || minor_triggers) && (clock_tick > (last_trigger + reset_interval))) { WARNING("Resetting watchdog timer trigger counts, as it has not been triggered in over %dms.", clock_tick - last_trigger); major_triggers = minor_triggers = 0; } last_fire = clock_tick; setPaused(); // Return this task to a paused state return true; }
static int downloadstatuscallback(http_t *http, double downloadsize, double downloaded, double uploadsize, double uploaded) { request_t *req = http->request; ullong elapsed = http->downloadstart ? getmilliseconds()-http->downloadstart : 0; return req->statuscallback(http->getrequestid(), req->callbackdata, downloadsize, downloaded, elapsed) ? 0 : -1; }