You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by zw...@apache.org on 2010/11/17 00:23:31 UTC
svn commit: r1035858 -
/trafficserver/plugins/stats_over_http/stats_over_http.c
Author: zwoop
Date: Tue Nov 16 23:23:31 2010
New Revision: 1035858
URL: http://svn.apache.org/viewvc?rev=1035858&view=rev
Log:
TS-521 Fix the stats-over-http plugin
Modified:
trafficserver/plugins/stats_over_http/stats_over_http.c
Modified: trafficserver/plugins/stats_over_http/stats_over_http.c
URL: http://svn.apache.org/viewvc/trafficserver/plugins/stats_over_http/stats_over_http.c?rev=1035858&r1=1035857&r2=1035858&view=diff
==============================================================================
--- trafficserver/plugins/stats_over_http/stats_over_http.c (original)
+++ trafficserver/plugins/stats_over_http/stats_over_http.c Tue Nov 16 23:23:31 2010
@@ -33,73 +33,73 @@
typedef struct stats_state_t
{
- INKVConn net_vc;
- INKVIO read_vio;
- INKVIO write_vio;
+ TSVConn net_vc;
+ TSVIO read_vio;
+ TSVIO write_vio;
- INKIOBuffer req_buffer;
- INKIOBufferReader req_reader;
+ TSIOBuffer req_buffer;
+ TSIOBufferReader req_reader;
- INKIOBuffer resp_buffer;
- INKIOBufferReader resp_reader;
+ TSIOBuffer resp_buffer;
+ TSIOBufferReader resp_reader;
- INKHttpTxn http_txnp;
+ TSHttpTxn http_txnp;
int output_bytes;
int body_written;
} stats_state;
static void
-stats_cleanup(INKCont contp, stats_state * my_state)
+stats_cleanup(TSCont contp, stats_state * my_state)
{
if (my_state->req_buffer) {
- if (INKIOBufferDestroy(my_state->req_buffer) == INK_ERROR) {
- INKDebug("istats", "INKIOBufferDestroy");
+ if (TSIOBufferDestroy(my_state->req_buffer) == TS_ERROR) {
+ TSDebug("istats", "TSIOBufferDestroy");
}
my_state->req_buffer = NULL;
}
if (my_state->resp_buffer) {
- if (INKIOBufferDestroy(my_state->resp_buffer) == INK_ERROR) {
- INKDebug("istats", "INKIOBufferDestroy");
+ if (TSIOBufferDestroy(my_state->resp_buffer) == TS_ERROR) {
+ TSDebug("istats", "TSIOBufferDestroy");
}
my_state->resp_buffer = NULL;
}
- if (INKVConnClose(my_state->net_vc) == INK_ERROR) {
- INKDebug("istats", "INKVConnClose");
+ if (TSVConnClose(my_state->net_vc) == TS_ERROR) {
+ TSDebug("istats", "TSVConnClose");
}
- INKfree(my_state);
- INKContDestroy(contp);
+ TSfree(my_state);
+ TSContDestroy(contp);
}
static void
-stats_process_accept(INKCont contp, stats_state * my_state)
+stats_process_accept(TSCont contp, stats_state * my_state)
{
- my_state->req_buffer = INKIOBufferCreate();
- if (my_state->req_buffer == INK_ERROR_PTR) {
- INKDebug("istats", "INKIOBufferCreate");
+ my_state->req_buffer = TSIOBufferCreate();
+ if (my_state->req_buffer == TS_ERROR_PTR) {
+ TSDebug("istats", "TSIOBufferCreate");
return;
}
- my_state->req_reader = INKIOBufferReaderAlloc(my_state->req_buffer);
- if (my_state->req_reader == INK_ERROR_PTR) {
- INKDebug("istats", "INKIOBufferReaderAlloc");
+ my_state->req_reader = TSIOBufferReaderAlloc(my_state->req_buffer);
+ if (my_state->req_reader == TS_ERROR_PTR) {
+ TSDebug("istats", "TSIOBufferReaderAlloc");
return;
}
- my_state->resp_buffer = INKIOBufferCreate();
- if (my_state->resp_buffer == INK_ERROR_PTR) {
- INKDebug("istats", "INKIOBufferCreate");
+ my_state->resp_buffer = TSIOBufferCreate();
+ if (my_state->resp_buffer == TS_ERROR_PTR) {
+ TSDebug("istats", "TSIOBufferCreate");
return;
}
- my_state->resp_reader = INKIOBufferReaderAlloc(my_state->resp_buffer);
- if (my_state->resp_reader == INK_ERROR_PTR) {
- INKDebug("istats", "INKIOBufferReaderAlloc");
+ my_state->resp_reader = TSIOBufferReaderAlloc(my_state->resp_buffer);
+ if (my_state->resp_reader == TS_ERROR_PTR) {
+ TSDebug("istats", "TSIOBufferReaderAlloc");
return;
}
- my_state->read_vio = INKVConnRead(my_state->net_vc, contp, my_state->req_buffer, INT_MAX);
- if (my_state->read_vio == INK_ERROR_PTR) {
- INKDebug("istats", "INKVConnRead");
+ my_state->read_vio = TSVConnRead(my_state->net_vc, contp, my_state->req_buffer, INT_MAX);
+ if (my_state->read_vio == TS_ERROR_PTR) {
+ TSDebug("istats", "TSVConnRead");
return;
}
}
@@ -108,12 +108,12 @@ static int
stats_add_data_to_resp_buffer(const char *s, stats_state * my_state)
{
int s_len = strlen(s);
- char *buf = (char *) INKmalloc(s_len);
+ char *buf = (char *) TSmalloc(s_len);
memcpy(buf, s, s_len);
- INKIOBufferWrite(my_state->resp_buffer, buf, s_len);
+ TSIOBufferWrite(my_state->resp_buffer, buf, s_len);
- INKfree(buf);
+ TSfree(buf);
buf = NULL;
return s_len;
}
@@ -127,30 +127,30 @@ stats_add_resp_header(stats_state * my_s
}
static void
-stats_process_read(INKCont contp, INKEvent event, stats_state * my_state)
+stats_process_read(TSCont contp, TSEvent event, stats_state * my_state)
{
- INKDebug("istats", "stats_process_read(%d)", event);
- if (event == INK_EVENT_VCONN_READ_READY) {
+ TSDebug("istats", "stats_process_read(%d)", event);
+ if (event == TS_EVENT_VCONN_READ_READY) {
my_state->output_bytes = stats_add_resp_header(my_state);
- if (INKVConnShutdown(my_state->net_vc, 1, 0) == INK_ERROR) {
- INKDebug("istats", "INKVConnShutdown");
+ if (TSVConnShutdown(my_state->net_vc, 1, 0) == TS_ERROR) {
+ TSDebug("istats", "TSVConnShutdown");
return;
}
- my_state->write_vio = INKVConnWrite(my_state->net_vc, contp, my_state->resp_reader, INT_MAX);
- if (my_state->write_vio == INK_ERROR_PTR) {
- INKDebug("istats", "INKVConnWrite");
+ my_state->write_vio = TSVConnWrite(my_state->net_vc, contp, my_state->resp_reader, INT_MAX);
+ if (my_state->write_vio == TS_ERROR_PTR) {
+ TSDebug("istats", "TSVConnWrite");
return;
}
- } else if (event == INK_EVENT_ERROR) {
- INKError("stats_process_read: Received INK_EVENT_ERROR\n");
- } else if (event == INK_EVENT_VCONN_EOS) {
+ } else if (event == TS_EVENT_ERROR) {
+ TSError("stats_process_read: Received TS_EVENT_ERROR\n");
+ } else if (event == TS_EVENT_VCONN_EOS) {
/* client may end the connection, simply return */
return;
- } else if (event == INK_EVENT_NET_ACCEPT_FAILED) {
- INKError("stats_process_read: Received INK_EVENT_NET_ACCEPT_FAILED\n");
+ } else if (event == TS_EVENT_NET_ACCEPT_FAILED) {
+ TSError("stats_process_read: Received TS_EVENT_NET_ACCEPT_FAILED\n");
} else {
printf("Unexpected Event %d\n", event);
- INKReleaseAssert(!"Unexpected Event");
+ TSReleaseAssert(!"Unexpected Event");
}
}
@@ -162,22 +162,22 @@ stats_process_read(INKCont contp, INKEve
} while(0)
static void
-json_out_stat(INKRecordType rec_type, void *edata, int registered,
- const char *name, INKRecordDataType data_type,
- INKRecordData *datum) {
+json_out_stat(TSRecordType rec_type, void *edata, int registered,
+ const char *name, TSRecordDataType data_type,
+ TSRecordData *datum) {
stats_state *my_state = edata;
switch(data_type) {
- case INK_RECORDDATATYPE_COUNTER:
+ case TS_RECORDDATATYPE_COUNTER:
APPEND_STAT(name, "%llu", datum->rec_counter); break;
- case INK_RECORDDATATYPE_INT:
+ case TS_RECORDDATATYPE_INT:
APPEND_STAT(name, "%llu", datum->rec_int); break;
- case INK_RECORDDATATYPE_FLOAT:
+ case TS_RECORDDATATYPE_FLOAT:
APPEND_STAT(name, "%f", datum->rec_float); break;
- case INK_RECORDDATATYPE_STRING:
+ case TS_RECORDDATATYPE_STRING:
APPEND_STAT(name, "%s", datum->rec_string); break;
default:
- INKDebug("istats", "unkown type for %s: %d", name, data_type);
+ TSDebug("istats", "unkown type for %s: %d", name, data_type);
break;
}
}
@@ -187,8 +187,8 @@ json_out_stats(stats_state * my_state)
const char *version;
APPEND("{ \"global\": {\n");
- INKRecordDump(INK_RECORDTYPE_PROCESS, json_out_stat, my_state);
- version = INKTrafficServerVersionGet();
+ TSRecordDump(TS_RECORDTYPE_PROCESS, json_out_stat, my_state);
+ version = TSTrafficServerVersionGet();
APPEND("\"server\": \"");
APPEND(version);
APPEND("\"\n");
@@ -196,99 +196,99 @@ json_out_stats(stats_state * my_state)
}
static void
-stats_process_write(INKCont contp, INKEvent event, stats_state * my_state)
+stats_process_write(TSCont contp, TSEvent event, stats_state * my_state)
{
- if (event == INK_EVENT_VCONN_WRITE_READY) {
+ if (event == TS_EVENT_VCONN_WRITE_READY) {
if (my_state->body_written == 0) {
- INKDebug("istats", "plugin adding response body");
+ TSDebug("istats", "plugin adding response body");
my_state->body_written = 1;
json_out_stats(my_state);
- if (INKVIONBytesSet(my_state->write_vio, my_state->output_bytes) == INK_ERROR) {
- INKDebug("istats", "INKVIONBytesSet");
+ if (TSVIONBytesSet(my_state->write_vio, my_state->output_bytes) == TS_ERROR) {
+ TSDebug("istats", "TSVIONBytesSet");
return;
}
}
- if (INKVIOReenable(my_state->write_vio) == INK_ERROR) {
- INKDebug("istats", "INKVIOReenable");
+ if (TSVIOReenable(my_state->write_vio) == TS_ERROR) {
+ TSDebug("istats", "TSVIOReenable");
return;
}
- } else if (INK_EVENT_VCONN_WRITE_COMPLETE) {
+ } else if (TS_EVENT_VCONN_WRITE_COMPLETE) {
stats_cleanup(contp, my_state);
- } else if (event == INK_EVENT_ERROR) {
- INKError("stats_process_write: Received INK_EVENT_ERROR\n");
+ } else if (event == TS_EVENT_ERROR) {
+ TSError("stats_process_write: Received TS_EVENT_ERROR\n");
} else {
- INKReleaseAssert(!"Unexpected Event");
+ TSReleaseAssert(!"Unexpected Event");
}
}
static int
-stats_dostuff(INKCont contp, INKEvent event, void *edata)
+stats_dostuff(TSCont contp, TSEvent event, void *edata)
{
- stats_state *my_state = INKContDataGet(contp);
- if (event == INK_EVENT_NET_ACCEPT) {
- my_state->net_vc = (INKVConn) edata;
+ stats_state *my_state = TSContDataGet(contp);
+ if (event == TS_EVENT_NET_ACCEPT) {
+ my_state->net_vc = (TSVConn) edata;
stats_process_accept(contp, my_state);
} else if (edata == my_state->read_vio) {
stats_process_read(contp, event, my_state);
} else if (edata == my_state->write_vio) {
stats_process_write(contp, event, my_state);
} else {
- INKReleaseAssert(!"Unexpected Event");
+ TSReleaseAssert(!"Unexpected Event");
}
return 0;
}
static int
-stats_origin(INKCont contp, INKEvent event, void *edata)
+stats_origin(TSCont contp, TSEvent event, void *edata)
{
- INKCont icontp;
+ TSCont icontp;
stats_state *my_state;
- INKHttpTxn txnp = (INKHttpTxn) edata;
- INKMBuffer reqp;
- INKMLoc hdr_loc = NULL, url_loc = NULL;
- INKEvent reenable = INK_EVENT_HTTP_CONTINUE;
+ TSHttpTxn txnp = (TSHttpTxn) edata;
+ TSMBuffer reqp;
+ TSMLoc hdr_loc = NULL, url_loc = NULL;
+ TSEvent reenable = TS_EVENT_HTTP_CONTINUE;
- INKDebug("istats", "in the read stuff");
+ TSDebug("istats", "in the read stuff");
- if (!INKHttpTxnClientReqGet(txnp, &reqp, &hdr_loc))
+ if (!TSHttpTxnClientReqGet(txnp, &reqp, &hdr_loc))
goto cleanup;
- url_loc = INKHttpHdrUrlGet(reqp, hdr_loc);
+ url_loc = TSHttpHdrUrlGet(reqp, hdr_loc);
int path_len = 0;
- const char * path = INKUrlPathGet(reqp,url_loc,&path_len);
- INKDebug("istats","Path: %.*s",path_len,path);
+ const char * path = TSUrlPathGet(reqp,url_loc,&path_len);
+ TSDebug("istats","Path: %.*s",path_len,path);
if (! (path_len != 0 && path_len == 6 && !memcmp(path,"_stats",6)) ) {
goto notforme;
}
- INKSkipRemappingSet(txnp,1); //not strictly necessary, but speed is everything these days
+ TSSkipRemappingSet(txnp,1); //not strictly necessary, but speed is everything these days
/* This is us -- register our intercept */
- INKDebug("istats", "Intercepting request");
+ TSDebug("istats", "Intercepting request");
- icontp = INKContCreate(stats_dostuff, INKMutexCreate());
- if (icontp == INK_ERROR_PTR) goto notforme;
- my_state = (stats_state *) INKmalloc(sizeof(*my_state));
+ icontp = TSContCreate(stats_dostuff, TSMutexCreate());
+ if (icontp == TS_ERROR_PTR) goto notforme;
+ my_state = (stats_state *) TSmalloc(sizeof(*my_state));
memset(my_state, 0, sizeof(*my_state));
- if (INK_ERROR == INKContDataSet(icontp, my_state)) goto error;
- if (INK_ERROR == INKHttpTxnIntercept(icontp, txnp)) goto error;
+ if (TS_ERROR == TSContDataSet(icontp, my_state)) goto error;
+ if (TS_ERROR == TSHttpTxnIntercept(icontp, txnp)) goto error;
goto cleanup;
error:
- INKError("[PluginInit] Error while intercepting stuff");
- INKContDestroy(icontp);
- reenable = INK_EVENT_HTTP_ERROR;
+ TSError("[PluginInit] Error while intercepting stuff");
+ TSContDestroy(icontp);
+ reenable = TS_EVENT_HTTP_ERROR;
goto cleanup;
notforme:
cleanup:
- if(path) INKHandleStringRelease(reqp, url_loc, path);
- if(url_loc) INKHandleMLocRelease(reqp, hdr_loc, url_loc);
- if(hdr_loc) INKHandleMLocRelease(reqp, INK_NULL_MLOC, hdr_loc);
+ if(path) TSHandleStringRelease(reqp, url_loc, path);
+ if(url_loc) TSHandleMLocRelease(reqp, hdr_loc, url_loc);
+ if(hdr_loc) TSHandleMLocRelease(reqp, TS_NULL_MLOC, hdr_loc);
- INKHttpTxnReenable(txnp, reenable);
+ TSHttpTxnReenable(txnp, reenable);
return 0;
}
@@ -296,7 +296,7 @@ int
check_ts_version()
{
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
int result = 0;
if (ts_version) {
@@ -318,29 +318,29 @@ check_ts_version()
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKPluginRegistrationInfo info;
+ TSPluginRegistrationInfo info;
info.plugin_name = "stats";
info.vendor_name = "Apache Software Foundation";
info.support_email = "jesus@omniti.com";
- if (!INKPluginRegister(INK_SDK_VERSION_2_0, &info))
- INKError("Plugin registration failed. \n");
+ if (!TSPluginRegister(TS_SDK_VERSION_2_0, &info))
+ TSError("Plugin registration failed. \n");
if (!check_ts_version()) {
- INKError("Plugin requires Traffic Server 2.0 or later\n");
+ TSError("Plugin requires Traffic Server 2.0 or later\n");
return;
}
/* Create a continuation with a mutex as there is a shared global structure
containing the headers to add */
- if (INK_ERROR == INKHttpHookAdd(INK_HTTP_READ_REQUEST_HDR_HOOK,
- INKContCreate(stats_origin, NULL))) {
- INKError("[PluginInit] Error while registering to hook");
+ if (TS_ERROR == TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK,
+ TSContCreate(stats_origin, NULL))) {
+ TSError("[PluginInit] Error while registering to hook");
return;
}
- INKDebug("istats", "stats module registered");
+ TSDebug("istats", "stats module registered");
}