You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by am...@apache.org on 2010/11/30 02:43:06 UTC
svn commit: r1040383 [25/38] - in /trafficserver/traffic/branches/wccp: ./
build/ contrib/ contrib/perl/AdminClient/lib/Apache/TS/ example/
example/add-header/ example/app-template/ example/append-transform/
example/basic-auth/ example/blacklist-0/ exa...
Modified: trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/ServerSM.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/ServerSM.cc?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/ServerSM.cc (original)
+++ trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/ServerSM.cc Tue Nov 30 01:42:55 2010
@@ -34,17 +34,17 @@ extern GlobalFDTable *global_table;
static int current_sub_sm_id = 0;
int
-server_handler(INKCont contp, INKEvent event, void *data)
+server_handler(TSCont contp, TSEvent event, void *data)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
ServerSMHandler q_current_handler = Server->q_server_current_handler;
return (*q_current_handler) (contp, event, data);
}
RaftServerStatsObject *
-RaftServerStatsObjectCreate(INKCont contp)
+RaftServerStatsObjectCreate(TSCont contp)
{
- RaftServerStatsObject *server_stats = (RaftServerStatsObject *) INKmalloc(sizeof(RaftServerStatsObject));
+ RaftServerStatsObject *server_stats = (RaftServerStatsObject *) TSmalloc(sizeof(RaftServerStatsObject));
server_stats->q_start_time = time(NULL);
server_stats->q_finished = 0;
server_stats->q_count_bytes_one_server = 0;
@@ -65,11 +65,11 @@ RaftServerStatsObjectCreate(INKCont cont
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
-INKCont
-ServerSMCreate(INKMutex pmutex)
+TSCont
+ServerSMCreate(TSMutex pmutex)
{
- ServerSM *Server = (ServerSM *) INKmalloc(sizeof(ServerSM));
- INKCont contp;
+ ServerSM *Server = (ServerSM *) TSmalloc(sizeof(ServerSM));
+ TSCont contp;
Server->q_mutex = pmutex;
Server->q_sm_id = server_sm_id_counter++;
@@ -99,9 +99,9 @@ ServerSMCreate(INKMutex pmutex)
Server->q_server_conn_status = NO_CONNECTION;
Server->q_server_calling_back_status = CONNECTED_IDLE;
- INKDebug("serversm", "[ServerSM][%u] created new server sm", Server->q_sm_id);
- contp = INKContCreate(server_handler, pmutex);
- INKContDataSet(contp, Server);
+ TSDebug("serversm", "[ServerSM][%u] created new server sm", Server->q_sm_id);
+ contp = TSContCreate(server_handler, pmutex);
+ TSContDataSet(contp, Server);
// stats
Server->server_stats = (RaftServerStatsObject *) RaftServerStatsObjectCreate(contp);
@@ -117,9 +117,9 @@ ServerSMCreate(INKMutex pmutex)
//
//////////////////////////////////////////////////////////////////////////
void
-init_parameters(INKCont contp, int glbl_indx, GlobalFDTableEntry * glbl_ptr, INKCont the_sub_contp)
+init_parameters(TSCont contp, int glbl_indx, GlobalFDTableEntry * glbl_ptr, TSCont the_sub_contp)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
Server->q_sending_sms = NULL;
Server->q_sms_to_call_back = NULL;
@@ -137,7 +137,7 @@ init_parameters(INKCont contp, int glbl_
Server->q_server_response_buffer_reader = NULL;
- Server->q_server_response_buffer = new_INKIOBuffer (RAFT_DEFAULT_BUFFER_INDEX_SIZE);
+ Server->q_server_response_buffer = new_TSIOBuffer (RAFT_DEFAULT_BUFFER_INDEX_SIZE);
Server->q_server_response_buffer_reader = Server->q_server_response_buffer->alloc_reader();
*/
// set the watermark on the buffer to the
@@ -145,7 +145,7 @@ init_parameters(INKCont contp, int glbl_
// net processor only notifies us if the
// full header is there.
// API: IOBuffer's water_mark
- INKIOBufferWaterMarkSet(Server->q_server_response_buffer, RAFT_HEADER_SIZE);
+ TSIOBufferWaterMarkSet(Server->q_server_response_buffer, RAFT_HEADER_SIZE);
assert(Server->q_server_response_buffer);
assert(Server->q_server_response_buffer_reader);
@@ -160,13 +160,13 @@ init_parameters(INKCont contp, int glbl_
//
//////////////////////////////////////////////////////////////////////////
void
-server_sm_init(INKCont contp,
+server_sm_init(TSCont contp,
char *name,
- int port, Protocols the_protocol, int glbl_indx, GlobalFDTableEntry * glbl_ptr, INKCont the_sub_contp)
+ int port, Protocols the_protocol, int glbl_indx, GlobalFDTableEntry * glbl_ptr, TSCont the_sub_contp)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
if (name) {
- Server->q_server_name = (char *) INKmalloc(sizeof(char) * (strlen(name) + 1));
+ Server->q_server_name = (char *) TSmalloc(sizeof(char) * (strlen(name) + 1));
strcpy(Server->q_server_name, name);
} else {
Server->q_server_name = NULL;
@@ -179,35 +179,35 @@ server_sm_init(INKCont contp,
Server->q_server_response_buffer = NULL;
Server->q_server_response_buffer_reader = NULL;
- Server->q_server_response_buffer = INKIOBufferCreate(); // (RAFT_DEFAULT_BUFFER_INDEX_SIZE);
- Server->q_server_response_buffer_reader = INKIOBufferReaderAlloc(Server->q_server_response_buffer);
+ Server->q_server_response_buffer = TSIOBufferCreate(); // (RAFT_DEFAULT_BUFFER_INDEX_SIZE);
+ Server->q_server_response_buffer_reader = TSIOBufferReaderAlloc(Server->q_server_response_buffer);
init_parameters(contp, glbl_indx, glbl_ptr, the_sub_contp);
add_item_to_raft_list(&(Server->q_sms_to_call_back), the_sub_contp);
assert(Server->q_server_vc == NULL);
- INKDebug("serversm", "[%u][init] No Connection Yet", Server->q_sm_id);
+ TSDebug("serversm", "[%u][init] No Connection Yet", Server->q_sm_id);
if (Server->q_server_ip == 0) {
assert(Server->q_server_name);
// issue dns lookup of hostname.
- INKDebug("serversm", "[%u][init] No Server IP - issuing DNS lookup of %s", Server->q_sm_id, Server->q_server_name);
+ TSDebug("serversm", "[%u][init] No Server IP - issuing DNS lookup of %s", Server->q_sm_id, Server->q_server_name);
set_handler(Server->q_server_current_handler, &state_dns_lookup);
- Server->q_pending_action = INKDNSLookup(contp, Server->q_server_name, strlen(Server->q_server_name));
+ Server->q_pending_action = TSDNSLookup(contp, Server->q_server_name, strlen(Server->q_server_name));
} else {
assert(Server->q_server_ip > 0);
assert(Server->q_server_port > 0);
// issue server connect.
unsigned char *p = (unsigned char *) (&Server->q_server_ip);
- INKDebug("serversm", "[%u][init] %s has resolved to %d.%d.%d.%d:%d. Connecting",
+ TSDebug("serversm", "[%u][init] %s has resolved to %d.%d.%d.%d:%d. Connecting",
Server->q_sm_id, ((Server->q_server_name) ? Server->q_server_name : "<>"),
p[0], p[1], p[2], p[3], Server->q_server_port);
// SET_HANDLER((ServerSMHandler)&state_connect_to_server);
set_handler(Server->q_server_current_handler, &state_connect_to_server);
- Server->q_pending_action = INKNetConnect(contp, Server->q_server_ip, Server->q_server_port);
+ Server->q_pending_action = TSNetConnect(contp, Server->q_server_ip, Server->q_server_port);
}
return;
@@ -220,19 +220,19 @@ server_sm_init(INKCont contp,
//
//////////////////////////////////////////////////////////////////////////
int
-accept_new_raft_command(INKCont contp, INKCont sub_contp)
+accept_new_raft_command(TSCont contp, TSCont sub_contp)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
- RaftSubSM *SubSM = (RaftSubSM *) INKContDataGet(sub_contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
+ RaftSubSM *SubSM = (RaftSubSM *) TSContDataGet(sub_contp);
current_sub_sm_id = SubSM->q_sm_id;
- INKDebug("serversm", "[accept_new_raft_command] accept_new_raft_command of sub_sm %d", current_sub_sm_id);
+ TSDebug("serversm", "[accept_new_raft_command] accept_new_raft_command of sub_sm %d", current_sub_sm_id);
add_item_to_raft_list(&(Server->q_sms_to_call_back), (void *) sub_contp);
server_send_request(contp);
- INKDebug("serversm", "leaving accept_new_raft_command");
+ TSDebug("serversm", "leaving accept_new_raft_command");
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
//////////////////////////////////////////////////////////////////////////
@@ -242,16 +242,16 @@ accept_new_raft_command(INKCont contp, I
//
//////////////////////////////////////////////////////////////////////////
void
-server_send_request(INKCont contp)
+server_send_request(TSCont contp)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
assert(Server->q_server_conn_status != CONNECTED_SENDING);
Server->q_server_conn_status = CONNECTED_SENDING;
/*
if (Server->q_server_request_buffer != NULL)
Server->q_server_request_buffer->reset();
- INKDebug("serversm",
+ TSDebug("serversm",
"[send_request] first pop up from sending_sms and then add it in call back queue");
RaftSubSM *current_sub_sm = (RaftSubSM *) pop_item_from_raft_list(&Server->q_sending_sms);
assert(current_sub_sm != NULL);
@@ -264,7 +264,7 @@ server_send_request(INKCont contp)
assert(Server->q_server_request_buffer);
assert(Server->q_server_request_buffer_reader);
- int req_len = INKIOBufferReaderAvail(Server->q_server_request_buffer_reader);
+ int req_len = TSIOBufferReaderAvail(Server->q_server_request_buffer_reader);
assert(req_len > 0);
set_handler(Server->q_server_current_handler, &state_main_event);
@@ -272,8 +272,8 @@ server_send_request(INKCont contp)
// Server->q_server_vc->set_inactivity_timeout(RAFT_SERVER_INACTIVITY_TIMEOUT);
// write down the request now.
- INKDebug("serversm", "[%u][send_request] sending %d bytes of request now.", Server->q_sm_id, req_len);
- Server->q_server_write_vio = INKVConnWrite(Server->q_server_vc, contp,
+ TSDebug("serversm", "[%u][send_request] sending %d bytes of request now.", Server->q_sm_id, req_len);
+ Server->q_server_write_vio = TSVConnWrite(Server->q_server_vc, contp,
Server->q_server_request_buffer_reader, req_len);
assert(Server->q_server_write_vio);
@@ -286,15 +286,15 @@ server_send_request(INKCont contp)
//
//////////////////////////////////////////////////////////////////////////
void
-set_current_reading_sub_sm(INKCont contp, INKCont * current_contp, unsigned int seq_num)
+set_current_reading_sub_sm(TSCont contp, TSCont * current_contp, unsigned int seq_num)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
- INKDebug("serversm", "[%u][set_current_reading_sub_sm] Header says sequence_number is %u.", Server->q_sm_id, seq_num);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
+ TSDebug("serversm", "[%u][set_current_reading_sub_sm] Header says sequence_number is %u.", Server->q_sm_id, seq_num);
if (Server->q_sms_to_call_back) {
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][set_current_reading_sub_sm] call back subsm queue is not NULL.", Server->q_sm_id, seq_num);
} else {
- INKDebug("serversm", "[%u][set_current_reading_sub_sm] call back subsm queue is NULL.", Server->q_sm_id, seq_num);
+ TSDebug("serversm", "[%u][set_current_reading_sub_sm] call back subsm queue is NULL.", Server->q_sm_id, seq_num);
}
// use the sequence number to dequeue the relevant sub sm
@@ -302,7 +302,7 @@ set_current_reading_sub_sm(INKCont contp
// remove this puppy from the waiting list
if (*current_contp == NULL) {
- INKDebug("serversm", "[%u][set_current_reading_sub_sm], can't find current_sm matching seq_num", Server->q_sm_id);
+ TSDebug("serversm", "[%u][set_current_reading_sub_sm], can't find current_sm matching seq_num", Server->q_sm_id);
assert(0);
}
@@ -314,71 +314,71 @@ set_current_reading_sub_sm(INKCont contp
//////////////////////////////////////////////////////////////////////////
//
-// state_main_event(int event, NetINKVConn *vc)
+// state_main_event(int event, NetTSVConn *vc)
//
//
//////////////////////////////////////////////////////////////////////////
int
-state_main_event(INKCont contp, int event, void *data)
+state_main_event(TSCont contp, int event, void *data)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
ENTER_STATE(serversm, Server->q_sm_id, state_main_event, event);
- INKDebug("serversm", "[%u][state_main_event] entering state_main_event, event is %d", Server->q_sm_id, event);
+ TSDebug("serversm", "[%u][state_main_event] entering state_main_event, event is %d", Server->q_sm_id, event);
int bytes_read = 0;
switch (event) {
- case INK_EVENT_TIMEOUT:
- INKDebug("serversm", "[%u][state_main_event]state_main_event, INTERVAL", Server->q_sm_id);
+ case TS_EVENT_TIMEOUT:
+ TSDebug("serversm", "[%u][state_main_event]state_main_event, INTERVAL", Server->q_sm_id);
- state_call_back_sub_sm(contp, event, (INKVIO) data);
- bytes_read = INKIOBufferReaderAvail(Server->q_server_response_buffer_reader);
+ state_call_back_sub_sm(contp, event, (TSVIO) data);
+ bytes_read = TSIOBufferReaderAvail(Server->q_server_response_buffer_reader);
if (bytes_read > 0)
- state_read_response_from_server(contp, INK_EVENT_VCONN_READ_READY, Server->q_server_read_vio);
- bytes_read = INKIOBufferReaderAvail(Server->q_server_response_buffer_reader);
- INKDebug("serversm",
+ state_read_response_from_server(contp, TS_EVENT_VCONN_READ_READY, Server->q_server_read_vio);
+ bytes_read = TSIOBufferReaderAvail(Server->q_server_response_buffer_reader);
+ TSDebug("serversm",
"[%u][state_main_event]state_main_event, INTERVAL, after read_response_from_server, there are %d bytes in response_buffer)",
Server->q_sm_id, bytes_read);
break;
- case INK_EVENT_VCONN_WRITE_READY:
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- INKDebug("serversm", "[%u][state_main_event]state_main_event, WRITE_READY/COMPLETE", Server->q_sm_id);
+ case TS_EVENT_VCONN_WRITE_READY:
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ TSDebug("serversm", "[%u][state_main_event]state_main_event, WRITE_READY/COMPLETE", Server->q_sm_id);
assert(data != NULL);
- assert((INKVIO) data == Server->q_server_write_vio);
- assert(INKVIOVConnGet((INKVIO) data) == Server->q_server_vc);
- state_wait_for_write(contp, event, (INKVIO) data);
+ assert((TSVIO) data == Server->q_server_write_vio);
+ assert(TSVIOVConnGet((TSVIO) data) == Server->q_server_vc);
+ state_wait_for_write(contp, event, (TSVIO) data);
break;
- case INK_EVENT_VCONN_READ_READY:
- case INK_EVENT_VCONN_READ_COMPLETE:
- INKDebug("serversm", "[%u][state_main_event]state_main_event, READ_READY/COMPLETE", Server->q_sm_id);
+ case TS_EVENT_VCONN_READ_READY:
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ TSDebug("serversm", "[%u][state_main_event]state_main_event, READ_READY/COMPLETE", Server->q_sm_id);
assert(data != NULL);
- assert((INKVIO) data == Server->q_server_read_vio);
- assert(INKVIOVConnGet((INKVIO) data) == Server->q_server_vc);
- state_read_response_from_server(contp, event, (INKVIO) data);
- bytes_read = INKIOBufferReaderAvail(Server->q_server_response_buffer_reader);
- INKDebug("serversm",
+ assert((TSVIO) data == Server->q_server_read_vio);
+ assert(TSVIOVConnGet((TSVIO) data) == Server->q_server_vc);
+ state_read_response_from_server(contp, event, (TSVIO) data);
+ bytes_read = TSIOBufferReaderAvail(Server->q_server_response_buffer_reader);
+ TSDebug("serversm",
"[%u][state_main_event]state_main_event, READ_READY/COMPLETE, after read_response_from_server, there are %d bytes in response_buffer)",
Server->q_sm_id, bytes_read);
break;
-/* case INK_EVENT_VCONN_INACTIVITY_TIMEOUT:
- INKDebug("serversm","[%u][state_main_event]state_main_event, INACTIVITY_TIME_OUT",
+/* case TS_EVENT_VCONN_INACTIVITY_TIMEOUT:
+ TSDebug("serversm","[%u][state_main_event]state_main_event, INACTIVITY_TIME_OUT",
Server->q_sm_id);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
*/
default:
- INKDebug("serversm", "[%u][state_main_event]state_main_event, default", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_main_event]state_main_event, default", Server->q_sm_id);
// it can be error cases, or other cases that I don't know.
break;
}
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_main_event]state_main_event, leaving main_event, current event is %d", Server->q_sm_id, event);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
//////////////////////////////////////////////////////////////////////////
@@ -390,29 +390,29 @@ state_main_event(INKCont contp, int even
//
//////////////////////////////////////////////////////////////////////////
int
-state_wait_for_write(INKCont contp, int event, INKVIO vio)
+state_wait_for_write(TSCont contp, int event, TSVIO vio)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
ENTER_STATE(serversm, Server->q_sm_id, state_wait_for_write, event);
assert(event);
switch (event) {
// How can it come to WRITE_READY? The whole request should
// be writen out.
- case INK_EVENT_VCONN_WRITE_READY:
- INKDebug("serversm", "[%u][state_wait_for_write] INK_EVENT_VCONN_WRITE_READY", Server->q_sm_id);
+ case TS_EVENT_VCONN_WRITE_READY:
+ TSDebug("serversm", "[%u][state_wait_for_write] TS_EVENT_VCONN_WRITE_READY", Server->q_sm_id);
- INKVIOReenable(vio);
- return INK_EVENT_IMMEDIATE;
+ TSVIOReenable(vio);
+ return TS_EVENT_IMMEDIATE;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
assert(vio != NULL);
assert(vio == Server->q_server_write_vio);
- assert(INKVIOVConnGet(vio) == Server->q_server_vc);
- INKDebug("serversm", "[%u][state_wait_for_write] INK_EVENT_VCONN_WRITE_COMPLETE", Server->q_sm_id);
+ assert(TSVIOVConnGet(vio) == Server->q_server_vc);
+ TSDebug("serversm", "[%u][state_wait_for_write] TS_EVENT_VCONN_WRITE_COMPLETE", Server->q_sm_id);
assert(Server->q_server_conn_status == CONNECTED_SENDING);
Server->q_server_conn_status = CONNECTED_IDLE;
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_wait_for_write] Server has read full request of sub_sm %d",
Server->q_sm_id, current_sub_sm_id);
@@ -434,7 +434,7 @@ state_wait_for_write(INKCont contp, int
assert(Server->q_server_response_buffer);
assert(Server->q_server_response_buffer_reader);
- INKDebug("serversm", "[%u][state_wait_for_write] Starting server read vio", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_wait_for_write] Starting server read vio", Server->q_sm_id);
// SET_HANDLER((ServerSMHandler)&state_main_event);
// Server->q_server_vc->set_inactivity_timeout(RAFT_SERVER_INACTIVITY_TIMEOUT);
@@ -444,15 +444,15 @@ state_wait_for_write(INKCont contp, int
Server->q_server_response_buffer);
*/
assert(Server->q_server_read_vio != NULL);
- INKDebug("serversm", "leaving state_wait_for_write");
- return INK_EVENT_IMMEDIATE;
+ TSDebug("serversm", "leaving state_wait_for_write");
+ return TS_EVENT_IMMEDIATE;
default:
// Server->q_error_type = RAFT_INTERNAL_PROXY_ERROR;
- INKDebug("serversm", "[%u][state_wait_for_write] unexpected event", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_wait_for_write] unexpected event", Server->q_sm_id);
assert(0);
if (Server->q_server_vc) {
- INKVConnAbort(Server->q_server_vc, 1);
+ TSVConnAbort(Server->q_server_vc, 1);
Server->q_server_vc = NULL;
}
Server->q_server_read_vio = NULL;
@@ -471,9 +471,9 @@ state_wait_for_write(INKCont contp, int
//
//////////////////////////////////////////////////////////////////////////
int
-state_read_response_from_server(INKCont contp, int event, INKVIO vio)
+state_read_response_from_server(TSCont contp, int event, TSVIO vio)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
int bytes_read = 0;
ReturnStatusCode parse_error = RAFTERR_SUCCESS;
@@ -493,43 +493,43 @@ state_read_response_from_server(INKCont
assert(Server->q_protocol == RAFT_PROTOCOL);
assert(vio != NULL);
assert(vio == Server->q_server_read_vio);
- assert(INKVIOVConnGet(vio) == Server->q_server_vc);
+ assert(TSVIOVConnGet(vio) == Server->q_server_vc);
assert(Server->q_server_response_buffer);
assert(Server->q_server_response_buffer_reader);
- bytes_read = INKIOBufferReaderAvail(Server->q_server_response_buffer_reader);
+ bytes_read = TSIOBufferReaderAvail(Server->q_server_response_buffer_reader);
assert(bytes_read >= 0);
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_read_response_from_server] entering this state, event is %d", Server->q_sm_id, event);
switch (event) {
- case INK_EVENT_VCONN_READ_READY:
- case INK_EVENT_VCONN_READ_COMPLETE:
+ case TS_EVENT_VCONN_READ_READY:
+ case TS_EVENT_VCONN_READ_COMPLETE:
while (bytes_read >= 0) {
if (Server->q_server_calling_back_status == CONNECTED_CALLING_BACK)
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
- bytes_read = INKIOBufferReaderAvail(Server->q_server_response_buffer_reader);
- INKDebug("serversm", "[%u][state_read_response_from_server] bytes_read is %d", Server->q_sm_id, bytes_read);
+ bytes_read = TSIOBufferReaderAvail(Server->q_server_response_buffer_reader);
+ TSDebug("serversm", "[%u][state_read_response_from_server] bytes_read is %d", Server->q_sm_id, bytes_read);
if (Server->q_reading_header && (bytes_read >= RAFT_HEADER_SIZE)) {
- INKDebug("serversm", "[%u][state_read_response_from_server] server response reading header", Server->q_sm_id);
- INKDebug("serversm", "********Read Header******");
+ TSDebug("serversm", "[%u][state_read_response_from_server] server response reading header", Server->q_sm_id);
+ TSDebug("serversm", "********Read Header******");
RAFT_READ_HEADER(Server->q_hdr_proc, Server->q_hdr_seq_num, Server->q_hdr_nbytes,
Server->q_hdr_status, parse_error,
Server->q_server_response_buffer, Server->q_server_response_buffer_reader);
if (parse_error != RAFTERR_SUCCESS) {
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_read_response_from_server] ERROR (%d) : Invalid header..", Server->q_sm_id, parse_error);
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_read_response_from_server] Connection Error (event %d), vio: %s",
Server->q_sm_id, event,
- (((INKVIO) vio == Server->q_server_read_vio) ? "server_read" :
- (((INKVIO) vio == Server->q_server_write_vio) ? "server_write" : "god-knows")));
+ (((TSVIO) vio == Server->q_server_read_vio) ? "server_read" :
+ (((TSVIO) vio == Server->q_server_write_vio) ? "server_write" : "god-knows")));
assert(0);
if (Server->q_server_vc) {
- INKVConnAbort(Server->q_server_vc, 1);
+ TSVConnAbort(Server->q_server_vc, 1);
Server->q_server_vc = NULL;
}
Server->q_server_read_vio = NULL;
@@ -537,7 +537,7 @@ state_read_response_from_server(INKCont
return call_back_sub_sm_with_error(contp);
} else {
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_read_response_from_server] header is: %d %d %d %d",
Server->q_sm_id, Server->q_hdr_proc, Server->q_hdr_seq_num,
Server->q_hdr_nbytes, Server->q_hdr_status);
@@ -547,16 +547,16 @@ state_read_response_from_server(INKCont
Server->q_reading_header = 0;
// reset the watermark in order to force the
// callback when there is a full body to read
- INKIOBufferWaterMarkSet(Server->q_server_response_buffer, Server->q_hdr_nbytes);
- INKDebug("serversm",
+ TSIOBufferWaterMarkSet(Server->q_server_response_buffer, Server->q_hdr_nbytes);
+ TSDebug("serversm",
"[state_read_response_from_server] header of seq_num (%d) is totally read in, current Server->q_reading_sub_contp is %p",
Server->q_hdr_seq_num, Server->q_reading_sub_contp);
- INKDebug("serversm", "*********Read Header DONE*****");
+ TSDebug("serversm", "*********Read Header DONE*****");
}
} else if (!Server->q_reading_header && (bytes_read >= Server->q_hdr_nbytes)) {
- INKDebug("serversm", "$$$$$$$$Read body$$$$$$");
+ TSDebug("serversm", "$$$$$$$$Read body$$$$$$");
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_read_response_from_server] Server response reading body for seq{%d} proc[%d] len is %d, status is %d",
Server->q_sm_id, Server->q_hdr_seq_num, Server->q_hdr_proc, Server->q_hdr_nbytes,
Server->q_hdr_status);
@@ -564,39 +564,39 @@ state_read_response_from_server(INKCont
assert(Server->q_reading_sub_contp);
- INKDebug("serversm",
+ TSDebug("serversm",
"[state_read_response_from_server] body of seq_num (%d) is totally read in, current Server->q_reading_sub_contp is %p",
Server->q_hdr_seq_num, Server->q_reading_sub_contp);
- INKDebug("serversm", "$$$$$$$$Read body DONE$$$$$$$");
+ TSDebug("serversm", "$$$$$$$$Read body DONE$$$$$$$");
Server->q_server_calling_back_status = CONNECTED_CALLING_BACK;
state_call_back_sub_sm(contp, 0, NULL);
// API: buffer's water mark
- INKIOBufferWaterMarkSet(Server->q_server_response_buffer, RAFT_HEADER_SIZE);
+ TSIOBufferWaterMarkSet(Server->q_server_response_buffer, RAFT_HEADER_SIZE);
Server->q_reading_header = 1;
//return state_main_event(0, NULL);
}
// There are not enough data for reading
else {
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_read_response_from_server] server response (%s) only %d read - reenabling",
Server->q_sm_id, (Server->q_reading_header ? "reading header" : "reading body"), bytes_read);
/*
- INKDebug("serversm","[%u][state_read_response_from_server] current handler is %s",
+ TSDebug("serversm","[%u][state_read_response_from_server] current handler is %s",
Server->q_sm_id, this->handler_name);
*/
- INKDebug("serversm", "[%u][state_read_response_from_server] print Server->q_reading_sub_contps list %p",
+ TSDebug("serversm", "[%u][state_read_response_from_server] print Server->q_reading_sub_contps list %p",
Server->q_sm_id);
print_list_1(&Server->q_sms_to_call_back);
// reenable the vio just in case the buffer was full earlier.
- INKVIOReenable(Server->q_server_read_vio);
+ TSVIOReenable(Server->q_server_read_vio);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
}
- case INK_EVENT_VCONN_WRITE_READY:
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- case INK_EVENT_VCONN_EOS:
+ case TS_EVENT_VCONN_WRITE_READY:
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ case TS_EVENT_VCONN_EOS:
assert(!"[serversm], [state_read_response_from_server], invalid events.");
return call_back_sub_sm_with_error(contp);
default:
@@ -604,7 +604,7 @@ state_read_response_from_server(INKCont
// what race condition can happen here.
break;
}
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
@@ -617,69 +617,71 @@ state_read_response_from_server(INKCont
//
//////////////////////////////////////////////////////////////////////////
int
-state_call_back_sub_sm(INKCont contp, int event, INKVIO vio)
+state_call_back_sub_sm(TSCont contp, int event, TSVIO vio)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
- RaftSubSM *SubSM = (RaftSubSM *) INKContDataGet(Server->q_reading_sub_contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
+ RaftSubSM *SubSM = (RaftSubSM *) TSContDataGet(Server->q_reading_sub_contp);
- INKIOBufferBlock blk;
+ TSIOBufferBlock blk;
char *buf;
int avail;
ENTER_STATE(serversm, Server->q_sm_id, state_call_back_sub_sm, event);
assert(Server->q_server_calling_back_status == CONNECTED_CALLING_BACK);
- INKDebug("serversm", "[%u][state_call_back_sub_sm] try to grab subsm's mutex", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_call_back_sub_sm] try to grab subsm's mutex", Server->q_sm_id);
- int lock3 = INKMutexTryLock(SubSM->q_mutex);
+ int lock3;
+
+ TSMutexLockTry(SubSM->q_mutex, &lock3);
if (!lock3) {
set_handler(Server->q_server_current_handler, &state_main_event);
- Server->q_pending_action = INKContSchedule(contp, RAFT_SERVER_LOCK_RETRY_TIME);
- return INK_EVENT_NONE;
+ Server->q_pending_action = TSContSchedule(contp, RAFT_SERVER_LOCK_RETRY_TIME);
+ return TS_EVENT_NONE;
}
- INKDebug("serversm", "[%u][state_call_back_sub_sm] subsm[%d]'s mutex is grabbed", Server->q_sm_id, SubSM->q_sm_id);
+ TSDebug("serversm", "[%u][state_call_back_sub_sm] subsm[%d]'s mutex is grabbed", Server->q_sm_id, SubSM->q_sm_id);
SubSM->q_client_request->response->proc = Server->q_hdr_proc;
SubSM->q_client_request->response->seq_num = Server->q_hdr_seq_num;
SubSM->q_client_request->response->nbytes = Server->q_hdr_nbytes;
SubSM->q_client_request->response->status = Server->q_hdr_status;
- INKDebug("serversm", "[state_call_back_sub_sm] consume %d bytes from response_buffer", Server->q_hdr_nbytes);
+ TSDebug("serversm", "[state_call_back_sub_sm] consume %d bytes from response_buffer", Server->q_hdr_nbytes);
assert(Server->q_server_response_buffer_reader);
assert(Server->q_server_response_buffer);
- INKDebug("serversm", "[state_call_back_sub_sm] reader_avail is %d",
- INKIOBufferReaderAvail(Server->q_server_response_buffer_reader));
+ TSDebug("serversm", "[state_call_back_sub_sm] reader_avail is %d",
+ TSIOBufferReaderAvail(Server->q_server_response_buffer_reader));
- INKIOBufferCopy(SubSM->q_client_request->response->resp_buffer,
+ TSIOBufferCopy(SubSM->q_client_request->response->resp_buffer,
Server->q_server_response_buffer_reader, Server->q_hdr_nbytes, 0);
- INKIOBufferReaderConsume(Server->q_server_response_buffer_reader, Server->q_hdr_nbytes);
+ TSIOBufferReaderConsume(Server->q_server_response_buffer_reader, Server->q_hdr_nbytes);
- INKDebug("serversm",
+ TSDebug("serversm",
"[state_call_back_sub_sm] sub_sm's incoming and outgoing seq_num are %d, %d, proc is %d",
SubSM->q_incoming_seq_num, SubSM->q_outgoing_seq_num, SubSM->q_client_request->proc);
- //API: INKContCall doesn't know RAFT_EVENT_RESPONSE_RECEIVED, so I have to
- // change to an event in INKEvent list.
- // INKContCall (Server->q_reading_sub_contp, RAFT_EVENT_RESPONSE_RECEIVED, NULL);
- INKDebug("serversm", "[state_call_back_sub_sm] call back current_sub_contp");
- INKMutexUnlock(SubSM->q_mutex);
+ //API: TSContCall doesn't know RAFT_EVENT_RESPONSE_RECEIVED, so I have to
+ // change to an event in TSEvent list.
+ // TSContCall (Server->q_reading_sub_contp, RAFT_EVENT_RESPONSE_RECEIVED, NULL);
+ TSDebug("serversm", "[state_call_back_sub_sm] call back current_sub_contp");
+ TSMutexUnlock(SubSM->q_mutex);
// stats
Server->server_stats->q_count_finished_requests++;
Server->server_stats->q_count_bytes_one_server += (RAFT_HEADER_SIZE + Server->q_hdr_nbytes);
Server->server_stats->q_count_server_pipeline_depth--;
-// INKContCall (Server->q_reading_sub_contp, INK_EVENT_CONTINUE, NULL);
- INKContSchedule(Server->q_reading_sub_contp, 0);
+// TSContCall (Server->q_reading_sub_contp, TS_EVENT_CONTINUE, NULL);
+ TSContSchedule(Server->q_reading_sub_contp, 0);
- INKDebug("serversm", "[state_call_back_sub_sm] release sub_sm's mutex");
+ TSDebug("serversm", "[state_call_back_sub_sm] release sub_sm's mutex");
Server->q_reading_sub_contp = NULL;
Server->q_server_calling_back_status = CONNECTED_IDLE;
- INKDebug("serversm", "Server->q_sending_sms is %p ", Server->q_sending_sms);
+ TSDebug("serversm", "Server->q_sending_sms is %p ", Server->q_sending_sms);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
//return state_main_event(0, NULL);
}
@@ -691,9 +693,9 @@ state_call_back_sub_sm(INKCont contp, in
//
//////////////////////////////////////////////////////////////////////////
int
-call_back_sub_sm_with_error(INKCont contp)
+call_back_sub_sm_with_error(TSCont contp)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
// call back all the current sending and reading sub_sms
// with an error now. in other words go through the waiting
// list and move every damn sm from it to the waiting to be
@@ -719,9 +721,9 @@ call_back_sub_sm_with_error(INKCont cont
// well and add them to the Server->q_sms_to_call_back, then make
// sure they all get called back with errors.
while (Server->q_sending_sms) {
- INKCont waiting_sub_sm = NULL;
+ TSCont waiting_sub_sm = NULL;
- waiting_sub_sm = (INKCont) pop_item_from_raft_list(&Server->q_sending_sms);
+ waiting_sub_sm = (TSCont) pop_item_from_raft_list(&Server->q_sending_sms);
assert(waiting_sub_sm);
add_item_to_raft_list(&(Server->q_sms_to_call_back), waiting_sub_sm);
@@ -762,9 +764,9 @@ call_back_sub_sm_with_error(INKCont cont
//
//////////////////////////////////////////////////////////////////////////
int
-state_prepare_to_die(INKCont contp, int event, INKVIO vio)
+state_prepare_to_die(TSCont contp, int event, TSVIO vio)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
ENTER_STATE(serversm, Server->q_sm_id, state_prepare_to_die, event);
int refcount = -1;
@@ -776,12 +778,13 @@ state_prepare_to_die(INKCont contp, int
Server->q_server_conn_status = NO_CONNECTION;
// update the global table entry
- INKDebug("servers,", "[%u][state_prepare_to_die] trying to grab global_table's entry_mutex", Server->q_sm_id);
+ TSDebug("servers,", "[%u][state_prepare_to_die] trying to grab global_table's entry_mutex", Server->q_sm_id);
- int lock = INKMutexTryLock(global_table->entry[Server->q_global_table_index].entry_mutex);
+ int lock;
+ TSMutexLockTry(global_table->entry[Server->q_global_table_index].entry_mutex, &lock);
if (!lock) {
- Server->q_pending_action = INKContSchedule(contp, RAFT_GLOBAL_TABLE_LOCK_RETRY_TIME);
- return INK_EVENT_NONE;
+ Server->q_pending_action = TSContSchedule(contp, RAFT_GLOBAL_TABLE_LOCK_RETRY_TIME);
+ return TS_EVENT_NONE;
}
Server->q_global_table_ptr->server_fd = -1;
@@ -789,9 +792,9 @@ state_prepare_to_die(INKCont contp, int
Server->q_global_table_ptr->server_contp = 0;
refcount = Server->q_global_table_ptr->refcount;
- INKMutexUnlock(global_table->entry[Server->q_global_table_index].entry_mutex);
+ TSMutexUnlock(global_table->entry[Server->q_global_table_index].entry_mutex);
- INKDebug("serversm", "[%u][state_prepare_to_die] global_table's entry_mutex is released", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_prepare_to_die] global_table's entry_mutex is released", Server->q_sm_id);
// no sub_sms have a pointer to this server_sm.
// safe to go away.
@@ -799,8 +802,8 @@ state_prepare_to_die(INKCont contp, int
return server_state_done(contp, 0, NULL);
// not yet safe to go away. retry later.
- Server->q_pending_action = INKContSchedule(contp, RAFT_SERVER_ATTEMPT_SHUT_DOWN_RETRY_TIME);
- return INK_EVENT_IMMEDIATE;
+ Server->q_pending_action = TSContSchedule(contp, RAFT_SERVER_ATTEMPT_SHUT_DOWN_RETRY_TIME);
+ return TS_EVENT_IMMEDIATE;
}
//////////////////////////////////////////////////////////////////////////
@@ -815,23 +818,23 @@ state_prepare_to_die(INKCont contp, int
//
//////////////////////////////////////////////////////////////////////////
int
-server_state_done(INKCont contp, int event, INKVIO vio)
+server_state_done(TSCont contp, int event, TSVIO vio)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
ENTER_STATE(serversm, Server->q_sm_id, state_done, event);
- INKDebug("serversm", "[%u][state_done]This state machine is done!", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_done]This state machine is done!", Server->q_sm_id);
// cancel any pending action
- if (Server->q_pending_action && !INKActionDone(Server->q_pending_action))
- INKActionCancel(Server->q_pending_action);
+ if (Server->q_pending_action && !TSActionDone(Server->q_pending_action))
+ TSActionCancel(Server->q_pending_action);
Server->q_pending_action = NULL;
// Server->q_mutex = NULL;
if (Server->q_server_name) {
- INKfree(Server->q_server_name);
+ TSfree(Server->q_server_name);
Server->q_server_name = NULL;
}
// this is a pointer to a buffer in calling raft_sub_sms,
@@ -845,8 +848,8 @@ server_state_done(INKCont contp, int eve
// reset pointers
if (Server->q_server_response_buffer) {
if (Server->q_server_response_buffer_reader)
- INKIOBufferReaderFree(Server->q_server_response_buffer_reader);
- INKIOBufferDestroy(Server->q_server_response_buffer);
+ TSIOBufferReaderFree(Server->q_server_response_buffer_reader);
+ TSIOBufferDestroy(Server->q_server_response_buffer);
Server->q_server_response_buffer = NULL;
Server->q_server_response_buffer_reader = NULL;
}
@@ -870,9 +873,9 @@ server_state_done(INKCont contp, int eve
Server->server_stats = NULL;
// delete this state machine and return
- INKfree(Server);
- INKContDestroy(contp);
- return INK_EVENT_NONE;
+ TSfree(Server);
+ TSContDestroy(contp);
+ return TS_EVENT_NONE;
}
//////////////////////////////////////////////////////////////////////////
@@ -885,18 +888,18 @@ server_state_done(INKCont contp, int eve
//////////////////////////////////////////////////////////////////////////
int
-state_dns_lookup(INKCont contp, int event, INKHostDBInfo host_info)
+state_dns_lookup(TSCont contp, int event, TSHostDBInfo host_info)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
ENTER_STATE(serversm, Server->q_sm_id, state_dns_lookup, event);
assert(Server->q_server_name);
- if (event != INK_EVENT_DNS_LOOKUP) {
+ if (event != TS_EVENT_DNS_LOOKUP) {
// Server->q_error_type = RAFT_INTERNAL_PROXY_ERROR;
- INKDebug("serversm", "[%u][state_dns_lookup], unexpected event", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_dns_lookup], unexpected event", Server->q_sm_id);
if (Server->q_server_vc) {
- INKVConnAbort(Server->q_server_vc, 1);
+ TSVConnAbort(Server->q_server_vc, 1);
Server->q_server_vc = NULL;
}
Server->q_server_read_vio = NULL;
@@ -910,7 +913,7 @@ state_dns_lookup(INKCont contp, int even
// that the lookup was unsuccessful.
if (!host_info) {
// Server->q_error_type = RAFT_DNS_FAILURE;
- INKDebug("serversm", "[%u][state_dns_lookup] Unable to resolve DNS for %s", Server->q_sm_id, Server->q_server_name);
+ TSDebug("serversm", "[%u][state_dns_lookup] Unable to resolve DNS for %s", Server->q_sm_id, Server->q_server_name);
// FUTURE: we may at some point want to try doing automatic
// name expansion (appending local domain name or prepending www)
@@ -919,21 +922,21 @@ state_dns_lookup(INKCont contp, int even
return call_back_sub_sm_with_error(contp);
}
// ok, we have DNS resolution. set the ip address and connect to the server.
-// Server->q_server_ip = INKDNSInfoIPGet (host_info);
- Server->q_server_ip = INKGetIP(host_info);
+// Server->q_server_ip = TSDNSInfoIPGet (host_info);
+ Server->q_server_ip = TSGetIP(host_info);
assert(Server->q_server_ip > 0);
assert(Server->q_server_port > 0);
// issue server connect.
unsigned char *p = (unsigned char *) &(Server->q_server_ip);
- INKDebug("serversm", "[%u][state_dns_resolve] %s has resolved to %d.%d.%d.%d:%d",
+ TSDebug("serversm", "[%u][state_dns_resolve] %s has resolved to %d.%d.%d.%d:%d",
Server->q_sm_id, Server->q_server_name, p[0], p[1], p[2], p[3], Server->q_server_port);
// SET_HANDLER((ServerSMHandler)&state_connect_to_server);
set_handler(Server->q_server_current_handler, &state_connect_to_server);
- Server->q_pending_action = INKNetConnect(contp, Server->q_server_ip, Server->q_server_port);
+ Server->q_pending_action = TSNetConnect(contp, Server->q_server_ip, Server->q_server_port);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
//////////////////////////////////////////////////////////////////////////
@@ -945,18 +948,18 @@ state_dns_lookup(INKCont contp, int even
//
//////////////////////////////////////////////////////////////////////////
int
-state_connect_to_server(INKCont contp, int event, INKVConn vc)
+state_connect_to_server(TSCont contp, int event, TSVConn vc)
{
- ServerSM *Server = (ServerSM *) INKContDataGet(contp);
+ ServerSM *Server = (ServerSM *) TSContDataGet(contp);
ENTER_STATE(serversm, Server->q_sm_id, state_connect_to_server, event);
assert(vc != NULL);
Server->q_server_vc = vc;
- if (event != INK_EVENT_NET_CONNECT) {
+ if (event != TS_EVENT_NET_CONNECT) {
// Server->q_error_type = RAFT_INTERNAL_PROXY_ERROR;
- INKDebug("serversm", "[%u][state_connect_to_server] unexpected event", Server->q_sm_id);
+ TSDebug("serversm", "[%u][state_connect_to_server] unexpected event", Server->q_sm_id);
if (Server->q_server_vc) {
- INKVConnAbort(Server->q_server_vc, 1);
+ TSVConnAbort(Server->q_server_vc, 1);
Server->q_server_vc = NULL;
}
Server->q_server_read_vio = NULL;
@@ -965,16 +968,16 @@ state_connect_to_server(INKCont contp, i
return call_back_sub_sm_with_error(contp);
}
- INKDebug("serversm",
+ TSDebug("serversm",
"[%u][state_connect_to_server] conn_status is updated to %d", Server->q_sm_id, Server->q_server_conn_status);
set_handler(Server->q_server_current_handler, &state_main_event);
assert(Server->q_server_response_buffer);
- Server->q_server_read_vio = INKVConnRead(Server->q_server_vc, contp, Server->q_server_response_buffer, INT_MAX);
+ Server->q_server_read_vio = TSVConnRead(Server->q_server_vc, contp, Server->q_server_response_buffer, INT_MAX);
assert(Server->q_server_read_vio);
server_send_request(contp);
- return INK_EVENT_IMMEDIATE;
+ return TS_EVENT_IMMEDIATE;
}
//////////////////////////////////////////////////////////////////////////
@@ -989,7 +992,7 @@ print_list_1(RaftList_t ** the_list)
int i = 0;
while (start) {
- INKDebug("serversm", "print_list, current_item[%d] is %p", i, start->item);
+ TSDebug("serversm", "print_list, current_item[%d] is %p", i, start->item);
i++;
start = start->next;
}
Modified: trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/mod.Sched
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/mod.Sched?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/mod.Sched (original)
+++ trafficserver/traffic/branches/wccp/test/plugin/INKContinuations/mod.Sched Tue Nov 30 01:42:55 2010
@@ -25,13 +25,13 @@
Verification of INKqa06643
Schedule a continuation that is simply called back with a later timeout
-value. Explicitly call INKContSchedule() without a mutex, the mutex should
-be created in InkAPI.cc/INKContSchedule.
+value. Explicitly call TSContSchedule() without a mutex, the mutex should
+be created in InkAPI.cc/TSContSchedule.
This plug-in will not complete the client request (request times-out),
-since the event routine calls INKContSchedule() in the event handler.
-A simple change to the event routine can be made so that INKHttpTxnReenable()
-is called in place of INKContSchedule().
+since the event routine calls TSContSchedule() in the event handler.
+A simple change to the event routine can be made so that TSHttpTxnReenable()
+is called in place of TSContSchedule().
Entry points to the core now use either
FORCE_PLUGIN_MUTEX
@@ -48,73 +48,73 @@ to create/init a mutex.
#include <ts/ts.h>
-/* Verification code for: INKqa06643 */
+/* Verification code for: TSqa06643 */
static int
-EventHandler(INKCont contp, INKEvent event, void *eData)
+EventHandler(TSCont contp, TSEvent event, void *eData)
{
- INKHttpTxn txn = (INKHttpTxn)eData;
+ TSHttpTxn txn = (TSHttpTxn)eData;
int iVal;
time_t tVal ;
if (time(&tVal) != (time_t)(-1)) {
- INKDebug("tag_sched6643",
- "INKContSchedule: EventHandler: called at %s\n",
+ TSDebug("tag_sched6643",
+ "TSContSchedule: EventHandler: called at %s\n",
ctime(&tVal));
}
- iVal = (int)INKContDataGet(contp);
+ iVal = (int)TSContDataGet(contp);
- INKDebug("tag_sched6643",
- "INKContSchedule: handler called with value %d\n",iVal);
+ TSDebug("tag_sched6643",
+ "TSContSchedule: handler called with value %d\n",iVal);
switch (event) {
- case INK_EVENT_HTTP_OS_DNS:
- INKDebug("tag_sched6643",
- "INKContSchedule: Seed event %s\n", "INK_EVENT_HTTP_OS_DNS");
+ case TS_EVENT_HTTP_OS_DNS:
+ TSDebug("tag_sched6643",
+ "TSContSchedule: Seed event %s\n", "TS_EVENT_HTTP_OS_DNS");
break;
- case INK_EVENT_TIMEOUT:
- INKDebug("tag_sched6643",
- "INKContSchedule: TIMEOUT event\n");
+ case TS_EVENT_TIMEOUT:
+ TSDebug("tag_sched6643",
+ "TSContSchedule: TIMEOUT event\n");
break;
default:
- INKDebug("tag_sched6643",
- "INKContSchedule: Error: default event\n");
+ TSDebug("tag_sched6643",
+ "TSContSchedule: Error: default event\n");
break;
}
iVal += 100; /* seed + timeout val */
- INKContDataSet(contp, (void*)iVal);
- INKContSchedule(contp,iVal);
+ TSContDataSet(contp, (void*)iVal);
+ TSContSchedule(contp,iVal);
- /* INKHttpTxnReenable(txn, INK_EVENT_HTTP_CONTINUE); */
+ /* TSHttpTxnReenable(txn, TS_EVENT_HTTP_CONTINUE); */
}
static int
-EventHandler2(INKCont contp, INKEvent event, void *eData)
+EventHandler2(TSCont contp, TSEvent event, void *eData)
{
}
void
-INKPluginInit(int argc, const char* argv[])
+TSPluginInit(int argc, const char* argv[])
{
- INKCont contp, contp2;
+ TSCont contp, contp2;
int timeOut = 10 ;
- INKDebug("tag_sched6643",
- "INKContSchedule: Initial data value for contp is %d\n",timeOut);
+ TSDebug("tag_sched6643",
+ "TSContSchedule: Initial data value for contp is %d\n",timeOut);
- /* contp = INKContCreate(EventHandler, INKMutexCreate() ); */
- mymUtex = INKMutexCreate() ;
+ /* contp = TSContCreate(EventHandler, TSMutexCreate() ); */
+ mymUtex = TSMutexCreate() ;
- contp = INKContCreate(EventHandler, myMutex);
- INKContDataSet(contp, (void*)timeOut);
+ contp = TSContCreate(EventHandler, myMutex);
+ TSContDataSet(contp, (void*)timeOut);
- contp2 = INKContCreate(EventHandler2, myMutex);
- INKContDataSet(contp2, (void*)contp);
+ contp2 = TSContCreate(EventHandler2, myMutex);
+ TSContDataSet(contp2, (void*)contp);
- /* INKHttpHookAdd(INK_HTTP_OS_DNS_HOOK, contp); */
- INKHttpHookAdd(INK_HTTP_OS_DNS_HOOK, contp2);
+ /* TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, contp); */
+ TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, contp2);
}
Modified: trafficserver/traffic/branches/wccp/test/plugin/INKFopen/INKFopen.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/test/plugin/INKFopen/INKFopen.c?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/test/plugin/INKFopen/INKFopen.c (original)
+++ trafficserver/traffic/branches/wccp/test/plugin/INKFopen/INKFopen.c Tue Nov 30 01:42:55 2010
@@ -25,29 +25,29 @@
/*****************************************************************************
TODO test for the debugging family of functions
- Test for the INKfopen family of functions
+ Test for the TSfopen family of functions
-INKfclose
-INKfflush
-INKfgets
-INKfopen
-INKfread
-INKfwrite
+TSfclose
+TSfflush
+TSfgets
+TSfopen
+TSfread
+TSfwrite
Test for the Memory allocation family of functions
-INKfree
-INKmalloc
-INKrealloc
-INKstrdup
-INKstrndup
+TSfree
+TSmalloc
+TSrealloc
+TSstrdup
+TSstrndup
Test for the Thread family of functions
-INKThreadCreate
-INKThreadDestroy
-INKThreadInit
-INKThreadSelf
-INKThread
+TSThreadCreate
+TSThreadDestroy
+TSThreadInit
+TSThreadSelf
+TSThread
The approach taken is to write a large test that excercises the major
portions of each api within each section. The order of the test is based
@@ -79,60 +79,60 @@ extern int errno;
#include <pthread.h>
/*
- * INKDebug() is used for generic messaging
- * INKerror() is used as an error reporting
+ * TSDebug() is used for generic messaging
+ * TSerror() is used as an error reporting
*/
/* Used to create tmp file */
#define TMP_DIR "/var/tmp"
-#define PFX "TS_INKfopen_"
+#define PFX "TS_TSfopen_"
/* There are three threads tests */
#define NUM_THREAD_TESTS (3)
/* This is the third test
- * Arbritrary number of to INKThreadInit()/INKThreadDestroy()
+ * Arbritrary number of to TSThreadInit()/TSThreadDestroy()
*/
#define NUM_THREADS (1000)
-/* Number of total INKfopen test: 16
+/* Number of total TSfopen test: 16
* non-negative tests: 10
*/
#define NUM_FOPEN_TESTS (10)
/*
-1. INKfclose:
- 1.1 INKfclose on read file 1.2 INKfclose on write file
+1. TSfclose:
+ 1.1 TSfclose on read file 1.2 TSfclose on write file
1.3 flush data on read file [neg] 1.4 flush data on write file
-2. INKfflush
- 2.1 INKfflush on read file [neg] 2.2 INKflush on write file
+2. TSfflush
+ 2.1 TSfflush on read file [neg] 2.2 TSflush on write file
-3. INKfgets
- 3.1 INKfgets on read file 3.2 INKfgets on write file [neg]
+3. TSfgets
+ 3.1 TSfgets on read file 3.2 TSfgets on write file [neg]
-4. INKfopen
- 4.1 INKfopen (create) for read [neg] 4.2 INKfopen (create) for write
- 4.3 INKfopen for read 4.4 INKfopen for write
+4. TSfopen
+ 4.1 TSfopen (create) for read [neg] 4.2 TSfopen (create) for write
+ 4.3 TSfopen for read 4.4 TSfopen for write
-5. INKfread
- 5.1 INKfread on read file 5.2 INKfread on write file [neg]
+5. TSfread
+ 5.1 TSfread on read file 5.2 TSfread on write file [neg]
-6. INKfwrite
- 6.1 INKfwrite on a write file 6.2 INKfwrite on a read file [neg]
+6. TSfwrite
+ 6.1 TSfwrite on a write file 6.2 TSfwrite on a read file [neg]
*/
static int
-INKfopenTest(INKHttpTxn txnp, INKCont contp)
+TSfopenTest(TSHttpTxn txnp, TSCont contp)
{
char *tempnamWriteFile = NULL;
char *tempnamFlushFile = NULL;
- INKFile sourceReadFile; /* existing file */
- INKFile writeFile; /* to be created */
- INKFile readFile; /* to be created */
- INKFile cmpReadFile; /* read & compare */
+ TSFile sourceReadFile; /* existing file */
+ TSFile writeFile; /* to be created */
+ TSFile readFile; /* to be created */
+ TSFile cmpReadFile; /* read & compare */
char inputBuf[BUFSIZ];
char cmpBuf[BUFSIZ];
@@ -140,188 +140,188 @@ INKfopenTest(INKHttpTxn txnp, INKCont co
char *retVal;
int fopenErrCount = 0, re = 0, wrote = 0, readAmount = 0;
const char *plugInDir;
- char INPUT_TEXT_FILE[] = "INKfopenText.txt";
+ char INPUT_TEXT_FILE[] = "TSfopenText.txt";
char inputTextFileFullPath[BUFSIZ];
/* Set full path to file at run time.
*/
- if ((plugInDir = INKPluginDirGet()) == NULL) {
+ if ((plugInDir = TSPluginDirGet()) == NULL) {
/* TODO this error does not write to any log file */
- INKError("INKfopenTest(): INKPluginDirGet failed.\n");
+ TSError("TSfopenTest(): TSPluginDirGet failed.\n");
return ++fopenErrCount;
}
sprintf(inputTextFileFullPath, "%s/", plugInDir);
strncat(inputTextFileFullPath, INPUT_TEXT_FILE, sizeof(INPUT_TEXT_FILE));
- /* 4. INKfopen
- * 4.3 INKfopen for read on existing file INPUT_TEXT_FILE
+ /* 4. TSfopen
+ * 4.3 TSfopen for read on existing file INPUT_TEXT_FILE
*/
- if (!(sourceReadFile = INKfopen(inputTextFileFullPath, "r"))) {
- INKError("INKfopenTest(): INKfopen failed on open read mode for existing file\n");
+ if (!(sourceReadFile = TSfopen(inputTextFileFullPath, "r"))) {
+ TSError("TSfopenTest(): TSfopen failed on open read mode for existing file\n");
return ++fopenErrCount;
} else
- INKDebug("INKfopen_plug-in", "INKfopenTest(): INKfopen for read mode of existing file passed\n");
+ TSDebug("TSfopen_plug-in", "TSfopenTest(): TSfopen for read mode of existing file passed\n");
/* Create unique tmp _file_name_, do not use any TS file_name */
if ((tempnamWriteFile = tempnam(TMP_DIR, PFX)) == NULL) {
- INKError("INKfopenTest(): tempnam failed \n");
+ TSError("TSfopenTest(): tempnam failed \n");
return ++fopenErrCount;
}
/*
- * 4. INKfopen
- * 4.2 INKfopen (create) for write
+ * 4. TSfopen
+ * 4.2 TSfopen (create) for write
*
* DOCS: Files does not have to exist. File will be created.
*/
- if (!(writeFile = INKfopen(tempnamWriteFile, "w"))) {
- INKError("INKfopenTest(): INKfopen failed to open for write mode \n");
+ if (!(writeFile = TSfopen(tempnamWriteFile, "w"))) {
+ TSError("TSfopenTest(): TSfopen failed to open for write mode \n");
return ++fopenErrCount;
}
- INKDebug("INKfopen_plug-in", "INKfopenTest: INKfopen (create) for write passed \n");
+ TSDebug("TSfopen_plug-in", "TSfopenTest: TSfopen (create) for write passed \n");
memset(inputBuf, '\0', BUFSIZ);
/*
- * 3. INKfgets
- * 3.1 INKfgets on read file
+ * 3. TSfgets
+ * 3.1 TSfgets on read file
* inputReadFile is the file to read from,
* inputBuf is the buffer to write to
* statBuffInputText.st_size is the size of the buffer to read into
*/
/* sourceReadFile and inputTextFileFullPath are the same file */
if (stat(inputTextFileFullPath, &statBuffInputText) != 0) {
- INKError("INKfopenTest() stat failed on sourceReadFile\n");
+ TSError("TSfopenTest() stat failed on sourceReadFile\n");
return ++fopenErrCount;
}
readAmount = (statBuffInputText.st_size <= sizeof(inputBuf)) ? (statBuffInputText.st_size) : (sizeof(inputBuf));
- if ((retVal = INKfgets(sourceReadFile, inputBuf, readAmount))
+ if ((retVal = TSfgets(sourceReadFile, inputBuf, readAmount))
== NULL) {
- INKError("INKfopenTest(): INKfgets failed\n");
+ TSError("TSfopenTest(): TSfgets failed\n");
return ++fopenErrCount;
} else
/* TODO doc retVal: NULL on error, inputBuff on success */
if (retVal != inputBuf) {
- INKError("INKfopenTest() INKfgets failed (retVal != inputBuf)\n");
+ TSError("TSfopenTest() TSfgets failed (retVal != inputBuf)\n");
return ++fopenErrCount;
} else
- INKDebug("INKfopen_plug-in", "INKfopenTest() INKfgets passed on file open for read mode.\n");
+ TSDebug("TSfopen_plug-in", "TSfopenTest() TSfgets passed on file open for read mode.\n");
/***************************************************************
* TODO how do we rewind to the begining of a file (sourceReadFile)?
*****************************************************************/
/*
- * 6. INKfwrite
- * 6.1 INKfwrite on a write file
+ * 6. TSfwrite
+ * 6.1 TSfwrite on a write file
* writeFile is the (tmp) file to write data to
* inputBuf buffer to read data from
* BUFSIZ is the amount of data to write
*
*/
- wrote = INKfwrite(writeFile, inputBuf, statBuffInputText.st_size);
+ wrote = TSfwrite(writeFile, inputBuf, statBuffInputText.st_size);
if (wrote != statBuffInputText.st_size) {
- INKError("INKfopenTest() INKfwrite failed: write %d/%d bytes\n", wrote, statBuffInputText.st_size);
+ TSError("TSfopenTest() TSfwrite failed: write %d/%d bytes\n", wrote, statBuffInputText.st_size);
return ++fopenErrCount;
}
- INKDebug("INKfopen_plug-in", "INKfopenTest(): INKfwrite: passed, data written to file\n");
+ TSDebug("TSfopen_plug-in", "TSfopenTest(): TSfwrite: passed, data written to file\n");
- /* 2. INKfflush
- * 2.2 INKflush on write file
- * No return value: one way to test INKfflush is to verify that
+ /* 2. TSfflush
+ * 2.2 TSflush on write file
+ * No return value: one way to test TSfflush is to verify that
* the data been written to the file by calling stat(2) and verifying
* a change in file size.
*/
if (stat(tempnamWriteFile, &statBuffPre) != 0) {
- INKError("INKfopenTest() stat failed on tmpFlushFile\n");
+ TSError("TSfopenTest() stat failed on tmpFlushFile\n");
return ++fopenErrCount;
}
- INKfflush(writeFile); /* writeFile should point to tempnamWriteFile */
+ TSfflush(writeFile); /* writeFile should point to tempnamWriteFile */
if (stat(tempnamWriteFile, &statBuffPost) != 0) {
- INKError("INKfopenTest() stat failed on tmpFlushFile\n");
+ TSError("TSfopenTest() stat failed on tmpFlushFile\n");
return ++fopenErrCount;
}
if ((statBuffPre.st_size == 0) && (statBuffPost.st_size == statBuffInputText.st_size)) {
- INKDebug("INKfopen_plug-in",
- "INKfopenTest(): INKfflush: passed: flushed pending data (%d bytes) written to file\n",
+ TSDebug("TSfopen_plug-in",
+ "TSfopenTest(): TSfflush: passed: flushed pending data (%d bytes) written to file\n",
statBuffPost.st_size);
} else {
- INKError
- ("INKfopenTest(): INKfflush failed to flush pending data to file: file size: before INKfflush (%d = 0), after %d == %d \n",
+ TSError
+ ("TSfopenTest(): TSfflush failed to flush pending data to file: file size: before TSfflush (%d = 0), after %d == %d \n",
statBuffPost.st_size, statBuffInputText.st_size);
return ++fopenErrCount;
}
/*
- * 5. INKfread
- * 5.1 INKfread on read file
+ * 5. TSfread
+ * 5.1 TSfread on read file
* Read the tempnameWriteFile back in and compare to original
*/
/* open again for reading */
- cmpReadFile = INKfopen(tempnamWriteFile, "r");
+ cmpReadFile = TSfopen(tempnamWriteFile, "r");
if (cmpReadFile == NULL) {
- INKError("INKfopenTest() INKfopen failed on cmpReadFile\n");
+ TSError("TSfopenTest() TSfopen failed on cmpReadFile\n");
return ++fopenErrCount;
}
readAmount = (statBuffInputText.st_size <= sizeof(cmpBuf)) ? (statBuffInputText.st_size) : (sizeof(cmpBuf));
- /* 5.1 INKfread on read file */
- re = INKfread(cmpReadFile, cmpBuf, readAmount);
+ /* 5.1 TSfread on read file */
+ re = TSfread(cmpReadFile, cmpBuf, readAmount);
if (re != statBuffInputText.st_size) {
- INKError("INKfopenTest() INKfread failed: read %d/%d bytes\n", re, statBuffInputText.st_size);
+ TSError("TSfopenTest() TSfread failed: read %d/%d bytes\n", re, statBuffInputText.st_size);
return ++fopenErrCount;
}
/* compare inputBuf and cmpBuf buffers */
if (memcmp(inputBuf, cmpBuf, statBuffInputText.st_size) != 0) {
- INKError("INKfopenTest(): INKfread failed\n");
+ TSError("TSfopenTest(): TSfread failed\n");
return ++fopenErrCount;
} else
- INKDebug("INKfopen_plug-in", "INKfopenTest(): INKfread: passed, read %d/%d bytes\n", re, statBuffInputText.st_size);
+ TSDebug("TSfopen_plug-in", "TSfopenTest(): TSfread: passed, read %d/%d bytes\n", re, statBuffInputText.st_size);
/* remove the tmp file */
if (unlink(tempnamWriteFile) != 0) {
- INKError("INKfopenTest(): unlink failed on tempnamWriteFile\n");
+ TSError("TSfopenTest(): unlink failed on tempnamWriteFile\n");
}
- /* 1. INKfclose:
- * 1.1 INKfclose on read file
- * INKfclose test: close and attempt another operation
+ /* 1. TSfclose:
+ * 1.1 TSfclose on read file
+ * TSfclose test: close and attempt another operation
* should get error message about closed file.
*/
- INKfclose(sourceReadFile);
- re = INKfread(sourceReadFile, inputBuf, 1);
+ TSfclose(sourceReadFile);
+ re = TSfread(sourceReadFile, inputBuf, 1);
if (re != (-1)) {
- INKError("INKfopenTest(): INKfclose on a read file failed:\n");
- INKError("expected -1, read %d bytes\n", re);
+ TSError("TSfopenTest(): TSfclose on a read file failed:\n");
+ TSError("expected -1, read %d bytes\n", re);
return ++fopenErrCount;
} else
- INKDebug("INKfopen_plug-in", "INKfopen: INKfclose: on read file passed\n");
+ TSDebug("TSfopen_plug-in", "TSfopen: TSfclose: on read file passed\n");
- /* 1. INKfclose:
- * 1.2 INKfclose on write file
+ /* 1. TSfclose:
+ * 1.2 TSfclose on write file
* Any operation (read) on a closed file should return an error
* message
*/
- INKfclose(writeFile);
+ TSfclose(writeFile);
- wrote = INKfwrite(writeFile, inputBuf, 1);
+ wrote = TSfwrite(writeFile, inputBuf, 1);
if (wrote != (-1)) {
- INKError("INKfopenTest(): INKfclose on a write file failed:\n");
- INKError("expected -1, wrote %d bytes\n", wrote);
+ TSError("TSfopenTest(): TSfclose on a write file failed:\n");
+ TSError("expected -1, wrote %d bytes\n", wrote);
return ++fopenErrCount;
}
- INKDebug("INKfopen_plug-in", "INKfopen: INKfclose: on write file passed\n");
+ TSDebug("TSfopen_plug-in", "TSfopen: TSfclose: on write file passed\n");
- /* 1. INKfclose:
+ /* 1. TSfclose:
* 1.4 flush data on write file by writing then closing file
*
* TODO address how we do rewind on a file
@@ -333,24 +333,24 @@ INKfopenTest(INKHttpTxn txnp, INKCont co
/* Create unique tmp _file_name_ do not use any TS file_name
*/
if ((tempnamFlushFile = tempnam(TMP_DIR, PFX)) == NULL) {
- INKError("INKfopenTest(): tempnam failed for tempnamFlushFile\n");
+ TSError("TSfopenTest(): tempnam failed for tempnamFlushFile\n");
return ++fopenErrCount;
}
- if (!(writeFile = INKfopen(tempnamFlushFile, "w"))) {
- INKError("INKfopenTest(): INKfopen failed to open for write mode on tmpFlushFile\n");
+ if (!(writeFile = TSfopen(tempnamFlushFile, "w"))) {
+ TSError("TSfopenTest(): TSfopen failed to open for write mode on tmpFlushFile\n");
return ++fopenErrCount;
}
- if (!(sourceReadFile = INKfopen(inputTextFileFullPath, "r"))) {
+ if (!(sourceReadFile = TSfopen(inputTextFileFullPath, "r"))) {
/* Returns zero on erro */
- INKError("INKfopenTest(): INKfopen read mode failed on %s\n", inputTextFileFullPath);
+ TSError("TSfopenTest(): TSfopen read mode failed on %s\n", inputTextFileFullPath);
/* TODO try to do other part of test (goto) */
return ++fopenErrCount;
}
if (stat(inputTextFileFullPath, &statBuffInputText) != 0) {
- INKError("INKfopenTest() stat failed on %s\n", inputTextFileFullPath);
+ TSError("TSfopenTest() stat failed on %s\n", inputTextFileFullPath);
return ++fopenErrCount;
}
@@ -361,43 +361,43 @@ INKfopenTest(INKHttpTxn txnp, INKCont co
* inputBuf is the buffer to write to
* statBuffInputText.st_size is the amount of data to read
*/
- if ((retVal = INKfgets(sourceReadFile, inputBuf, statBuffInputText.st_size))
+ if ((retVal = TSfgets(sourceReadFile, inputBuf, statBuffInputText.st_size))
== NULL) {
- INKError("INKfopenTest(): INKfgets failed\n");
+ TSError("TSfopenTest(): TSfgets failed\n");
return ++fopenErrCount;
}
- wrote = INKfwrite(writeFile, inputBuf, statBuffInputText.st_size);
+ wrote = TSfwrite(writeFile, inputBuf, statBuffInputText.st_size);
if (wrote != statBuffInputText.st_size) {
- INKError("INKfopenTest() INKfwrite failed: write %d/%d bytes\n", wrote, BUFSIZ);
+ TSError("TSfopenTest() TSfwrite failed: write %d/%d bytes\n", wrote, BUFSIZ);
return ++fopenErrCount;
}
/* stat() */
if (stat(tempnamFlushFile, &statBuffPre) != 0) {
- INKError("INKfopenTest() stat failed on tempnamFlushFile\n");
+ TSError("TSfopenTest() stat failed on tempnamFlushFile\n");
return ++fopenErrCount;
}
- /* INKfclose should indirectly call INKflush on pending data */
- INKfclose(writeFile);
+ /* TSfclose should indirectly call TSflush on pending data */
+ TSfclose(writeFile);
if (stat(tempnamFlushFile, &statBuffPost) != 0) {
- INKError("INKfopenTest() stat failed on tmpFlushFile\n");
+ TSError("TSfopenTest() stat failed on tmpFlushFile\n");
return ++fopenErrCount;
}
if ((statBuffPre.st_size == 0) && (statBuffPost.st_size == statBuffInputText.st_size)) {
- INKDebug("INKfopen_plug-in", "INKfopenTest(): INKfclose: passed, pending data flushed to file\n");
+ TSDebug("TSfopen_plug-in", "TSfopenTest(): TSfclose: passed, pending data flushed to file\n");
} else {
- INKError("INKfopenTest(): INKfclose failed to flush pending data to file\n");
- INKError("file size: before INKfclose %d, after %d\n", statBuffPre.st_size, statBuffPost.st_size);
+ TSError("TSfopenTest(): TSfclose failed to flush pending data to file\n");
+ TSError("file size: before TSfclose %d, after %d\n", statBuffPre.st_size, statBuffPost.st_size);
return ++fopenErrCount;
}
/*
- * 4. INKfopen
- * 4.4 INKfopen for write: Open existing file for write
+ * 4. TSfopen
+ * 4.4 TSfopen for write: Open existing file for write
*/
/* Does this append or does this truncate ?
@@ -405,103 +405,103 @@ INKfopenTest(INKHttpTxn txnp, INKCont co
* API: open(2) or fopen(3S) or NT? We just need to pick one.
*/
/* writeFile just closed, temporary file still exists, reopen */
- if (!(writeFile = INKfopen(tempnamFlushFile, "w"))) {
- INKError("INKfopenTest(): INKfopen: open existing file for write failed\n");
+ if (!(writeFile = TSfopen(tempnamFlushFile, "w"))) {
+ TSError("TSfopenTest(): TSfopen: open existing file for write failed\n");
return ++fopenErrCount;
}
- re = INKfwrite(writeFile, cmpBuf, statBuffInputText.st_size);
+ re = TSfwrite(writeFile, cmpBuf, statBuffInputText.st_size);
if (re != statBuffInputText.st_size) {
- INKError("INKfopenTest(): INKfopen: INKfwrite on existing file open for write failed\n");
+ TSError("TSfopenTest(): TSfopen: TSfwrite on existing file open for write failed\n");
return ++fopenErrCount;
}
if ((stat(tempnamFlushFile, &statBuffPost) == 0) && (statBuffPost.st_size == statBuffInputText.st_size)) {
- INKDebug("INKfopen_plug-in", "INKfopenTest(): INKfopen: INKfwrite on existing file open for write passed\n");
+ TSDebug("TSfopen_plug-in", "TSfopenTest(): TSfopen: TSfwrite on existing file open for write passed\n");
} else {
- INKError("INKfopenTest(): INKfopen: INKfwrite on existing file open for write failed, reason unkown. \n");
+ TSError("TSfopenTest(): TSfopen: TSfwrite on existing file open for write failed, reason unkown. \n");
return ++fopenErrCount;
}
- INKfclose(writeFile);
+ TSfclose(writeFile);
/* remove the tmp file */
if (unlink(tempnamFlushFile) != 0) {
- INKError("INKfopenTest() unlink failed on tmpFlushFile\n");
+ TSError("TSfopenTest() unlink failed on tmpFlushFile\n");
}
/* Need generic test pass/test fail routine */
/* TODO report on total errors/total tests */
- INKDebug("INKfopen_plug-in", "INKfopen: completed %d tests\n", NUM_FOPEN_TESTS);
+ TSDebug("TSfopen_plug-in", "TSfopen: completed %d tests\n", NUM_FOPEN_TESTS);
return fopenErrCount;
}
static int
-INKMemAllocTest(INKHttpTxn txnp, INKCont contp)
+TSMemAllocTest(TSHttpTxn txnp, TSCont contp)
{
- int INKMemAllocErrors = 0;
+ int TSMemAllocErrors = 0;
- INKDebug("INKfopen_plug-in", "INKMemAllocTest() called \n");
+ TSDebug("TSfopen_plug-in", "TSMemAllocTest() called \n");
/*
-INKmalloc
-INKfree
-INKfree
-INKmalloc
-INKrealloc
-INKstrdup
-INKstrndup
+TSmalloc
+TSfree
+TSfree
+TSmalloc
+TSrealloc
+TSstrdup
+TSstrndup
*/
- return INKMemAllocErrors;
+ return TSMemAllocErrors;
}
void *
pthreadStartFunc(void *arg)
{
- INKThread tmpINKThread = 0;
+ TSThread tmpTSThread = 0;
/* Init this thread */
- tmpINKThread = INKThreadInit();
+ tmpTSThread = TSThreadInit();
/* sleep(6) ; */
- if (!tmpINKThread) {
- INKError("INKfopen_plug-in", "pthreadStartFunc(): INKThreadInit failed\n");
- /* TODO track threads created in INKThreadTest() with the threads being called/terminiting here */
+ if (!tmpTSThread) {
+ TSError("TSfopen_plug-in", "pthreadStartFunc(): TSThreadInit failed\n");
+ /* TODO track threads created in TSThreadTest() with the threads being called/terminiting here */
/* errCreateCount--; */
} else
- INKDebug("INKfopen_plug-in", "pthreadStartFunc(): INKThreadInit pass\n");
+ TSDebug("TSfopen_plug-in", "pthreadStartFunc(): TSThreadInit pass\n");
- INKDebug("INKfopen_plug-in", "pthreadStartFunc(): created by thread: \
+ TSDebug("TSfopen_plug-in", "pthreadStartFunc(): created by thread: \
%d running on pthread: %d\n", (pthread_t) arg, pthread_self());
/* Clean-up this thread */
- if (tmpINKThread)
- INKThreadDestroy(tmpINKThread);
+ if (tmpTSThread)
+ TSThreadDestroy(tmpTSThread);
return NULL;
}
static void *
-INKThreadCallee(void *arg)
+TSThreadCallee(void *arg)
{
char buf[BUFSIZ];
- INKThread INKthread;
+ TSThread TSthread;
/* TODO do more useful work here */
sleep(10);
- INKDebug("INKfopen_plug-in", "INKThreadTest(): INKThreadCallee: INKThreadCreate passed\n");
+ TSDebug("TSfopen_plug-in", "TSThreadTest(): TSThreadCallee: TSThreadCreate passed\n");
- INKthread = INKThreadSelf(); /* Get thread id for this thread */
- if (INKthread == 0) {
- INKError("INKfopen_plug-in", "INKThreadCallee(): INKThreadSelf() failed\n");
+ TSthread = TSThreadSelf(); /* Get thread id for this thread */
+ if (TSthread == 0) {
+ TSError("TSfopen_plug-in", "TSThreadCallee(): TSThreadSelf() failed\n");
/* TODO can't use return values track errors in global data (or tsd ?) */
}
- INKDebug("INKfopen_plug-in",
- "INKThreadTest(): INKThreadCallee: created by pthread_t:%d running on pthread_t:%d, and INKThread at 0x%08x.\n",
- (int) arg, pthread_self(), INKthread);
+ TSDebug("TSfopen_plug-in",
+ "TSThreadTest(): TSThreadCallee: created by pthread_t:%d running on pthread_t:%d, and TSThread at 0x%08x.\n",
+ (int) arg, pthread_self(), TSthread);
return NULL;
}
@@ -521,41 +521,41 @@ INKThreadCallee(void *arg)
pthread_t currTid, newTid;
static int
-INKThreadTest(INKHttpTxn txnp, INKCont contp)
+TSThreadTest(TSHttpTxn txnp, TSCont contp)
{
- INKThreadFunc threadFunc;
+ TSThreadFunc threadFunc;
struct stat statBuffPre, statBuffPost;
- INKThread INKCurrThread = 0;
- INKThread INKCreateThread = 0;
- INKThread tmpINKThread = 0;
+ TSThread TSCurrThread = 0;
+ TSThread TSCreateThread = 0;
+ TSThread tmpTSThread = 0;
int errCreateCount = NUM_THREADS;
int threadErrCount = 0;
int i, rval;
currTid = pthread_self();
- INKDebug("INKfopen_plug-in", "INKThreadTest(): Begin: running on thread %d\n", currTid);
+ TSDebug("TSfopen_plug-in", "TSThreadTest(): Begin: running on thread %d\n", currTid);
/* call C++ code here */
- /* Test #1: Get current INKThread */
- INKCurrThread = INKThreadSelf();
- if (INKCurrThread == 0) {
- INKError("INKfopen_plug-in", "INKThreadSelf(): failed\n");
+ /* Test #1: Get current TSThread */
+ TSCurrThread = TSThreadSelf();
+ if (TSCurrThread == 0) {
+ TSError("TSfopen_plug-in", "TSThreadSelf(): failed\n");
threadErrCount++;
} else
- INKDebug("INKfopen_plug-in", "INKThreadSelf(): passed: current INKThread:0x%08x\n", INKCurrThread);
+ TSDebug("TSfopen_plug-in", "TSThreadSelf(): passed: current TSThread:0x%08x\n", TSCurrThread);
/* Test 2: */
- threadFunc = (INKThreadFunc) INKThreadCallee;
+ threadFunc = (TSThreadFunc) TSThreadCallee;
/* Try to attach this thread to a function that does not have the
* the same prototype described in the p.g.
*/
- /* INKThreadCreate(threadFunc, (void*)&argInt); */
- /* INKThreadCreate((INKThreadFunc)INKThreadCallee, (void*)&argInt); */
- INKCreateThread = INKThreadCreate(INKThreadCallee, (void *) currTid);
- if (INKCreateThread) {
- INKDebug("INKfopen_plug-in", "INKThreadCreate(): registration of thread init passed\n");
+ /* TSThreadCreate(threadFunc, (void*)&argInt); */
+ /* TSThreadCreate((TSThreadFunc)TSThreadCallee, (void*)&argInt); */
+ TSCreateThread = TSThreadCreate(TSThreadCallee, (void *) currTid);
+ if (TSCreateThread) {
+ TSDebug("TSfopen_plug-in", "TSThreadCreate(): registration of thread init passed\n");
} else {
- INKError("INKfopen_plug-in", "INKThreadCreate(): registration of thread init failed\n");
+ TSError("TSfopen_plug-in", "TSThreadCreate(): registration of thread init failed\n");
threadErrCount++;
}
@@ -578,8 +578,8 @@ INKThreadTest(INKHttpTxn txnp, INKCont c
#endif
if (rval != 0 || errno) {
errCreateCount--;
- INKError("INKfopen_plug-in",
- "INKThreadTest(): thread %d called pthread_create and failed to create pthread, errno:%d\n", currTid,
+ TSError("TSfopen_plug-in",
+ "TSThreadTest(): thread %d called pthread_create and failed to create pthread, errno:%d\n", currTid,
errno);
/********************************************
@@ -587,33 +587,33 @@ INKThreadTest(INKHttpTxn txnp, INKCont c
continue; skip these tests
********************************************/
} else
- INKDebug("INKfopen_plug-in", "INKThreadTest(): pthread_create created: %d\n", newTid);
+ TSDebug("TSfopen_plug-in", "TSThreadTest(): pthread_create created: %d\n", newTid);
}
/* No errors means all threads were created */
- INKDebug("INKfopen_plug-in", "INKThreadTest(): created %d/%d pthreads\n", errCreateCount, NUM_THREADS);
+ TSDebug("TSfopen_plug-in", "TSThreadTest(): created %d/%d pthreads\n", errCreateCount, NUM_THREADS);
if (errCreateCount != NUM_THREADS)
threadErrCount++;
- INKDebug("INKfopen_plug-in",
- "INKThreadTest(): results: %d/%d test passed \n", (NUM_THREAD_TESTS - threadErrCount), NUM_THREAD_TESTS);
+ TSDebug("TSfopen_plug-in",
+ "TSThreadTest(): results: %d/%d test passed \n", (NUM_THREAD_TESTS - threadErrCount), NUM_THREAD_TESTS);
return threadErrCount;
}
/* only callable from this file and as a call-back */
static int
-INKfopen_plugin(INKCont contp, INKEvent event, void *edata)
+TSfopen_plugin(TSCont contp, TSEvent event, void *edata)
{
int status = 0; /* assume success */
- INKHttpTxn txnp = (INKHttpTxn) edata;
+ TSHttpTxn txnp = (TSHttpTxn) edata;
switch (event) {
- case INK_EVENT_HTTP_OS_DNS:
+ case TS_EVENT_HTTP_OS_DNS:
- status += INKThreadTest(txnp, contp);
+ status += TSThreadTest(txnp, contp);
default:
break;
@@ -621,27 +621,27 @@ INKfopen_plugin(INKCont contp, INKEvent
/* Always reeneable HTTP transaction after processing of each
* transaction event.
*/
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
return status;
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont contp;
+ TSCont contp;
/* Parse args */
- if (!strcmp(argv[1], "INKfopenTest")) {
- INKDebug("INKfopen_plug-in", "\nRun: INKfopenTest \n");
+ if (!strcmp(argv[1], "TSfopenTest")) {
+ TSDebug("TSfopen_plug-in", "\nRun: TSfopenTest \n");
}
/* Associate this data at time call-back is called */
- contp = INKContCreate(INKfopen_plugin, NULL /* mutex */ );
+ contp = TSContCreate(TSfopen_plugin, NULL /* mutex */ );
if (contp == NULL) {
- INKError("usage: %s INKContCreate() returned NULL\n", argv[0]);
+ TSError("usage: %s TSContCreate() returned NULL\n", argv[0]);
return;
}
- /* Set at INK_HTTP_OS_DNS_HOOK for no specific reason */
- INKHttpHookAdd(INK_HTTP_OS_DNS_HOOK, contp);
+ /* Set at TS_HTTP_OS_DNS_HOOK for no specific reason */
+ TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, contp);
}
Modified: trafficserver/traffic/branches/wccp/test/plugin/INKHttpHooksTrans/INKHttpHook.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/branches/wccp/test/plugin/INKHttpHooksTrans/INKHttpHook.c?rev=1040383&r1=1040382&r2=1040383&view=diff
==============================================================================
--- trafficserver/traffic/branches/wccp/test/plugin/INKHttpHooksTrans/INKHttpHook.c (original)
+++ trafficserver/traffic/branches/wccp/test/plugin/INKHttpHooksTrans/INKHttpHook.c Tue Nov 30 01:42:55 2010
@@ -36,29 +36,29 @@ TODO TRANSFORM hooks are not "global" bu
-const char *const INKEventStrId[] = {
- "INK_EVENT_HTTP_CONTINUE", /* 60000 */
- "INK_EVENT_HTTP_ERROR", /* 60001 */
- "INK_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
- "INK_EVENT_HTTP_OS_DNS", /* 60003 */
- "INK_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
- "INK_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
- "INK_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
- "INK_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
- "INK_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
- "INK_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
- "INK_EVENT_HTTP_SELECT_ALT", /* 60010 */
- "INK_EVENT_HTTP_TXN_START", /* 60011 */
- "INK_EVENT_HTTP_TXN_CLOSE", /* 60012 */
- "INK_EVENT_HTTP_SSN_START", /* 60013 */
- "INK_EVENT_HTTP_SSN_CLOSE", /* 60014 */
+const char *const TSEventStrId[] = {
+ "TS_EVENT_HTTP_CONTINUE", /* 60000 */
+ "TS_EVENT_HTTP_ERROR", /* 60001 */
+ "TS_EVENT_HTTP_READ_REQUEST_HDR", /* 60002 */
+ "TS_EVENT_HTTP_OS_DNS", /* 60003 */
+ "TS_EVENT_HTTP_SEND_REQUEST_HDR", /* 60004 */
+ "TS_EVENT_HTTP_READ_CACHE_HDR", /* 60005 */
+ "TS_EVENT_HTTP_READ_RESPONSE_HDR", /* 60006 */
+ "TS_EVENT_HTTP_SEND_RESPONSE_HDR", /* 60007 */
+ "TS_EVENT_HTTP_REQUEST_TRANSFORM", /* 60008 */
+ "TS_EVENT_HTTP_RESPONSE_TRANSFORM", /* 60009 */
+ "TS_EVENT_HTTP_SELECT_ALT", /* 60010 */
+ "TS_EVENT_HTTP_TXN_START", /* 60011 */
+ "TS_EVENT_HTTP_TXN_CLOSE", /* 60012 */
+ "TS_EVENT_HTTP_SSN_START", /* 60013 */
+ "TS_EVENT_HTTP_SSN_CLOSE", /* 60014 */
- "INK_EVENT_MGMT_UPDATE" /* 60100 */
+ "TS_EVENT_MGMT_UPDATE" /* 60100 */
};
/*
* We track that each hook was called using this array. We start with
- * all values set to zero, meaning that the INKEvent has not been
+ * all values set to zero, meaning that the TSEvent has not been
* received.
* There 16 entries.
*/
@@ -71,11 +71,11 @@ static int
ChkEvents(const int event)
{
int i, re = 0;
- INKDebug("INKHttpHook", "ChkEvents: -- %s -- ", INKEventStrId[index(event)]);
+ TSDebug("TSHttpHook", "ChkEvents: -- %s -- ", TSEventStrId[index(event)]);
for (i = 0; i < inktHookTblSize; i++) {
if (!inktHookTbl[i]) {
- printf("Event [%d] %s registered and not called back\n", i, INKEventStrId[i]);
+ printf("Event [%d] %s registered and not called back\n", i, TSEventStrId[i]);
re = 1;
}
}
@@ -83,98 +83,98 @@ ChkEvents(const int event)
}
-/* event routine: for each INKHttpHookID this routine should be called
+/* event routine: for each TSHttpHookID this routine should be called
* with a matching event.
*/
static int
-INKHttpHook(INKCont contp, INKEvent event, void *eData)
+TSHttpHook(TSCont contp, TSEvent event, void *eData)
{
- INKHttpSsn ssnp = (INKHttpSsn) eData;
- INKHttpTxn txnp = (INKHttpTxn) eData;
+ TSHttpSsn ssnp = (TSHttpSsn) eData;
+ TSHttpTxn txnp = (TSHttpTxn) eData;
switch (event) {
- case INK_EVENT_HTTP_READ_REQUEST_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_READ_REQUEST_HDR)] = 1;
+ case TS_EVENT_HTTP_READ_REQUEST_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_READ_REQUEST_HDR)] = 1;
/* List what events have been called back at
* this point in procesing
*/
- ChkEvents(INK_EVENT_HTTP_READ_REQUEST_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ ChkEvents(TS_EVENT_HTTP_READ_REQUEST_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_OS_DNS:
- inktHookTbl[index(INK_EVENT_HTTP_OS_DNS)] = 1;
- ChkEvents(INK_EVENT_HTTP_OS_DNS);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_OS_DNS:
+ inktHookTbl[index(TS_EVENT_HTTP_OS_DNS)] = 1;
+ ChkEvents(TS_EVENT_HTTP_OS_DNS);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SEND_REQUEST_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_SEND_REQUEST_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_SEND_REQUEST_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_SEND_REQUEST_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_SEND_REQUEST_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SEND_REQUEST_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_CACHE_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_READ_CACHE_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_READ_CACHE_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_READ_CACHE_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_READ_CACHE_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_READ_CACHE_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_READ_RESPONSE_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_READ_RESPONSE_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_READ_RESPONSE_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_READ_RESPONSE_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SEND_RESPONSE_HDR:
- inktHookTbl[index(INK_EVENT_HTTP_SEND_RESPONSE_HDR)] = 1;
- ChkEvents(INK_EVENT_HTTP_SEND_RESPONSE_HDR);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
+ inktHookTbl[index(TS_EVENT_HTTP_SEND_RESPONSE_HDR)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SEND_RESPONSE_HDR);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_REQUEST_TRANSFORM:
- inktHookTbl[index(INK_EVENT_HTTP_REQUEST_TRANSFORM)] = 1;
- ChkEvents(INK_EVENT_HTTP_REQUEST_TRANSFORM);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_REQUEST_TRANSFORM:
+ inktHookTbl[index(TS_EVENT_HTTP_REQUEST_TRANSFORM)] = 1;
+ ChkEvents(TS_EVENT_HTTP_REQUEST_TRANSFORM);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_RESPONSE_TRANSFORM:
- inktHookTbl[index(INK_EVENT_HTTP_RESPONSE_TRANSFORM)] = 1;
- ChkEvents(INK_EVENT_HTTP_RESPONSE_TRANSFORM);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_RESPONSE_TRANSFORM:
+ inktHookTbl[index(TS_EVENT_HTTP_RESPONSE_TRANSFORM)] = 1;
+ ChkEvents(TS_EVENT_HTTP_RESPONSE_TRANSFORM);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SELECT_ALT:
- inktHookTbl[index(INK_EVENT_HTTP_SELECT_ALT)] = 1;
- ChkEvents(INK_EVENT_HTTP_SELECT_ALT);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_SELECT_ALT:
+ inktHookTbl[index(TS_EVENT_HTTP_SELECT_ALT)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SELECT_ALT);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_TXN_START:
- inktHookTbl[index(INK_EVENT_HTTP_TXN_START)] = 1;
- ChkEvents(INK_EVENT_HTTP_TXN_START);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_TXN_START:
+ inktHookTbl[index(TS_EVENT_HTTP_TXN_START)] = 1;
+ ChkEvents(TS_EVENT_HTTP_TXN_START);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_TXN_CLOSE:
- inktHookTbl[index(INK_EVENT_HTTP_TXN_CLOSE)] = 1;
- ChkEvents(INK_EVENT_HTTP_TXN_CLOSE);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ case TS_EVENT_HTTP_TXN_CLOSE:
+ inktHookTbl[index(TS_EVENT_HTTP_TXN_CLOSE)] = 1;
+ ChkEvents(TS_EVENT_HTTP_TXN_CLOSE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SSN_START:
+ case TS_EVENT_HTTP_SSN_START:
- inktHookTbl[index(INK_EVENT_HTTP_SSN_START)] = 1;
- ChkEvents(INK_EVENT_HTTP_SSN_START);
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ inktHookTbl[index(TS_EVENT_HTTP_SSN_START)] = 1;
+ ChkEvents(TS_EVENT_HTTP_SSN_START);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
- case INK_EVENT_HTTP_SSN_CLOSE:
+ case TS_EVENT_HTTP_SSN_CLOSE:
/* Here as a result of:
- * INKHTTPHookAdd(INK_HTTP_SSN_CLOSE_HOOK)
+ * TSHTTPHookAdd(TS_HTTP_SSN_CLOSE_HOOK)
*/
- inktHookTbl[index(INK_EVENT_HTTP_SSN_CLOSE)] = 1;
+ inktHookTbl[index(TS_EVENT_HTTP_SSN_CLOSE)] = 1;
/* Assumption: at this point all other events have
* have been called. Since a session can have one or
@@ -182,51 +182,51 @@ INKHttpHook(INKCont contp, INKEvent even
* prompt us to check that all events have been called back
* CAUTION: can a single request trigger all events?
*/
- if (ChkEvents(INK_EVENT_HTTP_SSN_CLOSE))
- INKError("INKHttpHook: Fail: All events not called back.\n");
+ if (ChkEvents(TS_EVENT_HTTP_SSN_CLOSE))
+ TSError("TSHttpHook: Fail: All events not called back.\n");
else
- INKError("INKHttpHook: Pass: All events called back.\n");
+ TSError("TSHttpHook: Pass: All events called back.\n");
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
break;
default:
- INKError("INKHttpHook: undefined event [%d] received\n", event);
+ TSError("TSHttpHook: undefined event [%d] received\n", event);
break;
}
}
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKCont myCont = NULL;
+ TSCont myCont = NULL;
inktHookTblSize = sizeof(inktHookTbl) / sizeof(int);
/* Create continuation */
- myCont = INKContCreate(INKHttpHook, NULL);
+ myCont = TSContCreate(TSHttpHook, NULL);
if (myCont != NULL) {
- INKHttpHookAdd(INK_HTTP_READ_REQUEST_HDR_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_OS_DNS_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_SEND_REQUEST_HDR_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_READ_CACHE_HDR_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_READ_RESPONSE_HDR_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_SEND_RESPONSE_HDR_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SEND_REQUEST_HDR_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_READ_CACHE_HDR_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SEND_RESPONSE_HDR_HOOK, myCont);
/* These are transactional
- * INKHttpHookAdd(INK_HTTP_REQUEST_TRANSFORM_HOOK, myCont);
- * INKHttpHookAdd(INK_HTTP_RESPONSE_TRANSFORM_HOOK, myCont);
+ * TSHttpHookAdd(TS_HTTP_REQUEST_TRANSFORM_HOOK, myCont);
+ * TSHttpHookAdd(TS_HTTP_RESPONSE_TRANSFORM_HOOK, myCont);
*/
- INKHttpHookAdd(INK_HTTP_SELECT_ALT_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SELECT_ALT_HOOK, myCont);
/* TODO this is transactional and not global */
- INKHttpHookAdd(INK_HTTP_TXN_START_HOOK, myCont);
- INKHttpHookAdd(INK_HTTP_TXN_CLOSE_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_TXN_START_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_TXN_CLOSE_HOOK, myCont);
- /* INKqa08194:
- * INKHttpHookAdd(INK_HTTP_SSN_START_HOOK, myCont);
+ /* TSqa08194:
+ * TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, myCont);
*/
- INKHttpHookAdd(INK_HTTP_SSN_CLOSE_HOOK, myCont);
+ TSHttpHookAdd(TS_HTTP_SSN_CLOSE_HOOK, myCont);
} else
- INKError("INKHttpHook: INKContCreate() failed \n");
+ TSError("TSHttpHook: TSContCreate() failed \n");
}