/*
- * Copyright (C) 1996-2014 The Squid Software Foundation and contributors
+ * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
*
* Squid software is distributed under GPLv2+ license and includes
* contributions from numerous individuals and organizations.
#include "squid.h"
#include "base/AsyncCbdataCalls.h"
+#include "base/Packable.h"
+#include "base/Raw.h"
#include "comm.h"
#include "comm/Connection.h"
#include "comm/Read.h"
#include "comm/Write.h"
+#include "debug/Messages.h"
#include "fd.h"
#include "fde.h"
#include "format/Quoting.h"
#include "helper.h"
#include "helper/Reply.h"
#include "helper/Request.h"
-#include "Mem.h"
#include "MemBuf.h"
+#include "SquidConfig.h"
#include "SquidIpc.h"
#include "SquidMath.h"
-#include "SquidTime.h"
#include "Store.h"
#include "wordlist.h"
+// helper_stateful_server::data uses explicit alloc()/freeOne() */
+#include "mem/Pool.h"
+
#define HELPER_MAX_ARGS 64
-/** Initial Squid input buffer size. Helper responses may exceed this, and
- * Squid will grow the input buffer as needed, up to ReadBufMaxSize.
- */
-const size_t ReadBufMinSize(4*1024);
+/// The maximum allowed request retries.
+#define MAX_RETRIES 2
-/** Maximum safe size of a helper-to-Squid response message plus one.
- * Squid will warn and close the stream if a helper sends a too-big response.
- * ssl_crtd helper is known to produce responses of at least 10KB in size.
- * Some undocumented helpers are known to produce responses exceeding 8KB.
- */
-const size_t ReadBufMaxSize(32*1024);
+/// Helpers input buffer size.
+const size_t ReadBufSize(32*1024);
static IOCB helperHandleRead;
static IOCB helperStatefulHandleRead;
-static void helperServerFree(helper_server *srv);
-static void helperStatefulServerFree(helper_stateful_server *srv);
-static void Enqueue(helper * hlp, Helper::Request *);
-static Helper::Request *Dequeue(helper * hlp);
-static Helper::Request *StatefulDequeue(statefulhelper * hlp);
-static helper_server *GetFirstAvailable(helper * hlp);
-static helper_stateful_server *StatefulGetFirstAvailable(statefulhelper * hlp);
-static void helperDispatch(helper_server * srv, Helper::Request * r);
-static void helperStatefulDispatch(helper_stateful_server * srv, Helper::Request * r);
-static void helperKickQueue(helper * hlp);
-static void helperStatefulKickQueue(statefulhelper * hlp);
+static void Enqueue(Helper::Client *, Helper::Xaction *);
+static Helper::Session *GetFirstAvailable(const Helper::Client::Pointer &);
+static helper_stateful_server *StatefulGetFirstAvailable(const statefulhelper::Pointer &);
+static void helperDispatch(Helper::Session *, Helper::Xaction *);
+static void helperStatefulDispatch(helper_stateful_server * srv, Helper::Xaction * r);
+static void helperKickQueue(const Helper::Client::Pointer &);
+static void helperStatefulKickQueue(const statefulhelper::Pointer &);
static void helperStatefulServerDone(helper_stateful_server * srv);
-static void StatefulEnqueue(statefulhelper * hlp, Helper::Request * r);
-static bool helperStartStats(StoreEntry *sentry, void *hlp, const char *label);
+static void StatefulEnqueue(statefulhelper * hlp, Helper::Xaction * r);
-CBDATA_CLASS_INIT(helper);
-CBDATA_CLASS_INIT(helper_server);
-CBDATA_CLASS_INIT(statefulhelper);
+CBDATA_NAMESPACED_CLASS_INIT(Helper, Session);
CBDATA_CLASS_INIT(helper_stateful_server);
-InstanceIdDefinitions(HelperServerBase, "Hlpr");
+InstanceIdDefinitions(Helper::SessionBase, "Hlpr");
void
-HelperServerBase::initStats()
+Helper::SessionBase::initStats()
{
stats.uses=0;
stats.replies=0;
stats.pending=0;
stats.releases=0;
+ stats.timedout = 0;
}
void
-HelperServerBase::closePipesSafely(const char *id_name)
+Helper::SessionBase::closePipesSafely(const char * const id_name)
{
#if _SQUID_WINDOWS_
shutdown(writePipe->fd, SD_BOTH);
}
CloseHandle(hIpc);
}
+#else
+ (void)id_name;
#endif
}
void
-HelperServerBase::closeWritePipeSafely(const char *id_name)
+Helper::SessionBase::closeWritePipeSafely(const char * const id_name)
{
#if _SQUID_WINDOWS_
shutdown(writePipe->fd, (readPipe->fd == writePipe->fd ? SD_BOTH : SD_SEND));
}
CloseHandle(hIpc);
}
+#else
+ (void)id_name;
#endif
}
void
-helperOpenServers(helper * hlp)
+Helper::SessionBase::dropQueued()
+{
+ while (!requests.empty()) {
+ // XXX: re-schedule these on another helper?
+ const auto r = requests.front();
+ requests.pop_front();
+ void *cbdata;
+ if (cbdataReferenceValidDone(r->request.data, &cbdata)) {
+ r->reply.result = Helper::Unknown;
+ r->request.callback(cbdata, r->reply);
+ }
+
+ delete r;
+ }
+}
+
+Helper::SessionBase::~SessionBase()
+{
+ if (rbuf) {
+ memFreeBuf(rbuf_sz, rbuf);
+ rbuf = nullptr;
+ }
+}
+
+Helper::Session::~Session()
+{
+ wqueue->clean();
+ delete wqueue;
+
+ if (writebuf) {
+ writebuf->clean();
+ delete writebuf;
+ writebuf = nullptr;
+ }
+
+ if (Comm::IsConnOpen(writePipe))
+ closeWritePipeSafely(parent->id_name);
+
+ dlinkDelete(&link, &parent->servers);
+
+ assert(parent->childs.n_running > 0);
+ -- parent->childs.n_running;
+
+ assert(requests.empty());
+}
+
+void
+Helper::Session::dropQueued()
+{
+ SessionBase::dropQueued();
+ requestsIndex.clear();
+}
+
+helper_stateful_server::~helper_stateful_server()
+{
+ /* TODO: walk the local queue of requests and carry them all out */
+ if (Comm::IsConnOpen(writePipe))
+ closeWritePipeSafely(parent->id_name);
+
+ parent->cancelReservation(reservationId);
+
+ dlinkDelete(&link, &parent->servers);
+
+ assert(parent->childs.n_running > 0);
+ -- parent->childs.n_running;
+
+ assert(requests.empty());
+}
+
+void
+helperOpenServers(const Helper::Client::Pointer &hlp)
{
char *s;
char *progname;
char *procname;
const char *args[HELPER_MAX_ARGS+1]; // save space for a NULL terminator
char fd_note_buf[FD_DESC_SZ];
- helper_server *srv;
int nargs = 0;
int k;
pid_t pid;
void * hIpc;
wordlist *w;
- if (hlp->cmdline == NULL)
+ if (hlp->cmdline == nullptr)
return;
progname = hlp->cmdline->key;
/* figure out how many new child are actually needed. */
int need_new = hlp->childs.needNew();
- debugs(84, DBG_IMPORTANT, "helperOpenServers: Starting " << need_new << "/" << hlp->childs.n_max << " '" << shortname << "' processes");
+ debugs(84, Important(19), "helperOpenServers: Starting " << need_new << "/" << hlp->childs.n_max << " '" << shortname << "' processes");
if (need_new < 1) {
- debugs(84, DBG_IMPORTANT, "helperOpenServers: No '" << shortname << "' processes needed.");
+ debugs(84, Important(20), "helperOpenServers: No '" << shortname << "' processes needed.");
}
procname = (char *)xmalloc(strlen(shortname) + 3);
++nargs;
}
- args[nargs] = NULL;
+ args[nargs] = nullptr;
++nargs;
assert(nargs <= HELPER_MAX_ARGS);
+ int successfullyStarted = 0;
+
for (k = 0; k < need_new; ++k) {
getCurrentTime();
rfd = wfd = -1;
continue;
}
+ ++successfullyStarted;
++ hlp->childs.n_running;
++ hlp->childs.n_active;
- srv = new helper_server;
+ const auto srv = new Helper::Session;
srv->hIpc = hIpc;
srv->pid = pid;
srv->initStats();
srv->readPipe->fd = rfd;
srv->writePipe = new Comm::Connection;
srv->writePipe->fd = wfd;
- srv->rbuf = (char *)memAllocBuf(ReadBufMinSize, &srv->rbuf_sz);
+ srv->rbuf = (char *)memAllocBuf(ReadBufSize, &srv->rbuf_sz);
srv->wqueue = new MemBuf;
srv->roffset = 0;
- srv->requests = (Helper::Request **)xcalloc(hlp->childs.concurrency ? hlp->childs.concurrency : 1, sizeof(*srv->requests));
- srv->parent = cbdataReference(hlp);
+ srv->nextRequestId = 0;
+ srv->replyXaction = nullptr;
+ srv->ignoreToEom = false;
+ srv->parent = hlp;
dlinkAddTail(srv, &srv->link, &hlp->servers);
if (rfd == wfd) {
if (wfd != rfd)
commSetNonBlocking(wfd);
- AsyncCall::Pointer closeCall = asyncCall(5,4, "helperServerFree", cbdataDialer(helperServerFree, srv));
+ AsyncCall::Pointer closeCall = asyncCall(5,4, "Helper::Session::HelperServerClosed", cbdataDialer(Helper::Session::HelperServerClosed, srv));
comm_add_close_handler(rfd, closeCall);
+ if (hlp->timeout && hlp->childs.concurrency) {
+ AsyncCall::Pointer timeoutCall = commCbCall(84, 4, "Helper::Session::requestTimeout",
+ CommTimeoutCbPtrFun(Helper::Session::requestTimeout, srv));
+ commSetConnTimeout(srv->readPipe, hlp->timeout, timeoutCall);
+ }
+
AsyncCall::Pointer call = commCbCall(5,4, "helperHandleRead",
CommIoCbPtrFun(helperHandleRead, srv));
comm_read(srv->readPipe, srv->rbuf, srv->rbuf_sz - 1, call);
}
+ // Call handleFewerServers() before hlp->last_restart is updated because
+ // that method uses last_restart to measure the delay since previous start.
+ // TODO: Refactor last_restart code to measure failure frequency rather than
+ // detecting a helper #X failure that is being close to the helper #Y start.
+ if (successfullyStarted < need_new)
+ hlp->handleFewerServers(false);
+
hlp->last_restart = squid_curtime;
safe_free(shortname);
safe_free(procname);
* helperStatefulOpenServers: create the stateful child helper processes
*/
void
-helperStatefulOpenServers(statefulhelper * hlp)
+helperStatefulOpenServers(const statefulhelper::Pointer &hlp)
{
char *shortname;
const char *args[HELPER_MAX_ARGS+1]; // save space for a NULL terminator
char fd_note_buf[FD_DESC_SZ];
int nargs = 0;
- if (hlp->cmdline == NULL)
+ if (hlp->cmdline == nullptr)
return;
if (hlp->childs.concurrency)
++nargs;
}
- args[nargs] = NULL;
+ args[nargs] = nullptr;
++nargs;
assert(nargs <= HELPER_MAX_ARGS);
+ int successfullyStarted = 0;
+
for (int k = 0; k < need_new; ++k) {
getCurrentTime();
int rfd = -1;
continue;
}
+ ++successfullyStarted;
++ hlp->childs.n_running;
++ hlp->childs.n_active;
helper_stateful_server *srv = new helper_stateful_server;
srv->hIpc = hIpc;
srv->pid = pid;
- srv->flags.reserved = false;
srv->initStats();
srv->addr = hlp->addr;
srv->readPipe = new Comm::Connection;
srv->readPipe->fd = rfd;
srv->writePipe = new Comm::Connection;
srv->writePipe->fd = wfd;
- srv->rbuf = (char *)memAllocBuf(ReadBufMinSize, &srv->rbuf_sz);
+ srv->rbuf = (char *)memAllocBuf(ReadBufSize, &srv->rbuf_sz);
srv->roffset = 0;
- srv->parent = cbdataReference(hlp);
-
- if (hlp->datapool != NULL)
- srv->data = hlp->datapool->alloc();
+ srv->parent = hlp;
+ srv->reservationStart = 0;
dlinkAddTail(srv, &srv->link, &hlp->servers);
if (wfd != rfd)
commSetNonBlocking(wfd);
- AsyncCall::Pointer closeCall = asyncCall(5,4, "helperStatefulServerFree", cbdataDialer(helperStatefulServerFree, srv));
+ AsyncCall::Pointer closeCall = asyncCall(5,4, "helper_stateful_server::HelperServerClosed", cbdataDialer(helper_stateful_server::HelperServerClosed, srv));
comm_add_close_handler(rfd, closeCall);
AsyncCall::Pointer call = commCbCall(5,4, "helperStatefulHandleRead",
comm_read(srv->readPipe, srv->rbuf, srv->rbuf_sz - 1, call);
}
+ // Call handleFewerServers() before hlp->last_restart is updated because
+ // that method uses last_restart to measure the delay since previous start.
+ // TODO: Refactor last_restart code to measure failure frequency rather than
+ // detecting a helper #X failure that is being close to the helper #Y start.
+ if (successfullyStarted < need_new)
+ hlp->handleFewerServers(false);
+
hlp->last_restart = squid_curtime;
safe_free(shortname);
safe_free(procname);
}
void
-helperSubmit(helper * hlp, const char *buf, HLPCB * callback, void *data)
+Helper::Client::submitRequest(Helper::Xaction * const r)
{
- if (hlp == NULL) {
- debugs(84, 3, "helperSubmit: hlp == NULL");
- Helper::Reply nilReply;
- callback(data, nilReply);
- return;
+ if (const auto srv = GetFirstAvailable(this))
+ helperDispatch(srv, r);
+ else
+ Enqueue(this, r);
+
+ syncQueueStats();
+}
+
+/// handles helperSubmit() and helperStatefulSubmit() failures
+static void
+SubmissionFailure(const Helper::Client::Pointer &hlp, HLPCB *callback, void *data)
+{
+ auto result = Helper::Error;
+ if (!hlp) {
+ debugs(84, 3, "no helper");
+ result = Helper::Unknown;
}
- hlp->prepSubmit();
- hlp->submit(buf, callback, data);
+ // else pretend the helper has responded with ERR
+
+ callback(data, Helper::Reply(result));
+}
+
+void
+helperSubmit(const Helper::Client::Pointer &hlp, const char * const buf, HLPCB * const callback, void * const data)
+{
+ if (!hlp || !hlp->trySubmit(buf, callback, data))
+ SubmissionFailure(hlp, callback, data);
+}
+
+/// whether queuing an additional request would overload the helper
+bool
+Helper::Client::queueFull() const {
+ return stats.queue_size >= static_cast<int>(childs.queue_size);
}
bool
-helper::queueFull() const {
+Helper::Client::overloaded() const {
return stats.queue_size > static_cast<int>(childs.queue_size);
}
-/// prepares the helper for request submission via trySubmit() or helperSubmit()
-/// currently maintains full_time and kills Squid if the helper remains full for too long
+/// synchronizes queue-dependent measurements with the current queue state
void
-helper::prepSubmit()
+Helper::Client::syncQueueStats()
{
- if (!queueFull())
- full_time = 0;
- else if (!full_time) // may happen here if reconfigure decreases capacity
- full_time = squid_curtime;
- else if (squid_curtime - full_time > 180)
- fatalf("Too many queued %s requests", id_name);
+ if (overloaded()) {
+ if (overloadStart) {
+ debugs(84, 5, id_name << " still overloaded; dropped " << droppedRequests);
+ } else {
+ overloadStart = squid_curtime;
+ debugs(84, 3, id_name << " became overloaded");
+ }
+ } else {
+ if (overloadStart) {
+ debugs(84, 5, id_name << " is no longer overloaded");
+ if (droppedRequests) {
+ debugs(84, DBG_IMPORTANT, "helper " << id_name <<
+ " is no longer overloaded after dropping " << droppedRequests <<
+ " requests in " << (squid_curtime - overloadStart) << " seconds");
+ droppedRequests = 0;
+ }
+ overloadStart = 0;
+ }
+ }
}
+/// prepares the helper for request submission
+/// returns true if and only if the submission should proceed
+/// may kill Squid if the helper remains overloaded for too long
bool
-helper::trySubmit(const char *buf, HLPCB * callback, void *data)
+Helper::Client::prepSubmit()
{
- prepSubmit();
+ // re-sync for the configuration may have changed since the last submission
+ syncQueueStats();
+
+ // Nothing special to do if the new request does not overload (i.e., the
+ // queue is not even full yet) or only _starts_ overloading this helper
+ // (i.e., the queue is currently at its limit).
+ if (!overloaded())
+ return true;
+
+ if (squid_curtime - overloadStart <= 180)
+ return true; // also OK: overload has not persisted long enough to panic
- if (queueFull()) {
- debugs(84, DBG_IMPORTANT, id_name << " drops request due to a full queue");
- return false; // request was ignored
+ if (childs.onPersistentOverload == ChildConfig::actDie)
+ fatalf("Too many queued %s requests; see on-persistent-overload.", id_name);
+
+ if (!droppedRequests) {
+ debugs(84, DBG_IMPORTANT, "WARNING: dropping requests to overloaded " <<
+ id_name << " helper configured with on-persistent-overload=err");
}
+ ++droppedRequests;
+ debugs(84, 3, "failed to send " << droppedRequests << " helper requests to " << id_name);
+ return false;
+}
+
+bool
+Helper::Client::trySubmit(const char * const buf, HLPCB * const callback, void * const data)
+{
+ if (!prepSubmit())
+ return false; // request was dropped
submit(buf, callback, data); // will send or queue
return true; // request submitted or queued
/// dispatches or enqueues a helper requests; does not enforce queue limits
void
-helper::submit(const char *buf, HLPCB * callback, void *data)
+Helper::Client::submit(const char * const buf, HLPCB * const callback, void * const data)
{
- Helper::Request *r = new Helper::Request(callback, data, buf);
- helper_server *srv;
+ const auto r = new Xaction(callback, data, buf);
+ submitRequest(r);
+ debugs(84, DBG_DATA, Raw("buf", buf, strlen(buf)));
+}
- if ((srv = GetFirstAvailable(this)))
- helperDispatch(srv, r);
- else
- Enqueue(this, r);
+/// Submit request or callback the caller with a Helper::Error error.
+/// If the reservation is not set then reserves a new helper.
+void
+helperStatefulSubmit(const statefulhelper::Pointer &hlp, const char *buf, HLPCB * callback, void *data, const Helper::ReservationId & reservation)
+{
+ if (!hlp || !hlp->trySubmit(buf, callback, data, reservation))
+ SubmissionFailure(hlp, callback, data);
+}
- debugs(84, DBG_DATA, Raw("buf", buf, strlen(buf)));
+/// If possible, submit request. Otherwise, either kill Squid or return false.
+bool
+statefulhelper::trySubmit(const char *buf, HLPCB * callback, void *data, const Helper::ReservationId & reservation)
+{
+ if (!prepSubmit())
+ return false; // request was dropped
+
+ submit(buf, callback, data, reservation); // will send or queue
+ return true; // request submitted or queued
+}
- if (!queueFull()) {
- full_time = 0;
- } else if (!full_time) {
- debugs(84, 3, id_name << " queue became full");
- full_time = squid_curtime;
+void
+statefulhelper::reserveServer(helper_stateful_server * srv)
+{
+ // clear any old reservation
+ if (srv->reserved()) {
+ reservations.erase(srv->reservationId);
+ srv->clearReservation();
}
+
+ srv->reserve();
+ reservations.insert(Reservations::value_type(srv->reservationId, srv));
}
-/// lastserver = "server last used as part of a reserved request sequence"
void
-helperStatefulSubmit(statefulhelper * hlp, const char *buf, HLPCB * callback, void *data, helper_stateful_server * lastserver)
+statefulhelper::cancelReservation(const Helper::ReservationId reservation)
{
- if (hlp == NULL) {
- debugs(84, 3, "helperStatefulSubmit: hlp == NULL");
- Helper::Reply nilReply;
- callback(data, nilReply);
+ const auto it = reservations.find(reservation);
+ if (it == reservations.end())
return;
- }
- hlp->prepSubmit();
- hlp->submit(buf, callback, data, lastserver);
+
+ helper_stateful_server *srv = it->second;
+ reservations.erase(it);
+ srv->clearReservation();
+
+ // schedule a queue kick
+ AsyncCall::Pointer call = asyncCall(5,4, "helperStatefulServerDone", cbdataDialer(helperStatefulServerDone, srv));
+ ScheduleCallHere(call);
+}
+
+helper_stateful_server *
+statefulhelper::findServer(const Helper::ReservationId & reservation)
+{
+ const auto it = reservations.find(reservation);
+ if (it == reservations.end())
+ return nullptr;
+ return it->second;
}
-void statefulhelper::submit(const char *buf, HLPCB * callback, void *data, helper_stateful_server * lastserver)
+void
+helper_stateful_server::reserve()
{
- Helper::Request *r = new Helper::Request(callback, data, buf);
+ assert(!reservationId);
+ reservationStart = squid_curtime;
+ reservationId = Helper::ReservationId::Next();
+ debugs(84, 3, "srv-" << index << " reservation id = " << reservationId);
+}
- if ((buf != NULL) && lastserver) {
- debugs(84, 5, "StatefulSubmit with lastserver " << lastserver);
- assert(lastserver->flags.reserved);
- assert(!(lastserver->request));
+void
+helper_stateful_server::clearReservation()
+{
+ debugs(84, 3, "srv-" << index << " reservation id = " << reservationId);
+ if (!reservationId)
+ return;
+ ++stats.releases;
+
+ reservationId.clear();
+ reservationStart = 0;
+}
+
+void
+statefulhelper::submit(const char *buf, HLPCB * callback, void *data, const Helper::ReservationId & reservation)
+{
+ Helper::Xaction *r = new Helper::Xaction(callback, data, buf);
+
+ if (buf && reservation) {
+ debugs(84, 5, reservation);
+ helper_stateful_server *lastServer = findServer(reservation);
+ if (!lastServer) {
+ debugs(84, DBG_CRITICAL, "ERROR: Helper " << id_name << " reservation expired (" << reservation << ")");
+ r->reply.result = Helper::TimedOut;
+ r->request.callback(r->request.data, r->reply);
+ delete r;
+ return;
+ }
debugs(84, 5, "StatefulSubmit dispatching");
- helperStatefulDispatch(lastserver, r);
+ helperStatefulDispatch(lastServer, r);
} else {
helper_stateful_server *srv;
if ((srv = StatefulGetFirstAvailable(this))) {
+ reserveServer(srv);
helperStatefulDispatch(srv, r);
} else
StatefulEnqueue(this, r);
}
- debugs(84, DBG_DATA, "placeholder: '" << r->placeholder <<
+ debugs(84, DBG_DATA, "placeholder: '" << r->request.placeholder <<
"', " << Raw("buf", buf, (!buf?0:strlen(buf))));
- if (!queueFull()) {
- full_time = 0;
- } else if (!full_time) {
- debugs(84, 3, id_name << " queue became full");
- full_time = squid_curtime;
- }
+ syncQueueStats();
}
-/**
- * DPW 2007-05-08
- *
- * helperStatefulReleaseServer tells the helper that whoever was
- * using it no longer needs its services.
- */
void
-helperStatefulReleaseServer(helper_stateful_server * srv)
+Helper::Client::packStatsInto(Packable * const p, const char * const label) const
{
- debugs(84, 3, HERE << "srv-" << srv->index << " flags.reserved = " << srv->flags.reserved);
- if (!srv->flags.reserved)
- return;
-
- ++ srv->stats.releases;
-
- srv->flags.reserved = false;
- if (srv->parent->OnEmptyQueue != NULL && srv->data)
- srv->parent->OnEmptyQueue(srv->data);
+ if (label)
+ p->appendf("%s:\n", label);
+
+ p->appendf(" program: %s\n", cmdline->key);
+ p->appendf(" number active: %d of %d (%d shutting down)\n", childs.n_active, childs.n_max, (childs.n_running - childs.n_active));
+ p->appendf(" requests sent: %d\n", stats.requests);
+ p->appendf(" replies received: %d\n", stats.replies);
+ p->appendf(" requests timedout: %d\n", stats.timedout);
+ p->appendf(" queue length: %d\n", stats.queue_size);
+ p->appendf(" avg service time: %d msec\n", stats.avg_svc_time);
+ p->append("\n",1);
+ p->appendf("%7s\t%7s\t%7s\t%11s\t%11s\t%11s\t%6s\t%7s\t%7s\t%7s\n",
+ "ID #",
+ "FD",
+ "PID",
+ "# Requests",
+ "# Replies",
+ "# Timed-out",
+ "Flags",
+ "Time",
+ "Offset",
+ "Request");
+
+ for (dlink_node *link = servers.head; link; link = link->next) {
+ const auto srv = static_cast<SessionBase *>(link->data);
+ assert(srv);
+ const auto xaction = srv->requests.empty() ? nullptr : srv->requests.front();
+ double tt = 0.001 * (xaction ? tvSubMsec(xaction->request.dispatch_time, current_time) : tvSubMsec(srv->dispatch_time, srv->answer_time));
+ p->appendf("%7u\t%7d\t%7d\t%11" PRIu64 "\t%11" PRIu64 "\t%11" PRIu64 "\t%c%c%c%c%c%c\t%7.3f\t%7d\t%s\n",
+ srv->index.value,
+ srv->readPipe->fd,
+ srv->pid,
+ srv->stats.uses,
+ srv->stats.replies,
+ srv->stats.timedout,
+ srv->stats.pending ? 'B' : ' ',
+ srv->flags.writing ? 'W' : ' ',
+ srv->flags.closing ? 'C' : ' ',
+ srv->reserved() ? 'R' : ' ',
+ srv->flags.shutdown ? 'S' : ' ',
+ xaction && xaction->request.placeholder ? 'P' : ' ',
+ tt < 0.0 ? 0.0 : tt,
+ (int) srv->roffset,
+ xaction ? Format::QuoteMimeBlob(xaction->request.buf) : "(none)");
+ }
- helperStatefulServerDone(srv);
+ p->append("\nFlags key:\n"
+ " B\tBUSY\n"
+ " W\tWRITING\n"
+ " C\tCLOSING\n"
+ " R\tRESERVED\n"
+ " S\tSHUTDOWN PENDING\n"
+ " P\tPLACEHOLDER\n", 101);
}
-/** return a pointer to the stateful routines data area */
-void *
-helperStatefulServerGetData(helper_stateful_server * srv)
-{
- return srv->data;
+bool
+Helper::Client::willOverload() const {
+ return queueFull() && !(childs.needNew() || GetFirstAvailable(this));
}
-/**
- * Dump some stats about the helper states to a StoreEntry
- */
-void
-helperStats(StoreEntry * sentry, helper * hlp, const char *label)
+Helper::Client::Pointer
+Helper::Client::Make(const char * const name)
{
- if (!helperStartStats(sentry, hlp, label))
- return;
-
- storeAppendPrintf(sentry, "program: %s\n",
- hlp->cmdline->key);
- storeAppendPrintf(sentry, "number active: %d of %d (%d shutting down)\n",
- hlp->childs.n_active, hlp->childs.n_max, (hlp->childs.n_running - hlp->childs.n_active) );
- storeAppendPrintf(sentry, "requests sent: %d\n",
- hlp->stats.requests);
- storeAppendPrintf(sentry, "replies received: %d\n",
- hlp->stats.replies);
- storeAppendPrintf(sentry, "queue length: %d\n",
- hlp->stats.queue_size);
- storeAppendPrintf(sentry, "avg service time: %d msec\n",
- hlp->stats.avg_svc_time);
- storeAppendPrintf(sentry, "\n");
- storeAppendPrintf(sentry, "%7s\t%7s\t%7s\t%11s\t%11s\t%s\t%7s\t%7s\t%7s\n",
- "ID #",
- "FD",
- "PID",
- "# Requests",
- "# Replies",
- "Flags",
- "Time",
- "Offset",
- "Request");
-
- for (dlink_node *link = hlp->servers.head; link; link = link->next) {
- helper_server *srv = (helper_server*)link->data;
- double tt = 0.001 * (srv->requests[0] ? tvSubMsec(srv->requests[0]->dispatch_time, current_time) : tvSubMsec(srv->dispatch_time, srv->answer_time));
- storeAppendPrintf(sentry, "%7u\t%7d\t%7d\t%11" PRIu64 "\t%11" PRIu64 "\t%c%c%c%c\t%7.3f\t%7d\t%s\n",
- srv->index.value,
- srv->readPipe->fd,
- srv->pid,
- srv->stats.uses,
- srv->stats.replies,
- srv->stats.pending ? 'B' : ' ',
- srv->flags.writing ? 'W' : ' ',
- srv->flags.closing ? 'C' : ' ',
- srv->flags.shutdown ? 'S' : ' ',
- tt < 0.0 ? 0.0 : tt,
- (int) srv->roffset,
- srv->requests[0] ? Format::QuoteMimeBlob(srv->requests[0]->buf) : "(none)");
- }
-
- storeAppendPrintf(sentry, "\nFlags key:\n\n");
- storeAppendPrintf(sentry, " B = BUSY\n");
- storeAppendPrintf(sentry, " W = WRITING\n");
- storeAppendPrintf(sentry, " C = CLOSING\n");
- storeAppendPrintf(sentry, " S = SHUTDOWN PENDING\n");
+ return new Client(name);
}
-void
-helperStatefulStats(StoreEntry * sentry, statefulhelper * hlp, const char *label)
+statefulhelper::Pointer
+statefulhelper::Make(const char *name)
{
- if (!helperStartStats(sentry, hlp, label))
- return;
-
- storeAppendPrintf(sentry, "program: %s\n",
- hlp->cmdline->key);
- storeAppendPrintf(sentry, "number active: %d of %d (%d shutting down)\n",
- hlp->childs.n_active, hlp->childs.n_max, (hlp->childs.n_running - hlp->childs.n_active) );
- storeAppendPrintf(sentry, "requests sent: %d\n",
- hlp->stats.requests);
- storeAppendPrintf(sentry, "replies received: %d\n",
- hlp->stats.replies);
- storeAppendPrintf(sentry, "queue length: %d\n",
- hlp->stats.queue_size);
- storeAppendPrintf(sentry, "avg service time: %d msec\n",
- hlp->stats.avg_svc_time);
- storeAppendPrintf(sentry, "\n");
- storeAppendPrintf(sentry, "%7s\t%7s\t%7s\t%11s\t%11s\t%6s\t%7s\t%7s\t%7s\n",
- "ID #",
- "FD",
- "PID",
- "# Requests",
- "# Replies",
- "Flags",
- "Time",
- "Offset",
- "Request");
-
- for (dlink_node *link = hlp->servers.head; link; link = link->next) {
- helper_stateful_server *srv = (helper_stateful_server *)link->data;
- double tt = 0.001 * tvSubMsec(srv->dispatch_time, srv->stats.pending ? current_time : srv->answer_time);
- storeAppendPrintf(sentry, "%7u\t%7d\t%7d\t%11" PRIu64 "\t%11" PRIu64 "\t%c%c%c%c%c\t%7.3f\t%7d\t%s\n",
- srv->index.value,
- srv->readPipe->fd,
- srv->pid,
- srv->stats.uses,
- srv->stats.replies,
- srv->stats.pending ? 'B' : ' ',
- srv->flags.closing ? 'C' : ' ',
- srv->flags.reserved ? 'R' : ' ',
- srv->flags.shutdown ? 'S' : ' ',
- srv->request ? (srv->request->placeholder ? 'P' : ' ') : ' ',
- tt < 0.0 ? 0.0 : tt,
- (int) srv->roffset,
- srv->request ? Format::QuoteMimeBlob(srv->request->buf) : "(none)");
- }
-
- storeAppendPrintf(sentry, "\nFlags key:\n\n");
- storeAppendPrintf(sentry, " B = BUSY\n");
- storeAppendPrintf(sentry, " C = CLOSING\n");
- storeAppendPrintf(sentry, " R = RESERVED\n");
- storeAppendPrintf(sentry, " S = SHUTDOWN PENDING\n");
- storeAppendPrintf(sentry, " P = PLACEHOLDER\n");
+ return new statefulhelper(name);
}
void
-helperShutdown(helper * hlp)
+helperShutdown(const Helper::Client::Pointer &hlp)
{
dlink_node *link = hlp->servers.head;
while (link) {
- helper_server *srv;
- srv = (helper_server *)link->data;
+ const auto srv = static_cast<Helper::Session *>(link->data);
link = link->next;
if (srv->flags.shutdown) {
assert(hlp->childs.n_active > 0);
-- hlp->childs.n_active;
- srv->flags.shutdown = true; /* request it to shut itself down */
+ srv->flags.shutdown = true; /* request it to shut itself down */
if (srv->flags.closing) {
debugs(84, 3, "helperShutdown: " << hlp->id_name << " #" << srv->index << " is CLOSING.");
}
void
-helperStatefulShutdown(statefulhelper * hlp)
+helperStatefulShutdown(const statefulhelper::Pointer &hlp)
{
dlink_node *link = hlp->servers.head;
helper_stateful_server *srv;
assert(hlp->childs.n_active > 0);
-- hlp->childs.n_active;
- srv->flags.shutdown = true; /* request it to shut itself down */
+ srv->flags.shutdown = true; /* request it to shut itself down */
if (srv->stats.pending) {
debugs(84, 3, "helperStatefulShutdown: " << hlp->id_name << " #" << srv->index << " is BUSY.");
continue;
}
- if (srv->flags.reserved) {
+ if (srv->reserved()) {
if (shutting_down) {
debugs(84, 3, "helperStatefulShutdown: " << hlp->id_name << " #" << srv->index << " is RESERVED. Closing anyway.");
} else {
}
}
-helper::~helper()
+Helper::Client::~Client()
{
/* note, don't free id_name, it probably points to static memory */
- if (queue.head)
+ // TODO: if the queue is not empty it will leak Helper::Request's
+ if (!queue.empty())
debugs(84, DBG_CRITICAL, "WARNING: freeing " << id_name << " helper with " << stats.queue_size << " requests queued");
}
-/* ====================================================================== */
-/* LOCAL FUNCTIONS */
-/* ====================================================================== */
-
-static void
-helperServerFree(helper_server *srv)
+void
+Helper::Client::handleKilledServer(SessionBase * const srv, bool &needsNewServers)
{
- helper *hlp = srv->parent;
- Helper::Request *r;
- int i, concurrency = hlp->childs.concurrency;
-
- if (!concurrency)
- concurrency = 1;
-
- if (srv->rbuf) {
- memFreeBuf(srv->rbuf_sz, srv->rbuf);
- srv->rbuf = NULL;
- }
-
- srv->wqueue->clean();
- delete srv->wqueue;
-
- if (srv->writebuf) {
- srv->writebuf->clean();
- delete srv->writebuf;
- srv->writebuf = NULL;
- }
-
- if (Comm::IsConnOpen(srv->writePipe))
- srv->closeWritePipeSafely(hlp->id_name);
-
- dlinkDelete(&srv->link, &hlp->servers);
-
- assert(hlp->childs.n_running > 0);
- -- hlp->childs.n_running;
-
+ needsNewServers = false;
if (!srv->flags.shutdown) {
- assert(hlp->childs.n_active > 0);
- -- hlp->childs.n_active;
- debugs(84, DBG_CRITICAL, "WARNING: " << hlp->id_name << " #" << srv->index << " exited");
+ assert(childs.n_active > 0);
+ --childs.n_active;
+ debugs(84, DBG_CRITICAL, "WARNING: " << id_name << " #" << srv->index << " exited");
- if (hlp->childs.needNew() > 0) {
- debugs(80, DBG_IMPORTANT, "Too few " << hlp->id_name << " processes are running (need " << hlp->childs.needNew() << "/" << hlp->childs.n_max << ")");
+ handleFewerServers(srv->stats.replies >= 1);
- if (hlp->childs.n_active < hlp->childs.n_startup && hlp->last_restart > squid_curtime - 30) {
- if (srv->stats.replies < 1)
- fatalf("The %s helpers are crashing too rapidly, need help!\n", hlp->id_name);
- else
- debugs(80, DBG_CRITICAL, "ERROR: The " << hlp->id_name << " helpers are crashing too rapidly, need help!");
- }
-
- debugs(80, DBG_IMPORTANT, "Starting new helpers");
- helperOpenServers(hlp);
+ if (childs.needNew() > 0) {
+ srv->flags.shutdown = true;
+ needsNewServers = true;
}
}
+}
- for (i = 0; i < concurrency; ++i) {
- // XXX: re-schedule these on another helper?
- if ((r = srv->requests[i])) {
- void *cbdata;
+void
+Helper::Client::handleFewerServers(const bool madeProgress)
+{
+ const auto needNew = childs.needNew();
- if (cbdataReferenceValidDone(r->data, &cbdata)) {
- Helper::Reply nilReply;
- r->callback(cbdata, nilReply);
- }
+ if (!needNew)
+ return; // some server(s) have died, but we still have enough
- delete r;
+ debugs(80, DBG_IMPORTANT, "Too few " << id_name << " processes are running (need " << needNew << "/" << childs.n_max << ")" <<
+ Debug::Extra << "active processes: " << childs.n_active <<
+ Debug::Extra << "processes configured to start at (re)configuration: " << childs.n_startup);
- srv->requests[i] = NULL;
- }
+ if (childs.n_active < childs.n_startup && last_restart > squid_curtime - 30) {
+ if (madeProgress)
+ debugs(80, DBG_CRITICAL, "ERROR: The " << id_name << " helpers are crashing too rapidly, need help!");
+ else
+ fatalf("The %s helpers are crashing too rapidly, need help!", id_name);
}
- safe_free(srv->requests);
-
- cbdataReferenceDone(srv->parent);
- delete srv;
}
-static void
-helperStatefulServerFree(helper_stateful_server *srv)
+void
+Helper::Session::HelperServerClosed(Session * const srv)
{
- statefulhelper *hlp = srv->parent;
- Helper::Request *r;
+ const auto hlp = srv->parent;
- if (srv->rbuf) {
- memFreeBuf(srv->rbuf_sz, srv->rbuf);
- srv->rbuf = NULL;
+ bool needsNewServers = false;
+ hlp->handleKilledServer(srv, needsNewServers);
+ if (needsNewServers) {
+ debugs(80, DBG_IMPORTANT, "Starting new helpers");
+ helperOpenServers(hlp);
}
-#if 0
- srv->wqueue->clean();
-
- delete srv->wqueue;
-
-#endif
-
- /* TODO: walk the local queue of requests and carry them all out */
- if (Comm::IsConnOpen(srv->writePipe))
- srv->closeWritePipeSafely(hlp->id_name);
-
- dlinkDelete(&srv->link, &hlp->servers);
-
- assert(hlp->childs.n_running > 0);
- -- hlp->childs.n_running;
-
- if (!srv->flags.shutdown) {
- assert( hlp->childs.n_active > 0);
- -- hlp->childs.n_active;
- debugs(84, DBG_CRITICAL, "WARNING: " << hlp->id_name << " #" << srv->index << " exited");
+ srv->dropQueued();
- if (hlp->childs.needNew() > 0) {
- debugs(80, DBG_IMPORTANT, "Too few " << hlp->id_name << " processes are running (need " << hlp->childs.needNew() << "/" << hlp->childs.n_max << ")");
+ delete srv;
+}
- if (hlp->childs.n_active < hlp->childs.n_startup && hlp->last_restart > squid_curtime - 30) {
- if (srv->stats.replies < 1)
- fatalf("The %s helpers are crashing too rapidly, need help!\n", hlp->id_name);
- else
- debugs(80, DBG_CRITICAL, "ERROR: The " << hlp->id_name << " helpers are crashing too rapidly, need help!");
- }
+// XXX: Almost duplicates Helper::Session::HelperServerClosed() because helperOpenServers() is not a virtual method of the `Helper::Client` class
+// TODO: Fix the `Helper::Client` class hierarchy to use virtual functions.
+void
+helper_stateful_server::HelperServerClosed(helper_stateful_server *srv)
+{
+ const auto hlp = srv->parent;
- debugs(80, DBG_IMPORTANT, "Starting new helpers");
- helperStatefulOpenServers(hlp);
- }
+ bool needsNewServers = false;
+ hlp->handleKilledServer(srv, needsNewServers);
+ if (needsNewServers) {
+ debugs(80, DBG_IMPORTANT, "Starting new helpers");
+ helperStatefulOpenServers(hlp);
}
- if ((r = srv->request)) {
- void *cbdata;
-
- if (cbdataReferenceValidDone(r->data, &cbdata)) {
- Helper::Reply nilReply;
- nilReply.whichServer = srv;
- r->callback(cbdata, nilReply);
- }
+ srv->dropQueued();
- delete r;
+ delete srv;
+}
- srv->request = NULL;
+Helper::Xaction *
+Helper::Session::popRequest(const int request_number)
+{
+ Xaction *r = nullptr;
+ if (parent->childs.concurrency) {
+ // If concurrency supported retrieve request from ID
+ const auto it = requestsIndex.find(request_number);
+ if (it != requestsIndex.end()) {
+ r = *(it->second);
+ requests.erase(it->second);
+ requestsIndex.erase(it);
+ }
+ } else if(!requests.empty()) {
+ // Else get the first request from queue, if any
+ r = requests.front();
+ requests.pop_front();
}
- if (srv->data != NULL)
- hlp->datapool->freeOne(srv->data);
-
- cbdataReferenceDone(srv->parent);
-
- delete srv;
+ return r;
}
/// Calls back with a pointer to the buffer with the helper output
static void
-helperReturnBuffer(int request_number, helper_server * srv, helper * hlp, char * msg, char * msg_end)
+helperReturnBuffer(Helper::Session * srv, const Helper::Client::Pointer &hlp, char * const msg, const size_t msgSize, const char * const msgEnd)
{
- Helper::Request *r = srv->requests[request_number];
- if (r) {
- HLPCB *callback = r->callback;
-
- srv->requests[request_number] = NULL;
+ if (Helper::Xaction *r = srv->replyXaction) {
+ const bool hasSpace = r->reply.accumulate(msg, msgSize);
+ if (!hasSpace) {
+ debugs(84, DBG_IMPORTANT, "ERROR: Disconnecting from a " <<
+ "helper that overflowed " << srv->rbuf_sz << "-byte " <<
+ "Squid input buffer: " << hlp->id_name << " #" << srv->index);
+ srv->closePipesSafely(hlp->id_name);
+ return;
+ }
- r->callback = NULL;
+ if (!msgEnd)
+ return; // We are waiting for more data.
- void *cbdata = NULL;
- if (cbdataReferenceValidDone(r->data, &cbdata)) {
- Helper::Reply response(msg, (msg_end-msg));
- callback(cbdata, response);
+ bool retry = false;
+ if (cbdataReferenceValid(r->request.data)) {
+ r->reply.finalize();
+ if (r->reply.result == Helper::BrokenHelper && r->request.retries < MAX_RETRIES) {
+ debugs(84, DBG_IMPORTANT, "ERROR: helper: " << r->reply << ", attempt #" << (r->request.retries + 1) << " of 2");
+ retry = true;
+ } else {
+ HLPCB *callback = r->request.callback;
+ r->request.callback = nullptr;
+ void *cbdata = nullptr;
+ if (cbdataReferenceValidDone(r->request.data, &cbdata))
+ callback(cbdata, r->reply);
+ }
}
-- srv->stats.pending;
srv->answer_time = current_time;
- srv->dispatch_time = r->dispatch_time;
+ srv->dispatch_time = r->request.dispatch_time;
hlp->stats.avg_svc_time =
Math::intAverage(hlp->stats.avg_svc_time,
- tvSubMsec(r->dispatch_time, current_time),
+ tvSubMsec(r->request.dispatch_time, current_time),
hlp->stats.replies, REDIRECT_AV_FACTOR);
- delete r;
- } else {
- debugs(84, DBG_IMPORTANT, "helperHandleRead: unexpected reply on channel " <<
- request_number << " from " << hlp->id_name << " #" << srv->index <<
- " '" << srv->rbuf << "'");
+ // release or re-submit parsedRequestXaction object
+ srv->replyXaction = nullptr;
+ if (retry) {
+ ++r->request.retries;
+ hlp->submitRequest(r);
+ } else
+ delete r;
}
+ if (hlp->timeout && hlp->childs.concurrency)
+ srv->checkForTimedOutRequests(hlp->retryTimedOut);
+
if (!srv->flags.shutdown) {
helperKickQueue(hlp);
} else if (!srv->flags.closing && !srv->stats.pending) {
- srv->flags.closing=true;
- srv->writePipe->close();
+ srv->closeWritePipeSafely(srv->parent->id_name);
}
}
static void
-helperHandleRead(const Comm::ConnectionPointer &conn, char *buf, size_t len, Comm::Flag flag, int xerrno, void *data)
+helperHandleRead(const Comm::ConnectionPointer &conn, char *, size_t len, Comm::Flag flag, int, void *data)
{
- char *t = NULL;
- helper_server *srv = (helper_server *)data;
- helper *hlp = srv->parent;
+ const auto srv = static_cast<Helper::Session *>(data);
+ const auto hlp = srv->parent;
assert(cbdataReferenceValid(data));
/* Bail out early on Comm::ERR_CLOSING - close handlers will tidy up for us */
srv->rbuf[srv->roffset] = '\0';
debugs(84, DBG_DATA, Raw("accumulated", srv->rbuf, srv->roffset));
- if (!srv->stats.pending) {
+ if (!srv->stats.pending && !srv->stats.timedout) {
/* someone spoke without being spoken to */
- debugs(84, DBG_IMPORTANT, "helperHandleRead: unexpected read from " <<
+ debugs(84, DBG_IMPORTANT, "ERROR: helperHandleRead: unexpected read from " <<
hlp->id_name << " #" << srv->index << ", " << (int)len <<
" bytes '" << srv->rbuf << "'");
srv->rbuf[0] = '\0';
}
- while ((t = strchr(srv->rbuf, hlp->eom))) {
- /* end of reply found */
- char *msg = srv->rbuf;
- int i = 0;
- int skip = 1;
- debugs(84, 3, "helperHandleRead: end of reply found");
-
- if (t > srv->rbuf && t[-1] == '\r' && hlp->eom == '\n') {
- *t = '\0';
- // rewind to the \r octet which is the real terminal now
- // and remember that we have to skip forward 2 places now.
- skip = 2;
- --t;
+ bool needsMore = false;
+ char *msg = srv->rbuf;
+ while (*msg && !needsMore) {
+ int skip = 0;
+ char *eom = strchr(msg, hlp->eom);
+ if (eom) {
+ skip = 1;
+ debugs(84, 3, "helperHandleRead: end of reply found");
+ if (eom > msg && eom[-1] == '\r' && hlp->eom == '\n') {
+ *eom = '\0';
+ // rewind to the \r octet which is the real terminal now
+ // and remember that we have to skip forward 2 places now.
+ skip = 2;
+ --eom;
+ }
+ *eom = '\0';
}
- *t = '\0';
-
- if (hlp->childs.concurrency) {
- i = strtol(msg, &msg, 10);
-
- while (*msg && xisspace(*msg))
- ++msg;
- }
+ if (!srv->ignoreToEom && !srv->replyXaction) {
+ int i = 0;
+ if (hlp->childs.concurrency) {
+ char *e = nullptr;
+ i = strtol(msg, &e, 10);
+ // Do we need to check for e == msg? Means wrong response from helper.
+ // Will be dropped as "unexpected reply on channel 0"
+ needsMore = !(xisspace(*e) || (eom && e == eom));
+ if (!needsMore) {
+ msg = e;
+ while (*msg && xisspace(*msg))
+ ++msg;
+ } // else not enough data to compute request number
+ }
+ if (!(srv->replyXaction = srv->popRequest(i))) {
+ if (srv->stats.timedout) {
+ debugs(84, 3, "Timedout reply received for request-ID: " << i << " , ignore");
+ } else {
+ debugs(84, DBG_IMPORTANT, "ERROR: helperHandleRead: unexpected reply on channel " <<
+ i << " from " << hlp->id_name << " #" << srv->index <<
+ " '" << srv->rbuf << "'");
+ }
+ srv->ignoreToEom = true;
+ }
+ } // else we need to just append reply data to the current Xaction
+
+ if (!needsMore) {
+ size_t msgSize = eom ? eom - msg : (srv->roffset - (msg - srv->rbuf));
+ assert(msgSize <= srv->rbuf_sz);
+ helperReturnBuffer(srv, hlp, msg, msgSize, eom);
+ msg += msgSize + skip;
+ assert(static_cast<size_t>(msg - srv->rbuf) <= srv->rbuf_sz);
+
+ // The next message should not ignored.
+ if (eom && srv->ignoreToEom)
+ srv->ignoreToEom = false;
+ } else
+ assert(skip == 0 && eom == nullptr);
+ }
- helperReturnBuffer(i, srv, hlp, msg, t);
- srv->roffset -= (t - srv->rbuf) + skip;
- memmove(srv->rbuf, t + skip, srv->roffset);
+ if (needsMore) {
+ size_t msgSize = (srv->roffset - (msg - srv->rbuf));
+ assert(msgSize <= srv->rbuf_sz);
+ memmove(srv->rbuf, msg, msgSize);
+ srv->roffset = msgSize;
srv->rbuf[srv->roffset] = '\0';
+ } else {
+ // All of the responses parsed and msg points at the end of read data
+ assert(static_cast<size_t>(msg - srv->rbuf) == srv->roffset);
+ srv->roffset = 0;
}
if (Comm::IsConnOpen(srv->readPipe) && !fd_table[srv->readPipe->fd].closing()) {
int spaceSize = srv->rbuf_sz - srv->roffset - 1;
assert(spaceSize >= 0);
- // grow the input buffer if needed and possible
- if (!spaceSize && srv->rbuf_sz + 4096 <= ReadBufMaxSize) {
- srv->rbuf = (char *)memReallocBuf(srv->rbuf, srv->rbuf_sz + 4096, &srv->rbuf_sz);
- debugs(84, 3, HERE << "Grew read buffer to " << srv->rbuf_sz);
- spaceSize = srv->rbuf_sz - srv->roffset - 1;
- assert(spaceSize >= 0);
- }
-
- // quit reading if there is no space left
- if (!spaceSize) {
- debugs(84, DBG_IMPORTANT, "ERROR: Disconnecting from a " <<
- "helper that overflowed " << srv->rbuf_sz << "-byte " <<
- "Squid input buffer: " << hlp->id_name << " #" << srv->index);
- srv->closePipesSafely(hlp->id_name);
- return;
- }
-
AsyncCall::Pointer call = commCbCall(5,4, "helperHandleRead",
CommIoCbPtrFun(helperHandleRead, srv));
comm_read(srv->readPipe, srv->rbuf + srv->roffset, spaceSize, call);
}
static void
-helperStatefulHandleRead(const Comm::ConnectionPointer &conn, char *buf, size_t len, Comm::Flag flag, int xerrno, void *data)
+helperStatefulHandleRead(const Comm::ConnectionPointer &conn, char *, size_t len, Comm::Flag flag, int, void *data)
{
- char *t = NULL;
+ char *t = nullptr;
helper_stateful_server *srv = (helper_stateful_server *)data;
- Helper::Request *r;
- statefulhelper *hlp = srv->parent;
+ const auto hlp = srv->parent;
assert(cbdataReferenceValid(data));
/* Bail out early on Comm::ERR_CLOSING - close handlers will tidy up for us */
srv->roffset += len;
srv->rbuf[srv->roffset] = '\0';
- r = srv->request;
+ Helper::Xaction *r = srv->requests.front();
debugs(84, DBG_DATA, Raw("accumulated", srv->rbuf, srv->roffset));
- if (r == NULL) {
+ if (r == nullptr) {
/* someone spoke without being spoken to */
- debugs(84, DBG_IMPORTANT, "helperStatefulHandleRead: unexpected read from " <<
+ debugs(84, DBG_IMPORTANT, "ERROR: helperStatefulHandleRead: unexpected read from " <<
hlp->id_name << " #" << srv->index << ", " << (int)len <<
" bytes '" << srv->rbuf << "'");
}
if ((t = strchr(srv->rbuf, hlp->eom))) {
- /* end of reply found */
- int called = 1;
- int skip = 1;
debugs(84, 3, "helperStatefulHandleRead: end of reply found");
if (t > srv->rbuf && t[-1] == '\r' && hlp->eom == '\n') {
*t = '\0';
// rewind to the \r octet which is the real terminal now
- // and remember that we have to skip forward 2 places now.
- skip = 2;
--t;
}
*t = '\0';
+ }
+
+ if (r && !r->reply.accumulate(srv->rbuf, t ? (t - srv->rbuf) : srv->roffset)) {
+ debugs(84, DBG_IMPORTANT, "ERROR: Disconnecting from a " <<
+ "helper that overflowed " << srv->rbuf_sz << "-byte " <<
+ "Squid input buffer: " << hlp->id_name << " #" << srv->index);
+ srv->closePipesSafely(hlp->id_name);
+ return;
+ }
+ /**
+ * BUG: the below assumes that only one response per read() was received and discards any octets remaining.
+ * Doing this prohibits concurrency support with multiple replies per read().
+ * TODO: check that read() setup on these buffers pays attention to roffest!=0
+ * TODO: check that replies bigger than the buffer are discarded and do not to affect future replies
+ */
+ srv->roffset = 0;
+
+ if (t) {
+ /* end of reply found */
+ srv->requests.pop_front(); // we already have it in 'r'
+ int called = 1;
- if (r && cbdataReferenceValid(r->data)) {
- Helper::Reply res(srv->rbuf, (t - srv->rbuf));
- res.whichServer = srv;
- r->callback(r->data, res);
+ if (r && cbdataReferenceValid(r->request.data)) {
+ r->reply.finalize();
+ r->reply.reservationId = srv->reservationId;
+ r->request.callback(r->request.data, r->reply);
} else {
debugs(84, DBG_IMPORTANT, "StatefulHandleRead: no callback data registered");
called = 0;
}
- // only skip off the \0's _after_ passing its location in Helper::Reply above
- t += skip;
-
- /**
- * BUG: the below assumes that only one response per read() was received and discards any octets remaining.
- * Doing this prohibits concurrency support with multiple replies per read().
- * TODO: check that read() setup on these buffers pays attention to roffest!=0
- * TODO: check that replies bigger than the buffer are discarded and do not to affect future replies
- */
- srv->roffset = 0;
+
delete r;
- srv->request = NULL;
-- srv->stats.pending;
++ srv->stats.replies;
if (called)
helperStatefulServerDone(srv);
else
- helperStatefulReleaseServer(srv);
+ hlp->cancelReservation(srv->reservationId);
}
if (Comm::IsConnOpen(srv->readPipe) && !fd_table[srv->readPipe->fd].closing()) {
- int spaceSize = srv->rbuf_sz - srv->roffset - 1;
- assert(spaceSize >= 0);
-
- // grow the input buffer if needed and possible
- if (!spaceSize && srv->rbuf_sz + 4096 <= ReadBufMaxSize) {
- srv->rbuf = (char *)memReallocBuf(srv->rbuf, srv->rbuf_sz + 4096, &srv->rbuf_sz);
- debugs(84, 3, HERE << "Grew read buffer to " << srv->rbuf_sz);
- spaceSize = srv->rbuf_sz - srv->roffset - 1;
- assert(spaceSize >= 0);
- }
-
- // quit reading if there is no space left
- if (!spaceSize) {
- debugs(84, DBG_IMPORTANT, "ERROR: Disconnecting from a " <<
- "helper that overflowed " << srv->rbuf_sz << "-byte " <<
- "Squid input buffer: " << hlp->id_name << " #" << srv->index);
- srv->closePipesSafely(hlp->id_name);
- return;
- }
+ int spaceSize = srv->rbuf_sz - 1;
AsyncCall::Pointer call = commCbCall(5,4, "helperStatefulHandleRead",
CommIoCbPtrFun(helperStatefulHandleRead, srv));
- comm_read(srv->readPipe, srv->rbuf + srv->roffset, spaceSize, call);
+ comm_read(srv->readPipe, srv->rbuf, spaceSize, call);
}
}
/// Handles a request when all running helpers, if any, are busy.
static void
-Enqueue(helper * hlp, Helper::Request * r)
+Enqueue(Helper::Client * const hlp, Helper::Xaction * const r)
{
- dlink_node *link = (dlink_node *)memAllocate(MEM_DLINK_NODE);
- dlinkAddTail(r, link, &hlp->queue);
+ hlp->queue.push(r);
++ hlp->stats.queue_size;
/* do this first so idle=N has a chance to grow the child pool before it hits critical. */
}
static void
-StatefulEnqueue(statefulhelper * hlp, Helper::Request * r)
+StatefulEnqueue(statefulhelper * hlp, Helper::Xaction * r)
{
- dlink_node *link = (dlink_node *)memAllocate(MEM_DLINK_NODE);
- dlinkAddTail(r, link, &hlp->queue);
+ hlp->queue.push(r);
++ hlp->stats.queue_size;
/* do this first so idle=N has a chance to grow the child pool before it hits critical. */
debugs(84, DBG_CRITICAL, "WARNING: Consider increasing the number of " << hlp->id_name << " processes in your config file.");
}
-static Helper::Request *
-Dequeue(helper * hlp)
+Helper::Xaction *
+Helper::Client::nextRequest()
{
- dlink_node *link;
- Helper::Request *r = NULL;
-
- if ((link = hlp->queue.head)) {
- r = (Helper::Request *)link->data;
- dlinkDelete(link, &hlp->queue);
- memFree(link, MEM_DLINK_NODE);
- -- hlp->stats.queue_size;
- }
+ if (queue.empty())
+ return nullptr;
+ auto *r = queue.front();
+ queue.pop();
+ --stats.queue_size;
return r;
}
-static Helper::Request *
-StatefulDequeue(statefulhelper * hlp)
-{
- dlink_node *link;
- Helper::Request *r = NULL;
-
- if ((link = hlp->queue.head)) {
- r = (Helper::Request *)link->data;
- dlinkDelete(link, &hlp->queue);
- memFree(link, MEM_DLINK_NODE);
- -- hlp->stats.queue_size;
- }
-
- return r;
-}
-
-static helper_server *
-GetFirstAvailable(helper * hlp)
+static Helper::Session *
+GetFirstAvailable(const Helper::Client::Pointer &hlp)
{
dlink_node *n;
- helper_server *srv;
- helper_server *selected = NULL;
+ Helper::Session *selected = nullptr;
debugs(84, 5, "GetFirstAvailable: Running servers " << hlp->childs.n_running);
if (hlp->childs.n_running == 0)
- return NULL;
+ return nullptr;
/* Find "least" loaded helper (approx) */
- for (n = hlp->servers.head; n != NULL; n = n->next) {
- srv = (helper_server *)n->data;
+ for (n = hlp->servers.head; n != nullptr; n = n->next) {
+ const auto srv = static_cast<Helper::Session *>(n->data);
if (selected && selected->stats.pending <= srv->stats.pending)
continue;
selected = srv;
}
- /* Check for overload */
if (!selected) {
debugs(84, 5, "GetFirstAvailable: None available.");
- return NULL;
+ return nullptr;
}
if (selected->stats.pending >= (hlp->childs.concurrency ? hlp->childs.concurrency : 1)) {
- debugs(84, 3, "GetFirstAvailable: Least-loaded helper is overloaded!");
- return NULL;
+ debugs(84, 3, "GetFirstAvailable: Least-loaded helper is fully loaded!");
+ return nullptr;
}
debugs(84, 5, "GetFirstAvailable: returning srv-" << selected->index);
}
static helper_stateful_server *
-StatefulGetFirstAvailable(statefulhelper * hlp)
+StatefulGetFirstAvailable(const statefulhelper::Pointer &hlp)
{
dlink_node *n;
- helper_stateful_server *srv = NULL;
+ helper_stateful_server *srv = nullptr;
+ helper_stateful_server *oldestReservedServer = nullptr;
debugs(84, 5, "StatefulGetFirstAvailable: Running servers " << hlp->childs.n_running);
if (hlp->childs.n_running == 0)
- return NULL;
+ return nullptr;
- for (n = hlp->servers.head; n != NULL; n = n->next) {
+ for (n = hlp->servers.head; n != nullptr; n = n->next) {
srv = (helper_stateful_server *)n->data;
if (srv->stats.pending)
continue;
- if (srv->flags.reserved)
+ if (srv->reserved()) {
+ if ((squid_curtime - srv->reservationStart) > hlp->childs.reservationTimeout) {
+ if (!oldestReservedServer)
+ oldestReservedServer = srv;
+ else if (oldestReservedServer->reservationStart < srv->reservationStart)
+ oldestReservedServer = srv;
+ debugs(84, 5, "the earlier reserved server is the srv-" << oldestReservedServer->index);
+ }
continue;
+ }
if (srv->flags.shutdown)
continue;
- if ((hlp->IsAvailable != NULL) && (srv->data != NULL) && !(hlp->IsAvailable(srv->data)))
- continue;
-
debugs(84, 5, "StatefulGetFirstAvailable: returning srv-" << srv->index);
return srv;
}
+ if (oldestReservedServer) {
+ debugs(84, 5, "expired reservation " << oldestReservedServer->reservationId << " for srv-" << oldestReservedServer->index);
+ return oldestReservedServer;
+ }
+
debugs(84, 5, "StatefulGetFirstAvailable: None available.");
- return NULL;
+ return nullptr;
}
static void
-helperDispatchWriteDone(const Comm::ConnectionPointer &conn, char *buf, size_t len, Comm::Flag flag, int xerrno, void *data)
+helperDispatchWriteDone(const Comm::ConnectionPointer &, char *, size_t, Comm::Flag flag, int, void *data)
{
- helper_server *srv = (helper_server *)data;
+ const auto srv = static_cast<Helper::Session *>(data);
srv->writebuf->clean();
delete srv->writebuf;
- srv->writebuf = NULL;
+ srv->writebuf = nullptr;
srv->flags.writing = false;
if (flag != Comm::OK) {
srv->flags.writing = true;
AsyncCall::Pointer call = commCbCall(5,5, "helperDispatchWriteDone",
CommIoCbPtrFun(helperDispatchWriteDone, srv));
- Comm::Write(srv->writePipe, srv->writebuf->content(), srv->writebuf->contentSize(), call, NULL);
+ Comm::Write(srv->writePipe, srv->writebuf->content(), srv->writebuf->contentSize(), call, nullptr);
}
}
static void
-helperDispatch(helper_server * srv, Helper::Request * r)
+helperDispatch(Helper::Session * const srv, Helper::Xaction * const r)
{
- helper *hlp = srv->parent;
- Helper::Request **ptr = NULL;
- unsigned int slot;
+ const auto hlp = srv->parent;
+ const uint64_t reqId = ++srv->nextRequestId;
- if (!cbdataReferenceValid(r->data)) {
- debugs(84, DBG_IMPORTANT, "helperDispatch: invalid callback data");
+ if (!cbdataReferenceValid(r->request.data)) {
+ debugs(84, DBG_IMPORTANT, "ERROR: helperDispatch: invalid callback data");
delete r;
return;
}
- for (slot = 0; slot < (hlp->childs.concurrency ? hlp->childs.concurrency : 1); ++slot) {
- if (!srv->requests[slot]) {
- ptr = &srv->requests[slot];
- break;
- }
- }
-
- assert(ptr);
- *ptr = r;
- r->dispatch_time = current_time;
+ r->request.Id = reqId;
+ const auto it = srv->requests.insert(srv->requests.end(), r);
+ r->request.dispatch_time = current_time;
if (srv->wqueue->isNull())
srv->wqueue->init();
- if (hlp->childs.concurrency)
- srv->wqueue->Printf("%d %s", slot, r->buf);
- else
- srv->wqueue->append(r->buf, strlen(r->buf));
+ if (hlp->childs.concurrency) {
+ srv->requestsIndex.insert(Helper::Session::RequestIndex::value_type(reqId, it));
+ assert(srv->requestsIndex.size() == srv->requests.size());
+ srv->wqueue->appendf("%" PRIu64 " %s", reqId, r->request.buf);
+ } else
+ srv->wqueue->append(r->request.buf, strlen(r->request.buf));
if (!srv->flags.writing) {
- assert(NULL == srv->writebuf);
+ assert(nullptr == srv->writebuf);
srv->writebuf = srv->wqueue;
srv->wqueue = new MemBuf;
srv->flags.writing = true;
AsyncCall::Pointer call = commCbCall(5,5, "helperDispatchWriteDone",
CommIoCbPtrFun(helperDispatchWriteDone, srv));
- Comm::Write(srv->writePipe, srv->writebuf->content(), srv->writebuf->contentSize(), call, NULL);
+ Comm::Write(srv->writePipe, srv->writebuf->content(), srv->writebuf->contentSize(), call, nullptr);
}
- debugs(84, 5, "helperDispatch: Request sent to " << hlp->id_name << " #" << srv->index << ", " << strlen(r->buf) << " bytes");
+ debugs(84, 5, "helperDispatch: Request sent to " << hlp->id_name << " #" << srv->index << ", " << strlen(r->request.buf) << " bytes");
++ srv->stats.uses;
++ srv->stats.pending;
}
static void
-helperStatefulDispatchWriteDone(const Comm::ConnectionPointer &conn, char *buf, size_t len, Comm::Flag flag,
- int xerrno, void *data)
-{
- /* nothing! */
-}
+helperStatefulDispatchWriteDone(const Comm::ConnectionPointer &, char *, size_t, Comm::Flag, int, void *)
+{}
static void
-helperStatefulDispatch(helper_stateful_server * srv, Helper::Request * r)
+helperStatefulDispatch(helper_stateful_server * srv, Helper::Xaction * r)
{
- statefulhelper *hlp = srv->parent;
+ const auto hlp = srv->parent;
- if (!cbdataReferenceValid(r->data)) {
- debugs(84, DBG_IMPORTANT, "helperStatefulDispatch: invalid callback data");
+ if (!cbdataReferenceValid(r->request.data)) {
+ debugs(84, DBG_IMPORTANT, "ERROR: helperStatefulDispatch: invalid callback data");
delete r;
- helperStatefulReleaseServer(srv);
+ hlp->cancelReservation(srv->reservationId);
return;
}
debugs(84, 9, "helperStatefulDispatch busying helper " << hlp->id_name << " #" << srv->index);
- if (r->placeholder == 1) {
+ assert(srv->reservationId);
+ r->reply.reservationId = srv->reservationId;
+
+ if (r->request.placeholder == 1) {
/* a callback is needed before this request can _use_ a helper. */
/* we don't care about releasing this helper. The request NEVER
* gets to the helper. So we throw away the return code */
- Helper::Reply nilReply;
- nilReply.whichServer = srv;
- r->callback(r->data, nilReply);
+ r->reply.result = Helper::Unknown;
+ r->request.callback(r->request.data, r->reply);
/* throw away the placeholder */
delete r;
/* and push the queue. Note that the callback may have submitted a new
* request to the helper which is why we test for the request */
- if (srv->request == NULL)
+ if (!srv->requests.size())
helperStatefulServerDone(srv);
return;
}
- srv->flags.reserved = true;
- srv->request = r;
+ srv->requests.push_back(r);
srv->dispatch_time = current_time;
AsyncCall::Pointer call = commCbCall(5,5, "helperStatefulDispatchWriteDone",
- CommIoCbPtrFun(helperStatefulDispatchWriteDone, hlp));
- Comm::Write(srv->writePipe, r->buf, strlen(r->buf), call, NULL);
+ CommIoCbPtrFun(helperStatefulDispatchWriteDone, srv));
+ Comm::Write(srv->writePipe, r->request.buf, strlen(r->request.buf), call, nullptr);
debugs(84, 5, "helperStatefulDispatch: Request sent to " <<
hlp->id_name << " #" << srv->index << ", " <<
- (int) strlen(r->buf) << " bytes");
+ (int) strlen(r->request.buf) << " bytes");
++ srv->stats.uses;
++ srv->stats.pending;
}
static void
-helperKickQueue(helper * hlp)
+helperKickQueue(const Helper::Client::Pointer &hlp)
{
- Helper::Request *r;
- helper_server *srv;
+ Helper::Xaction *r = nullptr;
+ Helper::Session *srv = nullptr;
- while ((srv = GetFirstAvailable(hlp)) && (r = Dequeue(hlp)))
+ while ((srv = GetFirstAvailable(hlp)) && (r = hlp->nextRequest()))
helperDispatch(srv, r);
}
static void
-helperStatefulKickQueue(statefulhelper * hlp)
+helperStatefulKickQueue(const statefulhelper::Pointer &hlp)
{
- Helper::Request *r;
+ Helper::Xaction *r;
helper_stateful_server *srv;
-
- while ((srv = StatefulGetFirstAvailable(hlp)) && (r = StatefulDequeue(hlp)))
+ while ((srv = StatefulGetFirstAvailable(hlp)) && (r = hlp->nextRequest())) {
+ debugs(84, 5, "found srv-" << srv->index);
+ hlp->reserveServer(srv);
helperStatefulDispatch(srv, r);
+ }
}
static void
{
if (!srv->flags.shutdown) {
helperStatefulKickQueue(srv->parent);
- } else if (!srv->flags.closing && !srv->flags.reserved && !srv->stats.pending) {
+ } else if (!srv->flags.closing && !srv->reserved() && !srv->stats.pending) {
srv->closeWritePipeSafely(srv->parent->id_name);
return;
}
}
-// TODO: should helper_ and helper_stateful_ have a common parent?
-static bool
-helperStartStats(StoreEntry *sentry, void *hlp, const char *label)
+void
+Helper::Session::checkForTimedOutRequests(bool const retry)
{
- if (!hlp) {
- if (label)
- storeAppendPrintf(sentry, "%s: unavailable\n", label);
- return false;
+ assert(parent->childs.concurrency);
+ while(!requests.empty() && requests.front()->request.timedOut(parent->timeout)) {
+ const auto r = requests.front();
+ RequestIndex::iterator it;
+ it = requestsIndex.find(r->request.Id);
+ assert(it != requestsIndex.end());
+ requestsIndex.erase(it);
+ requests.pop_front();
+ debugs(84, 2, "Request " << r->request.Id << " timed-out, remove it from queue");
+ void *cbdata;
+ bool retried = false;
+ if (retry && r->request.retries < MAX_RETRIES && cbdataReferenceValid(r->request.data)) {
+ debugs(84, 2, "Retry request " << r->request.Id);
+ ++r->request.retries;
+ parent->submitRequest(r);
+ retried = true;
+ } else if (cbdataReferenceValidDone(r->request.data, &cbdata)) {
+ if (!parent->onTimedOutResponse.isEmpty()) {
+ if (r->reply.accumulate(parent->onTimedOutResponse.rawContent(), parent->onTimedOutResponse.length()))
+ r->reply.finalize();
+ else
+ r->reply.result = Helper::TimedOut;
+ r->request.callback(cbdata, r->reply);
+ } else {
+ r->reply.result = Helper::TimedOut;
+ r->request.callback(cbdata, r->reply);
+ }
+ }
+ --stats.pending;
+ ++stats.timedout;
+ ++parent->stats.timedout;
+ if (!retried)
+ delete r;
}
+}
- if (label)
- storeAppendPrintf(sentry, "%s:\n", label);
+void
+Helper::Session::requestTimeout(const CommTimeoutCbParams &io)
+{
+ debugs(26, 3, io.conn);
+ const auto srv = static_cast<Session *>(io.data);
- return true;
+ srv->checkForTimedOutRequests(srv->parent->retryTimedOut);
+
+ debugs(84, 3, io.conn << " establish a new timeout");
+ AsyncCall::Pointer timeoutCall = commCbCall(84, 4, "Helper::Session::requestTimeout",
+ CommTimeoutCbPtrFun(Session::requestTimeout, srv));
+
+ const int timeSpent = srv->requests.empty() ? 0 : (squid_curtime - srv->requests.front()->request.dispatch_time.tv_sec);
+ const int timeLeft = max(1, (static_cast<int>(srv->parent->timeout) - timeSpent));
+
+ commSetConnTimeout(io.conn, timeLeft, timeoutCall);
}
+
projects / thirdparty / squid.git / blobdiff