static void helperStatefulServerFree(helper_stateful_server *srv);
static void Enqueue(helper * hlp, helper_request *);
static helper_request *Dequeue(helper * hlp);
-static helper_stateful_request *StatefulDequeue(statefulhelper * 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_stateful_request * r);
+static void helperStatefulDispatch(helper_stateful_server * srv, helper_request * r);
static void helperKickQueue(helper * hlp);
static void helperStatefulKickQueue(statefulhelper * hlp);
static void helperStatefulServerDone(helper_stateful_server * srv);
-static void helperRequestFree(helper_request * r);
-static void helperStatefulRequestFree(helper_stateful_request * r);
-static void StatefulEnqueue(statefulhelper * hlp, helper_stateful_request * r);
+static void StatefulEnqueue(statefulhelper * hlp, helper_request * r);
static bool helperStartStats(StoreEntry *sentry, void *hlp, const char *label);
CBDATA_CLASS_INIT(helper);
return;
}
- helper_request *r = new helper_request;
+ helper_request *r = new helper_request(callback, data, buf);
helper_server *srv;
- r->callback = callback;
- r->data = cbdataReference(data);
- r->buf = xstrdup(buf);
-
if ((srv = GetFirstAvailable(hlp)))
helperDispatch(srv, r);
else
return;
}
- helper_stateful_request *r = new helper_stateful_request;
-
- r->callback = callback;
- r->data = cbdataReference(data);
-
- if (buf != NULL) {
- r->buf = xstrdup(buf);
- r->placeholder = 0;
- } else {
- r->buf = NULL;
- r->placeholder = 1;
- }
+ helper_request *r = new helper_request(callback, data, buf);
if ((buf != NULL) && lastserver) {
debugs(84, 5, "StatefulSubmit with lastserver " << lastserver);
r->callback(cbdata, nilReply);
}
- helperRequestFree(r);
+ delete r;
srv->requests[i] = NULL;
}
helperStatefulServerFree(helper_stateful_server *srv)
{
statefulhelper *hlp = srv->parent;
- helper_stateful_request *r;
+ helper_request *r;
if (srv->rbuf) {
memFreeBuf(srv->rbuf_sz, srv->rbuf);
r->callback(cbdata, nilReply);
}
- helperStatefulRequestFree(r);
+ delete r;
srv->request = NULL;
}
tvSubMsec(r->dispatch_time, current_time),
hlp->stats.replies, REDIRECT_AV_FACTOR);
- helperRequestFree(r);
+ delete r;
} else {
debugs(84, DBG_IMPORTANT, "helperHandleRead: unexpected reply on channel " <<
request_number << " from " << hlp->id_name << " #" << srv->index <<
{
char *t = NULL;
helper_stateful_server *srv = (helper_stateful_server *)data;
- helper_stateful_request *r;
+ helper_request *r;
statefulhelper *hlp = srv->parent;
assert(cbdataReferenceValid(data));
* TODO: check that replies bigger than the buffer are discarded and do not to affect future replies
*/
srv->roffset = 0;
- helperStatefulRequestFree(r);
+ delete r;
srv->request = NULL;
-- srv->stats.pending;
}
static void
-StatefulEnqueue(statefulhelper * hlp, helper_stateful_request * r)
+StatefulEnqueue(statefulhelper * hlp, helper_request * r)
{
dlink_node *link = (dlink_node *)memAllocate(MEM_DLINK_NODE);
dlinkAddTail(r, link, &hlp->queue);
return r;
}
-static helper_stateful_request *
+static helper_request *
StatefulDequeue(statefulhelper * hlp)
{
dlink_node *link;
- helper_stateful_request *r = NULL;
+ helper_request *r = NULL;
if ((link = hlp->queue.head)) {
- r = (helper_stateful_request *)link->data;
+ r = (helper_request *)link->data;
dlinkDelete(link, &hlp->queue);
memFree(link, MEM_DLINK_NODE);
-- hlp->stats.queue_size;
if (!cbdataReferenceValid(r->data)) {
debugs(84, DBG_IMPORTANT, "helperDispatch: invalid callback data");
- helperRequestFree(r);
+ delete r;
return;
}
}
static void
-helperStatefulDispatch(helper_stateful_server * srv, helper_stateful_request * r)
+helperStatefulDispatch(helper_stateful_server * srv, helper_request * r)
{
statefulhelper *hlp = srv->parent;
if (!cbdataReferenceValid(r->data)) {
debugs(84, DBG_IMPORTANT, "helperStatefulDispatch: invalid callback data");
- helperStatefulRequestFree(r);
+ delete r;
helperStatefulReleaseServer(srv);
return;
}
nilReply.whichServer = srv;
r->callback(r->data, nilReply);
/* throw away the placeholder */
- helperStatefulRequestFree(r);
+ 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 */
static void
helperStatefulKickQueue(statefulhelper * hlp)
{
- helper_stateful_request *r;
+ helper_request *r;
helper_stateful_server *srv;
while ((srv = StatefulGetFirstAvailable(hlp)) && (r = StatefulDequeue(hlp)))
}
}
-static void
-helperRequestFree(helper_request * r)
-{
- cbdataReferenceDone(r->data);
- xfree(r->buf);
- delete r;
-}
-
-static void
-helperStatefulRequestFree(helper_stateful_request * r)
-{
- if (r) {
- cbdataReferenceDone(r->data);
- xfree(r->buf);
- delete r;
- }
-}
-
// TODO: should helper_ and helper_stateful_ have a common parent?
static bool
helperStartStats(StoreEntry *sentry, void *hlp, const char *label)
CBDATA_CLASS2(helper_server);
};
-class helper_stateful_request;
-
class helper_stateful_server : public HelperServerBase
{
public:
/* MemBuf writebuf; */
statefulhelper *parent;
- helper_stateful_request *request;
+ helper_request *request;
void *data; /* State data used by the calling routines */
class helper_request
{
-
public:
+ helper_request(HLPCB *c, void *d, const char *b) :
+ buf(b ? xstrdup(b) : NULL),
+ callback(c),
+ data(cbdataReference(d)),
+ placeholder(b == NULL)
+ {}
+ ~helper_request() {
+ cbdataReferenceDone(data);
+ xfree(buf);
+ }
+
MEMPROXY_CLASS(helper_request);
char *buf;
HLPCB *callback;
void *data;
+ int placeholder; /* if 1, this is a dummy request waiting for a stateful helper to become available */
struct timeval dispatch_time;
};
MEMPROXY_CLASS_INLINE(helper_request);
-class helper_stateful_request
-{
-
-public:
- MEMPROXY_CLASS(helper_stateful_request);
- char *buf;
- HLPCB *callback;
- int placeholder; /* if 1, this is a dummy request waiting for a stateful helper to become available */
- void *data;
-};
-
-MEMPROXY_CLASS_INLINE(helper_stateful_request);
-
/* helper.c */
void helperOpenServers(helper * hlp);
void helperStatefulOpenServers(statefulhelper * hlp);