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/16 21:22:08 UTC
svn commit: r1035782 [6/29] - in /trafficserver/traffic/trunk:
example/add-header/ example/append-transform/ example/basic-auth/
example/blacklist-0/ example/blacklist-1/ example/bnull-transform/
example/cache_plugin/ example/cache_scan/ example/file-1...
Modified: trafficserver/traffic/trunk/example/thread-pool/psi.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/thread-pool/psi.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/thread-pool/psi.c (original)
+++ trafficserver/traffic/trunk/example/thread-pool/psi.c Tue Nov 16 20:22:02 2010
@@ -93,12 +93,12 @@ typedef enum
typedef struct
{
unsigned int magic;
- INKVIO output_vio;
- INKIOBuffer output_buffer;
- INKIOBufferReader output_reader;
+ TSVIO output_vio;
+ TSIOBuffer output_buffer;
+ TSIOBufferReader output_reader;
- INKIOBuffer psi_buffer;
- INKIOBufferReader psi_reader;
+ TSIOBuffer psi_buffer;
+ TSIOBufferReader psi_reader;
char psi_filename[PSI_FILENAME_MAX_SIZE + 128];
int psi_filename_len;
int psi_success;
@@ -112,8 +112,8 @@ typedef struct
typedef struct
{
- INKCont contp;
- INKEvent event;
+ TSCont contp;
+ TSEvent event;
} TryLockData;
@@ -127,11 +127,11 @@ typedef enum
extern Queue job_queue;
-static INKTextLogObject log;
+static TSTextLogObject log;
static char psi_directory[PSI_PATH_MAX_SIZE];
-static int trylock_handler(INKCont contp, INKEvent event, void *edata);
+static int trylock_handler(TSCont contp, TSEvent event, void *edata);
/*-------------------------------------------------------------------------
cont_data_alloc
@@ -147,7 +147,7 @@ cont_data_alloc()
{
ContData *data;
- data = (ContData *) INKmalloc(sizeof(ContData));
+ data = (ContData *) TSmalloc(sizeof(ContData));
data->magic = MAGIC_ALIVE;
data->output_vio = NULL;
data->output_buffer = NULL;
@@ -181,27 +181,27 @@ cont_data_alloc()
static void
cont_data_destroy(ContData * data)
{
- INKDebug(DBG_TAG, "Destroying continuation data");
+ TSDebug(DBG_TAG, "Destroying continuation data");
if (data) {
- INKAssert(data->magic == MAGIC_ALIVE);
+ TSAssert(data->magic == MAGIC_ALIVE);
if (data->output_reader) {
- INKIOBufferReaderFree(data->output_reader);
+ TSIOBufferReaderFree(data->output_reader);
data->output_reader = NULL;
}
if (data->output_buffer) {
- INKIOBufferDestroy(data->output_buffer);
+ TSIOBufferDestroy(data->output_buffer);
data->output_buffer = NULL;
}
if (data->psi_reader) {
- INKIOBufferReaderFree(data->psi_reader);
+ TSIOBufferReaderFree(data->psi_reader);
data->psi_reader = NULL;
}
if (data->psi_buffer) {
- INKIOBufferDestroy(data->psi_buffer);
+ TSIOBufferDestroy(data->psi_buffer);
data->psi_buffer = NULL;
}
data->magic = MAGIC_DEAD;
- INKfree(data);
+ TSfree(data);
}
}
@@ -221,17 +221,17 @@ cont_data_destroy(ContData * data)
STR_FAIL if pattern not found
-------------------------------------------------------------------------*/
static StrOperationResult
-strsearch_ioreader(INKIOBufferReader reader, const char *pattern, int *nparse)
+strsearch_ioreader(TSIOBufferReader reader, const char *pattern, int *nparse)
{
int index = 0;
- INKIOBufferBlock block = INKIOBufferReaderStart(reader);
+ TSIOBufferBlock block = TSIOBufferReaderStart(reader);
int slen = strlen(pattern);
if (slen <= 0) {
return STR_FAIL;
}
- if (block == INK_ERROR_PTR) {
- INKError("[strsearch_ioreader] Error while getting block from ioreader");
+ if (block == TS_ERROR_PTR) {
+ TSError("[strsearch_ioreader] Error while getting block from ioreader");
return STR_FAIL;
}
@@ -240,11 +240,11 @@ strsearch_ioreader(INKIOBufferReader rea
/* Loop thru each block while we've not yet found the pattern */
while ((block != NULL) && (index < slen)) {
int64 blocklen;
- const char *blockptr = INKIOBufferBlockReadStart(block, reader, &blocklen);
+ const char *blockptr = TSIOBufferBlockReadStart(block, reader, &blocklen);
const char *ptr;
- if (blockptr == INK_ERROR_PTR) {
- INKError("[strsearch_ioreader] Error while getting block pointer");
+ if (blockptr == TS_ERROR_PTR) {
+ TSError("[strsearch_ioreader] Error while getting block pointer");
break;
}
@@ -261,22 +261,22 @@ strsearch_ioreader(INKIOBufferReader rea
}
/* Parse next block */
- block = INKIOBufferBlockNext(block);
- if (block == INK_ERROR_PTR) {
- INKError("[strsearch_ioreader] Error while getting block from ioreader");
+ block = TSIOBufferBlockNext(block);
+ if (block == TS_ERROR_PTR) {
+ TSError("[strsearch_ioreader] Error while getting block from ioreader");
return STR_FAIL;
}
}
*nparse -= index; /* Adjust nparse so it doesn't include matching chars */
if (index == slen) {
- INKDebug(DBG_TAG, "strfind: match for %s at position %d", pattern, *nparse);
+ TSDebug(DBG_TAG, "strfind: match for %s at position %d", pattern, *nparse);
return STR_SUCCESS;
} else if (index > 0) {
- INKDebug(DBG_TAG, "strfind: partial match for %s at position %d", pattern, *nparse);
+ TSDebug(DBG_TAG, "strfind: partial match for %s at position %d", pattern, *nparse);
return STR_PARTIAL;
} else {
- INKDebug(DBG_TAG, "strfind no match for %s", pattern);
+ TSDebug(DBG_TAG, "strfind no match for %s", pattern);
return STR_FAIL;
}
}
@@ -301,30 +301,30 @@ strsearch_ioreader(INKIOBufferReader rea
STR_FAIL if extraction failed
-------------------------------------------------------------------------*/
static int
-strextract_ioreader(INKIOBufferReader reader, int offset, const char *end_pattern, char *buffer, int *buflen)
+strextract_ioreader(TSIOBufferReader reader, int offset, const char *end_pattern, char *buffer, int *buflen)
{
int buf_idx = 0;
int p_idx = 0;
int nbytes_so_far = 0;
int plen = strlen(end_pattern);
const char *ptr;
- INKIOBufferBlock block = INKIOBufferReaderStart(reader);
+ TSIOBufferBlock block = TSIOBufferReaderStart(reader);
if (plen <= 0) {
return STR_FAIL;
}
- if (block == INK_ERROR_PTR) {
- INKError("[strextract_ioreader] Error while getting block from ioreader");
+ if (block == TS_ERROR_PTR) {
+ TSError("[strextract_ioreader] Error while getting block from ioreader");
return STR_FAIL;
}
/* Now start extraction */
while ((block != NULL) && (p_idx < plen) && (buf_idx < PSI_FILENAME_MAX_SIZE)) {
int64 blocklen;
- const char *blockptr = INKIOBufferBlockReadStart(block, reader, &blocklen);
+ const char *blockptr = TSIOBufferBlockReadStart(block, reader, &blocklen);
- if (blockptr == INK_ERROR_PTR) {
- INKError("[strsearch_ioreader] Error while getting block pointer");
+ if (blockptr == TS_ERROR_PTR) {
+ TSError("[strsearch_ioreader] Error while getting block pointer");
break;
}
@@ -351,16 +351,16 @@ strextract_ioreader(INKIOBufferReader re
}
}
- block = INKIOBufferBlockNext(block);
- if (block == INK_ERROR_PTR) {
- INKError("[strextract_ioreader] Error while getting block from ioreader");
+ block = TSIOBufferBlockNext(block);
+ if (block == TS_ERROR_PTR) {
+ TSError("[strextract_ioreader] Error while getting block from ioreader");
return STR_FAIL;
}
}
/* Error, could not read end of filename */
if (buf_idx >= PSI_FILENAME_MAX_SIZE) {
- INKDebug(DBG_TAG, "strextract: filename too long");
+ TSDebug(DBG_TAG, "strextract: filename too long");
*buflen = 0;
return STR_FAIL;
}
@@ -370,12 +370,12 @@ strextract_ioreader(INKIOBufferReader re
/* Nul terminate the filename, remove the end_pattern copied into the buffer */
*buflen = buf_idx - plen;
buffer[*buflen] = '\0';
- INKDebug(DBG_TAG, "strextract: filename = |%s|", buffer);
+ TSDebug(DBG_TAG, "strextract: filename = |%s|", buffer);
return STR_SUCCESS;
}
/* End of filename not yet reached we need to read some more data */
else {
- INKDebug(DBG_TAG, "strextract: partially extracted filename");
+ TSDebug(DBG_TAG, "strextract: partially extracted filename");
*buflen = buf_idx - p_idx;
return STR_PARTIAL;
}
@@ -399,14 +399,14 @@ strextract_ioreader(INKIOBufferReader re
1 if a psi filename was found
-------------------------------------------------------------------------*/
static int
-parse_data(INKCont contp, INKIOBufferReader input_reader, int avail, int *toconsume, int *towrite)
+parse_data(TSCont contp, TSIOBufferReader input_reader, int avail, int *toconsume, int *towrite)
{
ContData *data;
int nparse = 0;
int status;
- data = INKContDataGet(contp);
- INKAssert(data->magic == MAGIC_ALIVE);
+ data = TSContDataGet(contp);
+ TSAssert(data->magic == MAGIC_ALIVE);
if (data->parse_state == PARSE_SEARCH) {
@@ -432,7 +432,7 @@ parse_data(INKCont contp, INKIOBufferRea
data->parse_state = PARSE_EXTRACT;
break;
default:
- INKAssert(!"strsearch_ioreader returned unexpected status");
+ TSAssert(!"strsearch_ioreader returned unexpected status");
}
}
@@ -460,7 +460,7 @@ parse_data(INKCont contp, INKIOBufferRea
data->parse_state = PARSE_SEARCH;
return 1;
default:
- INKAssert(!"strextract_ioreader returned bad status");
+ TSAssert(!"strextract_ioreader returned bad status");
}
return 0;
@@ -506,32 +506,32 @@ _basename(const char *filename)
1 if success
-------------------------------------------------------------------------*/
static int
-psi_include(INKCont contp, void *edata)
+psi_include(TSCont contp, void *edata)
{
#define BUFFER_SIZE 1024
ContData *data;
- INKFile filep;
+ TSFile filep;
char buf[BUFFER_SIZE];
char inc_file[PSI_PATH_MAX_SIZE + PSI_FILENAME_MAX_SIZE];
- INKReturnCode retval;
+ TSReturnCode retval;
/* We manipulate plugin continuation data from a separate thread.
Grab mutex to avoid concurrent access */
- retval = INKMutexLock(INKContMutexGet(contp));
- if (retval != INK_SUCCESS) {
- INKError("[psi_include] Could not lock mutex");
+ retval = TSMutexLock(TSContMutexGet(contp));
+ if (retval != TS_SUCCESS) {
+ TSError("[psi_include] Could not lock mutex");
return 0;
}
- data = INKContDataGet(contp);
- INKAssert(data->magic == MAGIC_ALIVE);
+ data = TSContDataGet(contp);
+ TSAssert(data->magic == MAGIC_ALIVE);
if (!data->psi_buffer) {
- data->psi_buffer = INKIOBufferCreate();
- data->psi_reader = INKIOBufferReaderAlloc(data->psi_buffer);
+ data->psi_buffer = TSIOBufferCreate();
+ data->psi_reader = TSIOBufferReaderAlloc(data->psi_buffer);
- if ((data->psi_buffer == INK_ERROR_PTR) || (data->psi_reader == INK_ERROR_PTR)) {
- INKError("[psi_include] Could not create iobuffer to store include content");
+ if ((data->psi_buffer == TS_ERROR_PTR) || (data->psi_reader == TS_ERROR_PTR)) {
+ TSError("[psi_include] Could not create iobuffer to store include content");
goto error;
}
}
@@ -542,11 +542,11 @@ psi_include(INKCont contp, void *edata)
sprintf(inc_file, "%s/%s", psi_directory, _basename(data->psi_filename));
/* Read the include file and copy content into iobuffer */
- if ((filep = INKfopen(inc_file, "r")) != NULL) {
- INKDebug(DBG_TAG, "Reading include file %s", inc_file);
+ if ((filep = TSfopen(inc_file, "r")) != NULL) {
+ TSDebug(DBG_TAG, "Reading include file %s", inc_file);
- while (INKfgets(filep, buf, BUFFER_SIZE) != NULL) {
- INKIOBufferBlock block;
+ while (TSfgets(filep, buf, BUFFER_SIZE) != NULL) {
+ TSIOBufferBlock block;
int64 len, avail, ndone, ntodo, towrite;
char *ptr_block;
@@ -554,38 +554,38 @@ psi_include(INKCont contp, void *edata)
ndone = 0;
ntodo = len;
while (ntodo > 0) {
- /* INKIOBufferStart allocates more blocks if required */
- block = INKIOBufferStart(data->psi_buffer);
- if (block == INK_ERROR_PTR) {
- INKError("[psi_include] Could not get buffer block");
+ /* TSIOBufferStart allocates more blocks if required */
+ block = TSIOBufferStart(data->psi_buffer);
+ if (block == TS_ERROR_PTR) {
+ TSError("[psi_include] Could not get buffer block");
goto error;
}
- ptr_block = INKIOBufferBlockWriteStart(block, &avail);
- if (ptr_block == INK_ERROR_PTR) {
- INKError("[psi_include] Could not get buffer block");
+ ptr_block = TSIOBufferBlockWriteStart(block, &avail);
+ if (ptr_block == TS_ERROR_PTR) {
+ TSError("[psi_include] Could not get buffer block");
goto error;
}
towrite = MIN(ntodo, avail);
memcpy(ptr_block, buf + ndone, towrite);
- retval = INKIOBufferProduce(data->psi_buffer, towrite);
- if (retval == INK_ERROR) {
- INKError("[psi_include] Could not produce data");
+ retval = TSIOBufferProduce(data->psi_buffer, towrite);
+ if (retval == TS_ERROR) {
+ TSError("[psi_include] Could not produce data");
goto error;
}
ntodo -= towrite;
ndone += towrite;
}
}
- INKfclose(filep);
+ TSfclose(filep);
data->psi_success = 1;
if (log) {
- INKTextLogObjectWrite(log, "Successfully included file: %s", inc_file);
+ TSTextLogObjectWrite(log, "Successfully included file: %s", inc_file);
}
} else {
data->psi_success = 0;
if (log) {
- INKTextLogObjectWrite(log, "Failed to include file: %s", inc_file);
+ TSTextLogObjectWrite(log, "Failed to include file: %s", inc_file);
}
}
@@ -593,14 +593,14 @@ psi_include(INKCont contp, void *edata)
to let it know we're done. */
/* Note: if the blocking call was not in the transformation state (i.e. in
- INK_HTTP_READ_REQUEST_HDR, INK_HTTP_OS_DNS and so on...) we could
- use INKHttpTxnReenable to wake up the transaction instead of sending an event. */
+ TS_HTTP_READ_REQUEST_HDR, TS_HTTP_OS_DNS and so on...) we could
+ use TSHttpTxnReenable to wake up the transaction instead of sending an event. */
error:
- INKContSchedule(contp, 0);
+ TSContSchedule(contp, 0);
data->psi_success = 0;
data->state = STATE_READ_DATA;
- INKMutexUnlock(INKContMutexGet(contp));
+ TSMutexUnlock(TSContMutexGet(contp));
return 0;
}
@@ -618,48 +618,48 @@ error:
1 if success
-------------------------------------------------------------------------*/
static int
-wake_up_streams(INKCont contp)
+wake_up_streams(TSCont contp)
{
- INKVIO input_vio;
+ TSVIO input_vio;
ContData *data;
int ntodo;
- INKReturnCode retval;
+ TSReturnCode retval;
- data = INKContDataGet(contp);
- INKAssert(data->magic == MAGIC_ALIVE);
+ data = TSContDataGet(contp);
+ TSAssert(data->magic == MAGIC_ALIVE);
- input_vio = INKVConnWriteVIOGet(contp);
- if (input_vio == INK_ERROR_PTR) {
- INKError("[wake_up_streams] Error while getting input_vio");
+ input_vio = TSVConnWriteVIOGet(contp);
+ if (input_vio == TS_ERROR_PTR) {
+ TSError("[wake_up_streams] Error while getting input_vio");
return 0;
}
- ntodo = INKVIONTodoGet(input_vio);
- if (ntodo == INK_ERROR) {
- INKError("[wake_up_streams] Error while getting bytes left to read");
+ ntodo = TSVIONTodoGet(input_vio);
+ if (ntodo == TS_ERROR) {
+ TSError("[wake_up_streams] Error while getting bytes left to read");
return 0;
}
if (ntodo > 0) {
- retval = INKVIOReenable(data->output_vio);
- if (retval == INK_ERROR) {
- INKError("[wake_up_streams] Error while reenabling downstream vio");
+ retval = TSVIOReenable(data->output_vio);
+ if (retval == TS_ERROR) {
+ TSError("[wake_up_streams] Error while reenabling downstream vio");
return 0;
}
- INKContCall(INKVIOContGet(input_vio), INK_EVENT_VCONN_WRITE_READY, input_vio);
+ TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
} else {
- INKDebug(DBG_TAG, "Total bytes produced by transform = %d", data->transform_bytes);
- retval = INKVIONBytesSet(data->output_vio, data->transform_bytes);
- if (retval == INK_ERROR) {
- INKError("[wake_up_streams] Error while setting nbytes to downstream vio");
+ TSDebug(DBG_TAG, "Total bytes produced by transform = %d", data->transform_bytes);
+ retval = TSVIONBytesSet(data->output_vio, data->transform_bytes);
+ if (retval == TS_ERROR) {
+ TSError("[wake_up_streams] Error while setting nbytes to downstream vio");
return 0;
}
- retval = INKVIOReenable(data->output_vio);
- if (retval == INK_ERROR) {
- INKError("[wake_up_streams] Error while reenabling downstream vio");
+ retval = TSVIOReenable(data->output_vio);
+ if (retval == TS_ERROR) {
+ TSError("[wake_up_streams] Error while reenabling downstream vio");
return 0;
}
- INKContCall(INKVIOContGet(input_vio), INK_EVENT_VCONN_WRITE_COMPLETE, input_vio);
+ TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
}
return 1;
@@ -682,61 +682,61 @@ wake_up_streams(INKCont contp)
1 if success
-------------------------------------------------------------------------*/
static int
-handle_transform(INKCont contp)
+handle_transform(TSCont contp)
{
- INKVConn output_conn;
- INKVIO input_vio;
+ TSVConn output_conn;
+ TSVIO input_vio;
ContData *data;
- INKIOBufferReader input_reader;
+ TSIOBufferReader input_reader;
int toread, avail, psi, toconsume, towrite;
- INKReturnCode retval;
+ TSReturnCode retval;
/* Get the output (downstream) vconnection where we'll write data to. */
- output_conn = INKTransformOutputVConnGet(contp);
- if (output_conn == INK_ERROR_PTR) {
- INKError("[handle_transform] Error while getting transform VC");
+ output_conn = TSTransformOutputVConnGet(contp);
+ if (output_conn == TS_ERROR_PTR) {
+ TSError("[handle_transform] Error while getting transform VC");
return 1;
}
/* Get upstream vio */
- input_vio = INKVConnWriteVIOGet(contp);
- if (input_vio == INK_ERROR_PTR) {
- INKError("[handle_transform] Error while getting input vio");
+ input_vio = TSVConnWriteVIOGet(contp);
+ if (input_vio == TS_ERROR_PTR) {
+ TSError("[handle_transform] Error while getting input vio");
return 1;
}
- data = INKContDataGet(contp);
- INKAssert(data->magic == MAGIC_ALIVE);
+ data = TSContDataGet(contp);
+ TSAssert(data->magic == MAGIC_ALIVE);
if (!data->output_buffer) {
- data->output_buffer = INKIOBufferCreate();
- data->output_reader = INKIOBufferReaderAlloc(data->output_buffer);
+ data->output_buffer = TSIOBufferCreate();
+ data->output_reader = TSIOBufferReaderAlloc(data->output_buffer);
/* INT_MAX because we don't know yet how much bytes we'll produce */
- data->output_vio = INKVConnWrite(output_conn, contp, data->output_reader, INT_MAX);
+ data->output_vio = TSVConnWrite(output_conn, contp, data->output_reader, INT_MAX);
- if (data->output_vio == INK_ERROR_PTR) {
- INKError("[handle_transform] Error while writing to downstream VC");
+ if (data->output_vio == TS_ERROR_PTR) {
+ TSError("[handle_transform] Error while writing to downstream VC");
return 0;
}
}
/* If the input VIO's buffer is NULL, the transformation is over */
- if (!INKVIOBufferGet(input_vio)) {
- INKDebug(DBG_TAG, "input_vio NULL, terminating transformation");
- INKVIONBytesSet(data->output_vio, data->transform_bytes);
- INKVIOReenable(data->output_vio);
+ if (!TSVIOBufferGet(input_vio)) {
+ TSDebug(DBG_TAG, "input_vio NULL, terminating transformation");
+ TSVIONBytesSet(data->output_vio, data->transform_bytes);
+ TSVIOReenable(data->output_vio);
return 1;
}
/* Determine how much data we have left to read. */
- toread = INKVIONTodoGet(input_vio);
+ toread = TSVIONTodoGet(input_vio);
if (toread > 0) {
- input_reader = INKVIOReaderGet(input_vio);
- avail = INKIOBufferReaderAvail(input_reader);
- if (avail == INK_ERROR) {
- INKError("[handle_transform] Error while getting number of bytes available");
+ input_reader = TSVIOReaderGet(input_vio);
+ avail = TSIOBufferReaderAvail(input_reader);
+ if (avail == TS_ERROR) {
+ TSError("[handle_transform] Error while getting number of bytes available");
return 0;
}
@@ -758,32 +758,32 @@ handle_transform(INKCont contp)
data->transform_bytes += towrite;
/* Copy the data from the read buffer to the output buffer. */
- retval = INKIOBufferCopy(INKVIOBufferGet(data->output_vio), INKVIOReaderGet(input_vio), towrite, 0);
- if (retval == INK_ERROR) {
- INKError("[handle_transform] Error while copying bytes to output VC");
+ retval = TSIOBufferCopy(TSVIOBufferGet(data->output_vio), TSVIOReaderGet(input_vio), towrite, 0);
+ if (retval == TS_ERROR) {
+ TSError("[handle_transform] Error while copying bytes to output VC");
return 0;
}
/* Reenable the output connection so it can read the data we've produced. */
- retval = INKVIOReenable(data->output_vio);
- if (retval == INK_ERROR) {
- INKError("[handle_transform] Error while reenabling output VC");
+ retval = TSVIOReenable(data->output_vio);
+ if (retval == TS_ERROR) {
+ TSError("[handle_transform] Error while reenabling output VC");
return 0;
}
}
if (toconsume > 0) {
/* Consume data we've processed an we are no longer interested in */
- retval = INKIOBufferReaderConsume(input_reader, toconsume);
- if (retval == INK_ERROR) {
- INKError("[handle_transform] Error while consuming data from upstream VC");
+ retval = TSIOBufferReaderConsume(input_reader, toconsume);
+ if (retval == TS_ERROR) {
+ TSError("[handle_transform] Error while consuming data from upstream VC");
return 0;
}
/* Modify the input VIO to reflect how much data we've completed. */
- retval = INKVIONDoneSet(input_vio, INKVIONDoneGet(input_vio) + toconsume);
- if (retval == INK_ERROR) {
- INKError("[handle_transform] Error while setting ndone on upstream VC");
+ retval = TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + toconsume);
+ if (retval == TS_ERROR) {
+ TSError("[handle_transform] Error while setting ndone on upstream VC");
return 0;
}
}
@@ -793,7 +793,7 @@ handle_transform(INKCont contp)
Job *new_job;
/* Add a request to include a file into the jobs queue.. */
/* We'll be called back once it's done with an EVENT_IMMEDIATE */
- INKDebug(DBG_TAG, "Psi filename extracted. Adding an include job to thread queue.");
+ TSDebug(DBG_TAG, "Psi filename extracted. Adding an include job to thread queue.");
data->state = STATE_READ_PSI;
/* Create a new job request and add it to the queue */
@@ -827,51 +827,51 @@ handle_transform(INKCont contp)
1 if success
-------------------------------------------------------------------------*/
static int
-dump_psi(INKCont contp)
+dump_psi(TSCont contp)
{
ContData *data;
int psi_output_len;
- INKVIO input_vio;
- INKReturnCode retval;
+ TSVIO input_vio;
+ TSReturnCode retval;
- input_vio = INKVConnWriteVIOGet(contp);
- if (input_vio == INK_ERROR_PTR) {
- INKError("[dump_psi] Error while getting input vio");
+ input_vio = TSVConnWriteVIOGet(contp);
+ if (input_vio == TS_ERROR_PTR) {
+ TSError("[dump_psi] Error while getting input vio");
return 1;
}
- data = INKContDataGet(contp);
- INKAssert(data->magic == MAGIC_ALIVE);
+ data = TSContDataGet(contp);
+ TSAssert(data->magic == MAGIC_ALIVE);
/* If script exec succeded, copy its output to the downstream vconn */
if (data->psi_success == 1) {
- psi_output_len = INKIOBufferReaderAvail(data->psi_reader);
- if (psi_output_len == INK_ERROR) {
- INKError("[dump_psi] Error while getting available bytes from reader");
+ psi_output_len = TSIOBufferReaderAvail(data->psi_reader);
+ if (psi_output_len == TS_ERROR) {
+ TSError("[dump_psi] Error while getting available bytes from reader");
return 1;
}
if (psi_output_len > 0) {
data->transform_bytes += psi_output_len;
- INKDebug(DBG_TAG, "Inserting %d bytes from include file", psi_output_len);
- retval = INKIOBufferCopy(INKVIOBufferGet(data->output_vio), data->psi_reader, psi_output_len, 0);
- if (retval == INK_ERROR) {
- INKError("[dump_psi] Error while copying include bytes to downstream VC");
+ TSDebug(DBG_TAG, "Inserting %d bytes from include file", psi_output_len);
+ retval = TSIOBufferCopy(TSVIOBufferGet(data->output_vio), data->psi_reader, psi_output_len, 0);
+ if (retval == TS_ERROR) {
+ TSError("[dump_psi] Error while copying include bytes to downstream VC");
return 1;
}
/* Consume all the output data */
- retval = INKIOBufferReaderConsume(data->psi_reader, psi_output_len);
- if (retval == INK_ERROR) {
- INKError("[dump_psi] Error while consuming data from buffer");
+ retval = TSIOBufferReaderConsume(data->psi_reader, psi_output_len);
+ if (retval == TS_ERROR) {
+ TSError("[dump_psi] Error while consuming data from buffer");
return 1;
}
/* Reenable the output connection so it can read the data we've produced. */
- retval = INKVIOReenable(data->output_vio);
- if (retval == INK_ERROR) {
- INKError("[dump_psi] Error while reenabling output VIO");
+ retval = TSVIOReenable(data->output_vio);
+ if (retval == TS_ERROR) {
+ TSError("[dump_psi] Error while reenabling output VIO");
return 1;
}
}
@@ -895,66 +895,66 @@ dump_psi(INKCont contp)
Return Value:
-------------------------------------------------------------------------*/
static int
-transform_handler(INKCont contp, INKEvent event, void *edata)
+transform_handler(TSCont contp, TSEvent event, void *edata)
{
- INKVIO input_vio;
+ TSVIO input_vio;
ContData *data;
int state, lock, retval;
/* This section will be called by both TS internal
and the thread. Protect it with a mutex to avoid
concurrent calls. */
- INKMutexLockTry(INKContMutexGet(contp), &lock);
+ TSMutexLockTry(TSContMutexGet(contp), &lock);
/* Handle TryLock result */
if (!lock) {
- INKCont c = INKContCreate(trylock_handler, NULL);
- TryLockData *d = INKmalloc(sizeof(TryLockData));
+ TSCont c = TSContCreate(trylock_handler, NULL);
+ TryLockData *d = TSmalloc(sizeof(TryLockData));
d->contp = contp;
d->event = event;
- INKContDataSet(c, d);
- INKContSchedule(c, 10);
+ TSContDataSet(c, d);
+ TSContSchedule(c, 10);
return 1;
}
- data = INKContDataGet(contp);
- INKAssert(data->magic == MAGIC_ALIVE);
+ data = TSContDataGet(contp);
+ TSAssert(data->magic == MAGIC_ALIVE);
state = data->state;
/* Check to see if the transformation has been closed */
- retval = INKVConnClosedGet(contp);
- if (retval == INK_ERROR) {
- INKError("[transform_handler] Error while getting close status of transformation");
+ retval = TSVConnClosedGet(contp);
+ if (retval == TS_ERROR) {
+ TSError("[transform_handler] Error while getting close status of transformation");
}
if (retval) {
/* If the thread is still executing its job, we don't want to destroy
the continuation right away as the thread will call us back
on this continuation. */
if (state == STATE_READ_PSI) {
- INKContSchedule(contp, 10);
+ TSContSchedule(contp, 10);
} else {
- INKMutexUnlock(INKContMutexGet(contp));
- cont_data_destroy(INKContDataGet(contp));
- INKContDestroy(contp);
+ TSMutexUnlock(TSContMutexGet(contp));
+ cont_data_destroy(TSContDataGet(contp));
+ TSContDestroy(contp);
return 1;
}
} else {
switch (event) {
- case INK_EVENT_ERROR:
- input_vio = INKVConnWriteVIOGet(contp);
- if (input_vio == INK_ERROR_PTR) {
- INKError("[transform_handler] Error while getting upstream vio");
+ case TS_EVENT_ERROR:
+ input_vio = TSVConnWriteVIOGet(contp);
+ if (input_vio == TS_ERROR_PTR) {
+ TSError("[transform_handler] Error while getting upstream vio");
} else {
- INKContCall(INKVIOContGet(input_vio), INK_EVENT_ERROR, input_vio);
+ TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
}
break;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- INKVConnShutdown(INKTransformOutputVConnGet(contp), 0, 1);
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
break;
- case INK_EVENT_VCONN_WRITE_READY:
+ case TS_EVENT_VCONN_WRITE_READY:
/* downstream vconnection is done reading data we've write into it.
let's read some more data from upstream if we're in read state. */
if (state == STATE_READ_DATA) {
@@ -962,7 +962,7 @@ transform_handler(INKCont contp, INKEven
}
break;
- case INK_EVENT_IMMEDIATE:
+ case TS_EVENT_IMMEDIATE:
if (state == STATE_READ_DATA) {
/* upstream vconnection signals some more data ready to be read
let's try to transform some more data */
@@ -977,18 +977,18 @@ transform_handler(INKCont contp, INKEven
break;
default:
- INKAssert(!"Unexpected event");
+ TSAssert(!"Unexpected event");
break;
}
}
- INKMutexUnlock(INKContMutexGet(contp));
+ TSMutexUnlock(TSContMutexGet(contp));
return 1;
}
/*-------------------------------------------------------------------------
trylock_handler
- Small handler to handle INKMutexLockTry failures
+ Small handler to handle TSMutexLockTry failures
Input:
contp continuation for the current transaction
@@ -998,12 +998,12 @@ transform_handler(INKCont contp, INKEven
Return Value:
-------------------------------------------------------------------------*/
static int
-trylock_handler(INKCont contp, INKEvent event, void *edata)
+trylock_handler(TSCont contp, TSEvent event, void *edata)
{
- TryLockData *data = INKContDataGet(contp);
+ TryLockData *data = TSContDataGet(contp);
transform_handler(data->contp, data->event, NULL);
- INKfree(data);
- INKContDestroy(contp);
+ TSfree(data);
+ TSContDestroy(contp);
return 0;
}
@@ -1020,57 +1020,57 @@ trylock_handler(INKCont contp, INKEvent
0 if not
-------------------------------------------------------------------------*/
static int
-transformable(INKHttpTxn txnp)
+transformable(TSHttpTxn txnp)
{
/* We are only interested in transforming "200 OK" responses
with a Content-Type: text/ header and with X-Psi header */
- INKMBuffer bufp;
- INKMLoc hdr_loc, field_loc;
- INKHttpStatus resp_status;
+ TSMBuffer bufp;
+ TSMLoc hdr_loc, field_loc;
+ TSHttpStatus resp_status;
const char *value;
- INKHttpTxnServerRespGet(txnp, &bufp, &hdr_loc);
+ TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc);
- resp_status = INKHttpHdrStatusGet(bufp, hdr_loc);
- if (resp_status == (INKHttpStatus)INK_ERROR) {
- INKError("[transformable] Error while getting http status");
+ resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
+ if (resp_status == (TSHttpStatus)TS_ERROR) {
+ TSError("[transformable] Error while getting http status");
}
- if ((resp_status == (INKHttpStatus)INK_ERROR) || (resp_status != INK_HTTP_STATUS_OK)) {
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ if ((resp_status == (TSHttpStatus)TS_ERROR) || (resp_status != TS_HTTP_STATUS_OK)) {
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
- field_loc = INKMimeHdrFieldFind(bufp, hdr_loc, INK_MIME_FIELD_CONTENT_TYPE, -1);
- if (field_loc == INK_ERROR_PTR) {
- INKError("[transformable] Error while searching Content-Type field");
+ field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, TS_MIME_FIELD_CONTENT_TYPE, -1);
+ if (field_loc == TS_ERROR_PTR) {
+ TSError("[transformable] Error while searching Content-Type field");
}
- if ((field_loc == INK_ERROR_PTR) || (field_loc == NULL)) {
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ if ((field_loc == TS_ERROR_PTR) || (field_loc == NULL)) {
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
- if (INKMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, 0, &value, NULL) == INK_ERROR) {
- INKError("[transformable] Error while getting Content-Type field value");
+ if (TSMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, 0, &value, NULL) == TS_ERROR) {
+ TSError("[transformable] Error while getting Content-Type field value");
}
- if ((value == INK_ERROR_PTR) || (value == NULL) || (strncasecmp(value, "text/", sizeof("text/") - 1) != 0)) {
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ if ((value == TS_ERROR_PTR) || (value == NULL) || (strncasecmp(value, "text/", sizeof("text/") - 1) != 0)) {
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
- field_loc = INKMimeHdrFieldFind(bufp, hdr_loc, MIME_FIELD_XPSI, -1);
- if (value == INK_ERROR_PTR) {
- INKError("[transformable] Error while searching XPSI field");
+ field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, MIME_FIELD_XPSI, -1);
+ if (value == TS_ERROR_PTR) {
+ TSError("[transformable] Error while searching XPSI field");
}
- if ((value == INK_ERROR_PTR) || (field_loc == NULL)) {
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ if ((value == TS_ERROR_PTR) || (field_loc == NULL)) {
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 0;
}
- INKHandleMLocRelease(bufp, hdr_loc, field_loc);
- INKHandleMLocRelease(bufp, INK_NULL_MLOC, hdr_loc);
+ TSHandleMLocRelease(bufp, hdr_loc, field_loc);
+ TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
return 1;
}
@@ -1087,24 +1087,24 @@ transformable(INKHttpTxn txnp)
0 if not
-------------------------------------------------------------------------*/
static int
-transform_add(INKHttpTxn txnp)
+transform_add(TSHttpTxn txnp)
{
- INKCont contp;
+ TSCont contp;
ContData *data;
- INKReturnCode retval;
+ TSReturnCode retval;
- contp = INKTransformCreate(transform_handler, txnp);
- if (contp == INK_ERROR_PTR) {
- INKError("[transform_add] Error while creating a new transformation");
+ contp = TSTransformCreate(transform_handler, txnp);
+ if (contp == TS_ERROR_PTR) {
+ TSError("[transform_add] Error while creating a new transformation");
return 0;
}
data = cont_data_alloc();
- INKContDataSet(contp, data);
+ TSContDataSet(contp, data);
- retval = INKHttpTxnHookAdd(txnp, INK_HTTP_RESPONSE_TRANSFORM_HOOK, contp);
- if (retval == INK_ERROR) {
- INKError("[transform_add] Error registering to transform hook");
+ retval = TSHttpTxnHookAdd(txnp, TS_HTTP_RESPONSE_TRANSFORM_HOOK, contp);
+ if (retval == TS_ERROR) {
+ TSError("[transform_add] Error registering to transform hook");
return 0;
}
return 1;
@@ -1122,17 +1122,17 @@ transform_add(INKHttpTxn txnp)
Return Value:
-------------------------------------------------------------------------*/
static int
-read_response_handler(INKCont contp, INKEvent event, void *edata)
+read_response_handler(TSCont contp, TSEvent event, void *edata)
{
- INKHttpTxn txnp = (INKHttpTxn) edata;
+ TSHttpTxn txnp = (TSHttpTxn) edata;
switch (event) {
- case INK_EVENT_HTTP_READ_RESPONSE_HDR:
+ case TS_EVENT_HTTP_READ_RESPONSE_HDR:
if (transformable(txnp)) {
- INKDebug(DBG_TAG, "Add a transformation");
+ TSDebug(DBG_TAG, "Add a transformation");
transform_add(txnp);
}
- INKHttpTxnReenable(txnp, INK_EVENT_HTTP_CONTINUE);
+ TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
return 0;
default:
break;
@@ -1156,7 +1156,7 @@ int
check_ts_version()
{
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
int result = 0;
if (ts_version) {
@@ -1179,7 +1179,7 @@ check_ts_version()
/*-------------------------------------------------------------------------
- INKPluginInit
+ TSPluginInit
Function called at plugin init time
Input:
@@ -1189,32 +1189,32 @@ check_ts_version()
Return Value:
-------------------------------------------------------------------------*/
void
-INKPluginInit(int argc, const char *argv[])
+TSPluginInit(int argc, const char *argv[])
{
- INKPluginRegistrationInfo info;
+ TSPluginRegistrationInfo info;
int i;
- INKReturnCode retval;
+ TSReturnCode retval;
info.plugin_name = "psi";
info.vendor_name = "Apache";
info.support_email = "";
- 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;
}
/* Initialize the psi directory = <plugin_path>/include */
- sprintf(psi_directory, "%s/%s", INKPluginDirGet(), PSI_PATH);
+ sprintf(psi_directory, "%s/%s", TSPluginDirGet(), PSI_PATH);
- /* create an INKTextLogObject to log any psi include */
- retval = INKTextLogObjectCreate("psi", INK_LOG_MODE_ADD_TIMESTAMP, &log);
- if (retval == INK_ERROR) {
- INKError("Failed creating log for psi plugin");
+ /* create an TSTextLogObject to log any psi include */
+ retval = TSTextLogObjectCreate("psi", TS_LOG_MODE_ADD_TIMESTAMP, &log);
+ if (retval == TS_ERROR) {
+ TSError("Failed creating log for psi plugin");
log = NULL;
}
@@ -1223,19 +1223,19 @@ INKPluginInit(int argc, const char *argv
init_queue(&job_queue);
for (i = 0; i < NB_THREADS; i++) {
- char *thread_name = (char *) INKmalloc(64);
+ char *thread_name = (char *) TSmalloc(64);
sprintf(thread_name, "Thread[%d]", i);
- if (!INKThreadCreate((INKThreadFunc) thread_loop, thread_name)) {
- INKError("[INKPluginInit] Error while creating threads");
+ if (!TSThreadCreate((TSThreadFunc) thread_loop, thread_name)) {
+ TSError("[TSPluginInit] Error while creating threads");
return;
}
}
- retval = INKHttpHookAdd(INK_HTTP_READ_RESPONSE_HDR_HOOK, INKContCreate(read_response_handler, INKMutexCreate()));
- if (retval == INK_ERROR) {
- INKError("[INKPluginInit] Error while registering to read response hook");
+ retval = TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(read_response_handler, TSMutexCreate()));
+ if (retval == TS_ERROR) {
+ TSError("[TSPluginInit] Error while registering to read response hook");
return;
}
- INKDebug(DBG_TAG, "Plugin started");
+ TSDebug(DBG_TAG, "Plugin started");
}
Modified: trafficserver/traffic/trunk/example/thread-pool/test/SDKTest/psi_server.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/thread-pool/test/SDKTest/psi_server.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/thread-pool/test/SDKTest/psi_server.c (original)
+++ trafficserver/traffic/trunk/example/thread-pool/test/SDKTest/psi_server.c Tue Nov 16 20:22:02 2010
@@ -80,7 +80,7 @@ generate_psibility()
void
-INKOptionsProcess(char *option, char *value)
+TSOptionsProcess(char *option, char *value)
{
if (strcmp(option, "psi_ratio") == 0) {
fprintf(stderr, "psi ratio set to %d %%\n", atoi(value));
@@ -90,17 +90,17 @@ INKOptionsProcess(char *option, char *va
void
-INKPluginInit()
+TSPluginInit()
{
fprintf(stderr, "*** PSI Server ***\n");
- INKFuncRegister(INK_FID_OPTIONS_PROCESS);
- INKFuncRegister(INK_FID_RESPONSE_PREPARE);
- INKFuncRegister(INK_FID_RESPONSE_PUT);
+ TSFuncRegister(TS_FID_OPTIONS_PROCESS);
+ TSFuncRegister(TS_FID_RESPONSE_PREPARE);
+ TSFuncRegister(TS_FID_RESPONSE_PUT);
}
/* prepare response header for a request */
int
-INKResponsePrepare(char *req_hdr, int req_len, void **response_id)
+TSResponsePrepare(char *req_hdr, int req_len, void **response_id)
{
char *len_string;
RequestInfo *resp_id = (RequestInfo *) malloc(sizeof(RequestInfo));
@@ -134,7 +134,7 @@ INKResponsePrepare(char *req_hdr, int re
/* put response (response header + response document) into buffer */
void
-INKResponsePut(void **resp_id /* return */ ,
+TSResponsePut(void **resp_id /* return */ ,
void *resp_buffer /* return */ ,
int *resp_bytes /* return */ ,
int resp_buffer_size, int bytes_last_response)
@@ -187,7 +187,7 @@ INKResponsePut(void **resp_id /* return
}
}
/* return NULL as the resp_id to indicate
- * if it is the last INKResponsePut call */
+ * if it is the last TSResponsePut call */
if (rid->bytes_not_sent <= 0 || rid->status_code != 200) {
free(rid);
*((RequestInfo **) resp_id) = NULL;
Modified: trafficserver/traffic/trunk/example/thread-pool/thread.c
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/thread-pool/thread.c?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/thread-pool/thread.c (original)
+++ trafficserver/traffic/trunk/example/thread-pool/thread.c Tue Nov 16 20:22:02 2010
@@ -46,7 +46,7 @@ init_queue(Queue * q)
q->head = NULL; /* Pointer on head cell */
q->tail = NULL; /* Pointer on tail cell */
q->nb_elem = 0; /* Nb elem in the queue */
- q->mutex = INKMutexCreate();
+ q->mutex = TSMutexCreate();
}
void
@@ -56,9 +56,9 @@ add_to_queue(Queue * q, void *data)
int n;
if (data != NULL) {
- INKMutexLock(q->mutex);
+ TSMutexLock(q->mutex);
/* Init the new cell */
- new_cell = INKmalloc(sizeof(Cell));
+ new_cell = TSmalloc(sizeof(Cell));
new_cell->magic = MAGIC_ALIVE;
new_cell->ptr_data = data;
new_cell->ptr_next = q->tail;
@@ -66,20 +66,20 @@ add_to_queue(Queue * q, void *data)
/* Add this new cell to the queue */
if (q->tail == NULL) {
- INKAssert(q->head == NULL);
- INKAssert(q->nb_elem == 0);
+ TSAssert(q->head == NULL);
+ TSAssert(q->nb_elem == 0);
q->tail = new_cell;
q->head = new_cell;
} else {
- INKAssert(q->tail->magic == MAGIC_ALIVE);
+ TSAssert(q->tail->magic == MAGIC_ALIVE);
q->tail->ptr_prev = new_cell;
q->tail = new_cell;
}
n = q->nb_elem++;
- INKMutexUnlock(q->mutex);
+ TSMutexUnlock(q->mutex);
if (n > MAX_JOBS_ALARM) {
- INKError("Warning:Too many jobs in plugin thread pool queue (%d). Maximum allowed is %d", n, MAX_JOBS_ALARM);
+ TSError("Warning:Too many jobs in plugin thread pool queue (%d). Maximum allowed is %d", n, MAX_JOBS_ALARM);
}
}
}
@@ -90,28 +90,28 @@ remove_from_queue(Queue * q)
void *data = NULL;
Cell *remove_cell;
- INKMutexLock(q->mutex);
+ TSMutexLock(q->mutex);
if (q->nb_elem > 0) {
remove_cell = q->head;
- INKAssert(remove_cell->magic == MAGIC_ALIVE);
+ TSAssert(remove_cell->magic == MAGIC_ALIVE);
data = remove_cell->ptr_data;
q->head = remove_cell->ptr_prev;
if (q->head == NULL) {
- INKAssert(q->nb_elem == 1);
+ TSAssert(q->nb_elem == 1);
q->tail = NULL;
} else {
- INKAssert(q->head->magic == MAGIC_ALIVE);
+ TSAssert(q->head->magic == MAGIC_ALIVE);
q->head->ptr_next = NULL;
}
remove_cell->magic = MAGIC_DEAD;
- INKfree(remove_cell);
+ TSfree(remove_cell);
q->nb_elem--;
}
- INKMutexUnlock(q->mutex);
+ TSMutexUnlock(q->mutex);
return data;
}
@@ -119,19 +119,19 @@ int
get_nbelem_queue(Queue * q)
{
int nb;
- INKMutexLock(q->mutex);
+ TSMutexLock(q->mutex);
nb = q->nb_elem;
- INKMutexUnlock(q->mutex);
+ TSMutexUnlock(q->mutex);
return nb;
}
Job *
-job_create(INKCont contp, ExecFunc func, void *data)
+job_create(TSCont contp, ExecFunc func, void *data)
{
Job *new_job;
- new_job = INKmalloc(sizeof(Job));
+ new_job = TSmalloc(sizeof(Job));
new_job->magic = MAGIC_ALIVE;
new_job->cont = contp;
new_job->func = func;
@@ -143,7 +143,7 @@ void
job_delete(Job * job)
{
job->magic = MAGIC_DEAD;
- INKfree(job);
+ TSfree(job);
}
void
@@ -171,7 +171,7 @@ thread_loop(void *arg)
job_todo = remove_from_queue(&job_queue);
if (job_todo != NULL) {
- INKAssert(job_todo->magic == MAGIC_ALIVE);
+ TSAssert(job_todo->magic == MAGIC_ALIVE);
/* Simply execute the job function */
job_todo->func(job_todo->cont, job_todo->data);
Modified: trafficserver/traffic/trunk/example/thread-pool/thread.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/example/thread-pool/thread.h?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/example/thread-pool/thread.h (original)
+++ trafficserver/traffic/trunk/example/thread-pool/thread.h Tue Nov 16 20:22:02 2010
@@ -33,13 +33,13 @@
will log error messages. This should be tuned based on your application */
#define MAX_JOBS_ALARM 1000
-typedef int (*ExecFunc) (INKCont, void *);
+typedef int (*ExecFunc) (TSCont, void *);
/* Structure that contains all information for a job execution */
typedef struct
{
unsigned int magic;
- INKCont cont; /* Continuation to call once job is done */
+ TSCont cont; /* Continuation to call once job is done */
ExecFunc func; /* Job function */
void *data; /* Any data to pass to the job function */
} Job;
@@ -59,7 +59,7 @@ typedef struct
Cell *head;
Cell *tail;
int nb_elem;
- INKMutex mutex;
+ TSMutex mutex;
} Queue;
@@ -74,7 +74,7 @@ int get_nbelem_queue(Queue * q);
/* Job functions */
-Job *job_create(INKCont contp, ExecFunc func, void *data);
+Job *job_create(TSCont contp, ExecFunc func, void *data);
void job_delete(Job * job);
Modified: trafficserver/traffic/trunk/iocore/cache/Cache.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/cache/Cache.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/cache/Cache.cc (original)
+++ trafficserver/traffic/trunk/iocore/cache/Cache.cc Tue Nov 16 20:22:02 2010
@@ -111,18 +111,18 @@ int CacheVC::size_to_init = -1;
CacheKey zero_key(0, 0);
void verify_cache_api() {
- ink_assert((int)INK_EVENT_CACHE_OPEN_READ == (int)CACHE_EVENT_OPEN_READ);
- ink_assert((int)INK_EVENT_CACHE_OPEN_READ_FAILED == (int)CACHE_EVENT_OPEN_READ_FAILED);
- ink_assert((int)INK_EVENT_CACHE_OPEN_WRITE == (int)CACHE_EVENT_OPEN_WRITE);
- ink_assert((int)INK_EVENT_CACHE_OPEN_WRITE_FAILED == (int)CACHE_EVENT_OPEN_WRITE_FAILED);
- ink_assert((int)INK_EVENT_CACHE_REMOVE == (int)CACHE_EVENT_REMOVE);
- ink_assert((int)INK_EVENT_CACHE_REMOVE_FAILED == (int)CACHE_EVENT_REMOVE_FAILED);
- ink_assert((int)INK_EVENT_CACHE_SCAN == (int)CACHE_EVENT_SCAN);
- ink_assert((int)INK_EVENT_CACHE_SCAN_FAILED == (int)CACHE_EVENT_SCAN_FAILED);
- ink_assert((int)INK_EVENT_CACHE_SCAN_OBJECT == (int)CACHE_EVENT_SCAN_OBJECT);
- ink_assert((int)INK_EVENT_CACHE_SCAN_OPERATION_BLOCKED == (int)CACHE_EVENT_SCAN_OPERATION_BLOCKED);
- ink_assert((int)INK_EVENT_CACHE_SCAN_OPERATION_FAILED == (int)CACHE_EVENT_SCAN_OPERATION_FAILED);
- ink_assert((int)INK_EVENT_CACHE_SCAN_DONE == (int)CACHE_EVENT_SCAN_DONE);
+ ink_assert((int)TS_EVENT_CACHE_OPEN_READ == (int)CACHE_EVENT_OPEN_READ);
+ ink_assert((int)TS_EVENT_CACHE_OPEN_READ_FAILED == (int)CACHE_EVENT_OPEN_READ_FAILED);
+ ink_assert((int)TS_EVENT_CACHE_OPEN_WRITE == (int)CACHE_EVENT_OPEN_WRITE);
+ ink_assert((int)TS_EVENT_CACHE_OPEN_WRITE_FAILED == (int)CACHE_EVENT_OPEN_WRITE_FAILED);
+ ink_assert((int)TS_EVENT_CACHE_REMOVE == (int)CACHE_EVENT_REMOVE);
+ ink_assert((int)TS_EVENT_CACHE_REMOVE_FAILED == (int)CACHE_EVENT_REMOVE_FAILED);
+ ink_assert((int)TS_EVENT_CACHE_SCAN == (int)CACHE_EVENT_SCAN);
+ ink_assert((int)TS_EVENT_CACHE_SCAN_FAILED == (int)CACHE_EVENT_SCAN_FAILED);
+ ink_assert((int)TS_EVENT_CACHE_SCAN_OBJECT == (int)CACHE_EVENT_SCAN_OBJECT);
+ ink_assert((int)TS_EVENT_CACHE_SCAN_OPERATION_BLOCKED == (int)CACHE_EVENT_SCAN_OPERATION_BLOCKED);
+ ink_assert((int)TS_EVENT_CACHE_SCAN_OPERATION_FAILED == (int)CACHE_EVENT_SCAN_OPERATION_FAILED);
+ ink_assert((int)TS_EVENT_CACHE_SCAN_DONE == (int)CACHE_EVENT_SCAN_DONE);
}
struct PartInitInfo
@@ -2753,7 +2753,7 @@ CacheProcessor::open_read(Continuation *
#endif
if (cache_global_hooks != NULL && cache_global_hooks->hooks_set > 0) {
Debug("cache_plugin", "[CacheProcessor::open_read] Cache hooks are set");
- APIHook *cache_lookup = cache_global_hooks->get(INK_CACHE_PLUGIN_HOOK);
+ APIHook *cache_lookup = cache_global_hooks->get(TS_CACHE_PLUGIN_HOOK);
if (cache_lookup != NULL) {
HttpCacheSM *sm = (HttpCacheSM *) cont;
@@ -2770,8 +2770,8 @@ CacheProcessor::open_read(Continuation *
sm->master_sm->t_state.cache_vc = vc;
}
//vc->setCtrlInPlugin(true);
- int rval = cache_lookup->invoke(INK_EVENT_CACHE_LOOKUP, (void *) vc);
- if (rval == INK_SUCCESS) {
+ int rval = cache_lookup->invoke(TS_EVENT_CACHE_LOOKUP, (void *) vc);
+ if (rval == TS_SUCCESS) {
return ACTION_RESULT_DONE;
} else {
abort();
@@ -2841,14 +2841,14 @@ CacheProcessor::remove(Continuation *con
#endif
if (cache_global_hooks != NULL && cache_global_hooks->hooks_set > 0) {
DDebug("cache_plugin", "[CacheProcessor::remove] Cache hooks are set");
- APIHook *cache_lookup = cache_global_hooks->get(INK_CACHE_PLUGIN_HOOK);
+ APIHook *cache_lookup = cache_global_hooks->get(TS_CACHE_PLUGIN_HOOK);
if (cache_lookup != NULL) {
NewCacheVC *vc = NewCacheVC::alloc(cont, url, NULL);
- int rval = cache_lookup->invoke(INK_EVENT_CACHE_DELETE, (void *) vc);
+ int rval = cache_lookup->invoke(TS_EVENT_CACHE_DELETE, (void *) vc);
if (vc) {
vc->free();
}
- if (rval == INK_SUCCESS) {
+ if (rval == TS_SUCCESS) {
return ACTION_RESULT_DONE;
} else {
abort();
Modified: trafficserver/traffic/trunk/iocore/cache/CachePages.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/cache/CachePages.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/cache/CachePages.cc (original)
+++ trafficserver/traffic/trunk/iocore/cache/CachePages.cc Tue Nov 16 20:22:02 2010
@@ -75,8 +75,8 @@ struct ShowCache: public ShowCont
unescapifyStr(query);
- INKDebug("cache_inspector", "query params: %s [unescaped]", unescapedQuery);
- INKDebug("cache_inspector", "query params: %s [escaped]", query);
+ Debug("cache_inspector", "query params: %s [unescaped]", unescapedQuery);
+ Debug("cache_inspector", "query params: %s [escaped]", query);
// remove 'C-m' s
int l, m;
for (l = 0, m = 0; l < query_len; l++)
@@ -121,13 +121,13 @@ struct ShowCache: public ShowCont
}
}
- INKDebug("cache_inspector", "there were %d url(s) passed in", nstrings == 1 ? 1 : nstrings - 1);
+ Debug("cache_inspector", "there were %d url(s) passed in", nstrings == 1 ? 1 : nstrings - 1);
for (int i = 0; i < nstrings; i++) {
if (show_cache_urlstrs[i][0] == '\0')
continue;
unescapifyStr(show_cache_urlstrs[i]);
- INKDebug("cache_inspector", "URL %d: %s", i + 1, &show_cache_urlstrs[i]);
+ Debug("cache_inspector", "URL %d: %s", i + 1, &show_cache_urlstrs[i]);
}
}
Modified: trafficserver/traffic/trunk/iocore/cache/NewCacheVC.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/cache/NewCacheVC.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/cache/NewCacheVC.cc (original)
+++ trafficserver/traffic/trunk/iocore/cache/NewCacheVC.cc Tue Nov 16 20:22:02 2010
@@ -168,7 +168,7 @@ NewCacheVC::handleRead(int event, Event
cancel_trigger();
if (!closed)
- _cacheReadHook->invoke(INK_EVENT_CACHE_READ, this);
+ _cacheReadHook->invoke(TS_EVENT_CACHE_READ, this);
return 1;
}
@@ -215,7 +215,7 @@ NewCacheVC::do_io_write(Continuation * c
_vio.vc_server = this;
ink_assert(c->mutex->thread_holding);
- //_cacheWriteHook->invoke(INK_EVENT_CACHE_OPEN_WRITE, this);
+ //_cacheWriteHook->invoke(TS_EVENT_CACHE_OPEN_WRITE, this);
SET_HANDLER(&NewCacheVC::handleWrite);
if (!trigger) {
@@ -235,7 +235,7 @@ NewCacheVC::handleWrite(int event, Event
cancel_trigger();
if (!closed)
- _cacheWriteHook->invoke(INK_EVENT_CACHE_WRITE, this);
+ _cacheWriteHook->invoke(TS_EVENT_CACHE_WRITE, this);
return 1;
}
@@ -259,8 +259,8 @@ NewCacheVC::alloc(Continuation * cont, U
c->_lookupUrl = url;
c->_url = url->string_get_ref(&c->_url_length);
c->_sm = sm;
- c->_cacheWriteHook = cache_global_hooks->get(INK_CACHE_PLUGIN_HOOK);
- c->_cacheReadHook = cache_global_hooks->get(INK_CACHE_PLUGIN_HOOK);
+ c->_cacheWriteHook = cache_global_hooks->get(TS_CACHE_PLUGIN_HOOK);
+ c->_cacheReadHook = cache_global_hooks->get(TS_CACHE_PLUGIN_HOOK);
return c;
}
@@ -296,7 +296,7 @@ NewCacheVC::do_io_close(int lerrno)
if (_vio.op == VIO::WRITE) {
// do_io_close without set_http_info is a delete
- _cacheWriteHook->invoke(INK_EVENT_CACHE_DELETE, this);
+ _cacheWriteHook->invoke(TS_EVENT_CACHE_DELETE, this);
}
break;
@@ -403,7 +403,7 @@ NewCacheVC::handleLookup(int event, Even
cancel_trigger();
if (!closed)
- _cacheReadHook->invoke(INK_EVENT_CACHE_LOOKUP, this);
+ _cacheReadHook->invoke(TS_EVENT_CACHE_LOOKUP, this);
return 1;
}
@@ -850,7 +850,7 @@ NewCacheVC::_writeHttpInfo()
#endif
}
//setCtrlInPlugin(true);
- _cacheWriteHook->invoke(INK_EVENT_CACHE_WRITE_HEADER, this);
+ _cacheWriteHook->invoke(TS_EVENT_CACHE_WRITE_HEADER, this);
} else {
Debug("cache_plugin", "[NewCacheVC::_writeHttpInfo] httpinfo not valid");
}
@@ -867,14 +867,14 @@ NewCacheVC::_free()
//send close event to allow plugin to free buffers
//setCtrlInPlugin(true);
- _cacheReadHook->invoke(INK_EVENT_CACHE_CLOSE, this);
+ _cacheReadHook->invoke(TS_EVENT_CACHE_CLOSE, this);
// if(_vio.op == VIO::READ)
-// _cacheWriteHook->invoke(INK_EVENT_CACHE_READ_UNLOCK, this);
+// _cacheWriteHook->invoke(TS_EVENT_CACHE_READ_UNLOCK, this);
// else if(_vio.op == VIO::WRITE)
-// _cacheWriteHook->invoke(INK_EVENT_CACHE_WRITE_UNLOCK,this);
+// _cacheWriteHook->invoke(TS_EVENT_CACHE_WRITE_UNLOCK,this);
// else if(_vio.op == VIO::SHUTDOWN_READWRITE)
- // _cacheWriteHook->invoke(INK_EVENT_CACHE_DELETE_UNLOCK,this);
+ // _cacheWriteHook->invoke(TS_EVENT_CACHE_DELETE_UNLOCK,this);
//CACHE_DECREMENT_DYN_STAT(this->base_stat + CACHE_STAT_ACTIVE);
// if (this->closed > 0) {
Modified: trafficserver/traffic/trunk/iocore/cluster/ClusterAPI.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/cluster/ClusterAPI.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/cluster/ClusterAPI.cc (original)
+++ trafficserver/traffic/trunk/iocore/cluster/ClusterAPI.cc Tue Nov 16 20:22:02 2010
@@ -34,12 +34,12 @@
#include "InkAPIInternal.h"
class ClusterAPIPeriodicSM;
-static void send_machine_online_list(INKClusterStatusHandle_t *);
+static void send_machine_online_list(TSClusterStatusHandle_t *);
typedef struct node_callout_entry
{
Ptr<ProxyMutex> mutex;
- INKClusterStatusFunction func;
+ TSClusterStatusFunction func;
int state; // See NE_STATE_XXX defines
} node_callout_entry_t;
@@ -52,22 +52,22 @@ static ProxyMutex *ClusterAPI_mutex;
static ClusterAPIPeriodicSM *periodicSM;
static node_callout_entry_t status_callouts[MAX_CLUSTERSTATUS_CALLOUTS];
-static INKClusterRPCFunction RPC_Functions[API_END_CLUSTER_FUNCTION];
+static TSClusterRPCFunction RPC_Functions[API_END_CLUSTER_FUNCTION];
-#define INDEX_TO_CLUSTER_STATUS_HANDLE(i) ((INKClusterStatusHandle_t)((i)))
+#define INDEX_TO_CLUSTER_STATUS_HANDLE(i) ((TSClusterStatusHandle_t)((i)))
#define CLUSTER_STATUS_HANDLE_TO_INDEX(h) ((int) ((h)))
#define NODE_HANDLE_TO_IP(h) (*((struct in_addr *) &((h))))
#define RPC_FUNCTION_KEY_TO_CLUSTER_NUMBER(k) ((int)((k)))
-#define IP_TO_NODE_HANDLE(ip) ((INKNodeHandle_t)((ip)))
-#define SIZEOF_RPC_MSG_LESS_DATA (sizeof(INKClusterRPCMsg_t) - \
- (sizeof(INKClusterRPCMsg_t) - sizeof(INKClusterRPCHandle_t)))
+#define IP_TO_NODE_HANDLE(ip) ((TSNodeHandle_t)((ip)))
+#define SIZEOF_RPC_MSG_LESS_DATA (sizeof(TSClusterRPCMsg_t) - \
+ (sizeof(TSClusterRPCMsg_t) - sizeof(TSClusterRPCHandle_t)))
typedef struct RPCHandle
{
union
{ // Note: All union elements are assumed to be the same size
// sizeof(u.internal) == sizeof(u.external)
- INKClusterRPCHandle_t external;
+ TSClusterRPCHandle_t external;
struct real_format
{
int cluster_function;
@@ -84,22 +84,22 @@ class MachineStatusSM:public Continuatio
{
public:
// Broadcast constructor
- MachineStatusSM(INKNodeHandle_t h, INKNodeStatus_t s):_node_handle(h), _node_status(s), _status_handle(0),
+ MachineStatusSM(TSNodeHandle_t h, TSNodeStatus_t s):_node_handle(h), _node_status(s), _status_handle(0),
_broadcast(1), _restart(0), _next_n(0)
{
SET_HANDLER((MachineStatusSMHandler)
& MachineStatusSM::MachineStatusSMEvent);
}
// Unicast constructor
- MachineStatusSM(INKNodeHandle_t h, INKNodeStatus_t s,
- INKClusterStatusHandle_t sh):_node_handle(h), _node_status(s), _status_handle(sh),
+ MachineStatusSM(TSNodeHandle_t h, TSNodeStatus_t s,
+ TSClusterStatusHandle_t sh):_node_handle(h), _node_status(s), _status_handle(sh),
_broadcast(0), _restart(0), _next_n(0)
{
SET_HANDLER((MachineStatusSMHandler)
& MachineStatusSM::MachineStatusSMEvent);
}
// Send machine online list constructor
-MachineStatusSM(INKClusterStatusHandle_t sh):
+MachineStatusSM(TSClusterStatusHandle_t sh):
_node_handle(0), _node_status(NODE_ONLINE), _status_handle(sh), _broadcast(0), _restart(0), _next_n(0) {
SET_HANDLER((MachineStatusSMHandler)
& MachineStatusSM::MachineStatusSMEvent);
@@ -109,9 +109,9 @@ MachineStatusSM(INKClusterStatusHandle_t
int MachineStatusSMEvent(Event * e, void *d);
private:
- INKNodeHandle_t _node_handle;
- INKNodeStatus_t _node_status;
- INKClusterStatusHandle_t _status_handle; // Valid only if !_broadcast
+ TSNodeHandle_t _node_handle;
+ TSNodeStatus_t _node_status;
+ TSClusterStatusHandle_t _status_handle; // Valid only if !_broadcast
int _broadcast;
int _restart;
int _next_n;
@@ -157,7 +157,7 @@ MachineStatusSM::MachineStatusSMEvent(Ev
unsigned int my_ipaddr = (this_cluster_machine())->ip;
ClusterConfiguration *cc;
- INKNodeHandle_t nh;
+ TSNodeHandle_t nh;
cc = this_cluster()->current_configuration();
if (cc) {
@@ -304,9 +304,9 @@ clusterAPI_init()
* called at plugin load time.
*/
int
-INKAddClusterStatusFunction(INKClusterStatusFunction Status_Function, INKMutex m, INKClusterStatusHandle_t * h)
+TSAddClusterStatusFunction(TSClusterStatusFunction Status_Function, TSMutex m, TSClusterStatusHandle_t * h)
{
- Debug("cluster_api", "INKAddClusterStatusFunction func 0x%x", Status_Function);
+ Debug("cluster_api", "TSAddClusterStatusFunction func 0x%x", Status_Function);
int n;
EThread *e = this_ethread();
@@ -319,7 +319,7 @@ INKAddClusterStatusFunction(INKClusterSt
MUTEX_UNTAKE_LOCK(ClusterAPI_mutex, e);
*h = INDEX_TO_CLUSTER_STATUS_HANDLE(n);
- Debug("cluster_api", "INKAddClusterStatusFunction: func 0x%x n %d", Status_Function, n);
+ Debug("cluster_api", "TSAddClusterStatusFunction: func 0x%x n %d", Status_Function, n);
return 0;
}
}
@@ -329,23 +329,23 @@ INKAddClusterStatusFunction(INKClusterSt
/*
* Remove the given function from the node status callout list
- * established via INKAddClusterStatusFunction().
+ * established via TSAddClusterStatusFunction().
*
* Note: Using blocking mutex since interface is synchronous and is only
* called at plugin unload time (unload currently not supported).
*/
int
-INKDeleteClusterStatusFunction(INKClusterStatusHandle_t * h)
+TSDeleteClusterStatusFunction(TSClusterStatusHandle_t * h)
{
int n = CLUSTER_STATUS_HANDLE_TO_INDEX(*h);
EThread *e = this_ethread();
ink_release_assert((n >= 0) && (n < MAX_CLUSTERSTATUS_CALLOUTS));
- Debug("cluster_api", "INKDeleteClusterStatusFunction: n %d", n);
+ Debug("cluster_api", "TSDeleteClusterStatusFunction: n %d", n);
MUTEX_TAKE_LOCK(ClusterAPI_mutex, e);
status_callouts[n].mutex = 0;
- status_callouts[n].func = (INKClusterStatusFunction) 0;
+ status_callouts[n].func = (TSClusterStatusFunction) 0;
status_callouts[n].state = NE_STATE_FREE;
MUTEX_UNTAKE_LOCK(ClusterAPI_mutex, e);
@@ -353,26 +353,26 @@ INKDeleteClusterStatusFunction(INKCluste
}
int
-INKNodeHandleToIPAddr(INKNodeHandle_t * h, struct in_addr *in)
+TSNodeHandleToIPAddr(TSNodeHandle_t * h, struct in_addr *in)
{
*in = NODE_HANDLE_TO_IP(*h);
return 0;
}
void
-INKGetMyNodeHandle(INKNodeHandle_t * h)
+TSGetMyNodeHandle(TSNodeHandle_t * h)
{
*h = IP_TO_NODE_HANDLE((this_cluster_machine())->ip);
}
/*
* Enable node status callouts for the added callout entry.
- * Issued once after the call to INKAddClusterStatusFunction()
+ * Issued once after the call to TSAddClusterStatusFunction()
* to get the current node configuration. All subsequent
* callouts are updates to the state obtained at this point.
*/
void
-INKEnableClusterStatusCallout(INKClusterStatusHandle_t * h)
+TSEnableClusterStatusCallout(TSClusterStatusHandle_t * h)
{
int ci = CLUSTER_STATUS_HANDLE_TO_INDEX(*h);
// This isn't used.
@@ -383,12 +383,12 @@ INKEnableClusterStatusCallout(INKCluster
return;
}
- Debug("cluster_api", "INKEnableClusterStatusCallout: n %d", ci);
+ Debug("cluster_api", "TSEnableClusterStatusCallout: n %d", ci);
send_machine_online_list(h);
}
static void
-send_machine_online_list(INKClusterStatusHandle_t * h)
+send_machine_online_list(TSClusterStatusHandle_t * h)
{
MachineStatusSM *msm = NEW(new MachineStatusSM(*h));
@@ -401,7 +401,7 @@ send_machine_online_list(INKClusterStatu
// This doesn't seem to be used...
#ifdef NOT_USED_HERE
static void
-directed_machine_online(int Ipaddr, INKClusterStatusHandle_t * h)
+directed_machine_online(int Ipaddr, TSClusterStatusHandle_t * h)
{
MachineStatusSM *msm = NEW(new MachineStatusSM(IP_TO_NODE_HANDLE(Ipaddr), NODE_ONLINE, *h));
@@ -438,7 +438,7 @@ machine_offline_APIcallout(int Ipaddr)
* called at plugin load time.
*/
int
-INKAddClusterRPCFunction(INKClusterRPCKey_t k, INKClusterRPCFunction func, INKClusterRPCHandle_t * h)
+TSAddClusterRPCFunction(TSClusterRPCKey_t k, TSClusterRPCFunction func, TSClusterRPCHandle_t * h)
{
RPCHandle_t handle;
int n = RPC_FUNCTION_KEY_TO_CLUSTER_NUMBER(k);
@@ -447,7 +447,7 @@ INKAddClusterRPCFunction(INKClusterRPCKe
ink_release_assert(func);
ink_release_assert((n >= API_STARECT_CLUSTER_FUNCTION)
&& (n <= API_END_CLUSTER_FUNCTION));
- Debug("cluster_api", "INKAddClusterRPCFunction: key %d func 0x%x", k, func);
+ Debug("cluster_api", "TSAddClusterRPCFunction: key %d func 0x%x", k, func);
handle.u.internal.cluster_function = n;
handle.u.internal.magic = RPC_HANDLE_MAGIC;
@@ -462,20 +462,20 @@ INKAddClusterRPCFunction(INKClusterRPCKe
}
/*
- * Remove the given RPC function added via INKAddClusterRPCFunction().
+ * Remove the given RPC function added via TSAddClusterRPCFunction().
*
* Note: Using blocking mutex since interface is synchronous and is only
* called at plugin unload time (unload currently not supported).
*/
int
-INKDeleteClusterRPCFunction(INKClusterRPCHandle_t * rpch)
+TSDeleteClusterRPCFunction(TSClusterRPCHandle_t * rpch)
{
RPCHandle_t *h = (RPCHandle_t *) rpch;
EThread *e = this_ethread();
ink_release_assert(((h->u.internal.cluster_function >= API_STARECT_CLUSTER_FUNCTION)
&& (h->u.internal.cluster_function <= API_END_CLUSTER_FUNCTION)));
- Debug("cluster_api", "INKDeleteClusterRPCFunction: n %d", h->u.internal.cluster_function);
+ Debug("cluster_api", "TSDeleteClusterRPCFunction: n %d", h->u.internal.cluster_function);
MUTEX_TAKE_LOCK(ClusterAPI_mutex, e);
RPC_Functions[h->u.internal.cluster_function] = 0;
@@ -491,17 +491,17 @@ default_api_ClusterFunction(ClusterMachi
{
Debug("cluster_api", "default_api_ClusterFunction: [%u.%u.%u.%u] data 0x%x len %d", DOT_SEPARATED(m->ip), data, len);
- INKClusterRPCMsg_t *msg = (INKClusterRPCMsg_t *) data;
+ TSClusterRPCMsg_t *msg = (TSClusterRPCMsg_t *) data;
RPCHandle_t *rpch = (RPCHandle_t *) & msg->m_handle;
int cluster_function = rpch->u.internal.cluster_function;
- ink_release_assert((size_t) len >= sizeof(INKClusterRPCMsg_t));
+ ink_release_assert((size_t) len >= sizeof(TSClusterRPCMsg_t));
ink_release_assert(((cluster_function >= API_STARECT_CLUSTER_FUNCTION)
&& (cluster_function <= API_END_CLUSTER_FUNCTION)));
if (cluster_function < API_END_CLUSTER_FUNCTION && RPC_Functions[cluster_function]) {
int msg_data_len = len - SIZEOF_RPC_MSG_LESS_DATA;
- INKNodeHandle_t nh = IP_TO_NODE_HANDLE(m->ip);
+ TSNodeHandle_t nh = IP_TO_NODE_HANDLE(m->ip);
(*RPC_Functions[cluster_function]) (&nh, msg, msg_data_len);
} else {
clusterProcessor.free_remote_data((char *) data, len);
@@ -509,42 +509,42 @@ default_api_ClusterFunction(ClusterMachi
}
/*
- * Free INKClusterRPCMsg_t received via the RPC function.
+ * Free TSClusterRPCMsg_t received via the RPC function.
*/
void
-INKFreeRPCMsg(INKClusterRPCMsg_t * msg, int msg_data_len)
+TSFreeRPCMsg(TSClusterRPCMsg_t * msg, int msg_data_len)
{
RPCHandle_t *rpch = (RPCHandle_t *) & msg->m_handle;
ink_release_assert(rpch->u.internal.magic == RPC_HANDLE_MAGIC);
- Debug("cluster_api", "INKFreeRPCMsg: msg 0x%x msg_data_len %d", msg, msg_data_len);
+ Debug("cluster_api", "TSFreeRPCMsg: msg 0x%x msg_data_len %d", msg, msg_data_len);
clusterProcessor.free_remote_data((char *) msg, msg_data_len + SIZEOF_RPC_MSG_LESS_DATA);
}
/*
- * Allocate a message structure for use in the call to INKSendClusterRPC().
+ * Allocate a message structure for use in the call to TSSendClusterRPC().
*/
-INKClusterRPCMsg_t *
-INKAllocClusterRPCMsg(INKClusterRPCHandle_t * h, int data_size)
+TSClusterRPCMsg_t *
+TSAllocClusterRPCMsg(TSClusterRPCHandle_t * h, int data_size)
{
ink_debug_assert(data_size >= 4);
if (data_size < 4) {
/* Message must be at least 4 bytes in length */
- return (INKClusterRPCMsg_t *) 0;
+ return (TSClusterRPCMsg_t *) 0;
}
- INKClusterRPCMsg_t *rpcm;
+ TSClusterRPCMsg_t *rpcm;
OutgoingControl *c = OutgoingControl::alloc();
c->len = sizeof(OutgoingControl *) + SIZEOF_RPC_MSG_LESS_DATA + data_size;
c->alloc_data();
*((OutgoingControl **) c->data) = c;
- rpcm = (INKClusterRPCMsg_t *) (c->data + sizeof(OutgoingControl *));
+ rpcm = (TSClusterRPCMsg_t *) (c->data + sizeof(OutgoingControl *));
rpcm->m_handle = *h;
/*
- * Note: We have carefully constructed INKClusterRPCMsg_t so
+ * Note: We have carefully constructed TSClusterRPCMsg_t so
* m_data[] is 8 byte aligned. This allows the user to
* cast m_data[] to any type without any consideration
* for alignment issues.
@@ -556,7 +556,7 @@ INKAllocClusterRPCMsg(INKClusterRPCHandl
* Send the given message to the specified node.
*/
int
-INKSendClusterRPC(INKNodeHandle_t * nh, INKClusterRPCMsg_t * msg)
+TSSendClusterRPC(TSNodeHandle_t * nh, TSClusterRPCMsg_t * msg)
{
struct in_addr ipaddr = NODE_HANDLE_TO_IP(*nh);
RPCHandle_t *rpch = (RPCHandle_t *) & msg->m_handle;
@@ -570,14 +570,13 @@ INKSendClusterRPC(INKNodeHandle_t * nh,
if ((m = cc->find(ipaddr.s_addr))) {
int len = c->len - sizeof(OutgoingControl *);
- ink_release_assert((size_t) len >= sizeof(INKClusterRPCMsg_t));
+ ink_release_assert((size_t) len >= sizeof(TSClusterRPCMsg_t));
clusterProcessor.invoke_remote(m, rpch->u.internal.cluster_function,
msg, len, (CLUSTER_OPT_STEAL | CLUSTER_OPT_DATA_IS_OCONTROL));
- Debug("cluster_api",
- "INKSendClusterRPC: msg 0x%x dlen %d [%u.%u.%u.%u] sent", msg, len, DOT_SEPARATED(ipaddr.s_addr));
+ Debug("cluster_api", "TSSendClusterRPC: msg 0x%x dlen %d [%u.%u.%u.%u] sent", msg, len, DOT_SEPARATED(ipaddr.s_addr));
} else {
- Debug("cluster_api", "INKSendClusterRPC: msg 0x%x to [%u.%u.%u.%u] dropped", msg, DOT_SEPARATED(ipaddr.s_addr));
+ Debug("cluster_api", "TSSendClusterRPC: msg 0x%x to [%u.%u.%u.%u] dropped", msg, DOT_SEPARATED(ipaddr.s_addr));
c->freeall();
}
Modified: trafficserver/traffic/trunk/libinktomi++/ink_config.h.in
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/libinktomi%2B%2B/ink_config.h.in?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/libinktomi++/ink_config.h.in (original)
+++ trafficserver/traffic/trunk/libinktomi++/ink_config.h.in Tue Nov 16 20:22:02 2010
@@ -150,8 +150,8 @@
#define TS_MAX_API_STATS @max_api_stats@
/* XXX: Should make those individually selectable ? */
#else
-# define INK_NO_TRANSFORM 1
-# define INK_NO_API 1
+# define TS_NO_TRANSFORM 1
+# define TS_NO_API 1
# define INK_SINGLE_THREADED 1
#endif
Modified: trafficserver/traffic/trunk/proxy/FetchSM.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/FetchSM.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/FetchSM.cc (original)
+++ trafficserver/traffic/trunk/proxy/FetchSM.cc Tue Nov 16 20:22:02 2010
@@ -33,14 +33,14 @@ ClassAllocator < FetchSM > FetchSMAlloca
void
FetchSM::cleanUp()
{
- INKDebug(DEBUG_TAG, "[%s] calling cleanup", __FUNCTION__);
+ Debug(DEBUG_TAG, "[%s] calling cleanup", __FUNCTION__);
free_MIOBuffer(response_buffer);
free_MIOBuffer(req_buffer);
free_MIOBuffer(resp_buffer);
mutex.clear();
http_parser_clear(&http_parser);
client_response_hdr.destroy();
- INKfree(client_response);
+ xfree(client_response);
PluginVC *vc = (PluginVC *) http_vc;
vc->do_io_close();
FetchSMAllocator.free(this);
@@ -49,8 +49,8 @@ FetchSM::cleanUp()
void
FetchSM::httpConnect()
{
- INKDebug(DEBUG_TAG, "[%s] calling httpconnect write", __FUNCTION__);
- INKHttpConnect(_ip, _port, &(http_vc));
+ Debug(DEBUG_TAG, "[%s] calling httpconnect write", __FUNCTION__);
+ TSHttpConnect(_ip, _port, &(http_vc));
PluginVC *vc = (PluginVC *) http_vc;
read_vio = vc->do_io_read(this, INT_MAX, resp_buffer);
write_vio = vc->do_io_write(this, getReqLen(), req_reader);
@@ -71,23 +71,23 @@ int FetchSM::InvokePlugin(int event, voi
return ret;
}
void
-FetchSM::get_info_from_buffer(INKIOBufferReader the_reader)
+FetchSM::get_info_from_buffer(TSIOBufferReader the_reader)
{
char *info;
// char *info_start;
int64 read_avail, read_done;
- INKIOBufferBlock blk;
+ TSIOBufferBlock blk;
char *buf;
if (!the_reader)
return ;
- read_avail = INKIOBufferReaderAvail(the_reader);
- INKDebug(DEBUG_TAG, "[%s] total avail %d", __FUNCTION__, read_avail);
+ read_avail = TSIOBufferReaderAvail(the_reader);
+ Debug(DEBUG_TAG, "[%s] total avail %d", __FUNCTION__, read_avail);
//size_t hdr_size = _headers.size();
- //info = (char *) INKmalloc(sizeof(char) * (read_avail+1) + hdr_size);
- info = (char *) INKmalloc(sizeof(char) * (read_avail+1));
+ //info = (char *) xmalloc(sizeof(char) * (read_avail+1) + hdr_size);
+ info = (char *) xmalloc(sizeof(char) * (read_avail+1));
if (info == NULL)
return ;
client_response = info;
@@ -96,11 +96,11 @@ FetchSM::get_info_from_buffer(INKIOBuffe
/* Read the data out of the reader */
while (read_avail > 0) {
- blk = INKIOBufferReaderStart(the_reader);
- buf = (char *) INKIOBufferBlockReadStart(blk, the_reader, &read_done);
+ blk = TSIOBufferReaderStart(the_reader);
+ buf = (char *) TSIOBufferBlockReadStart(blk, the_reader, &read_done);
memcpy(info, buf, read_done);
if (read_done > 0) {
- INKIOBufferReaderConsume(the_reader, read_done);
+ TSIOBufferReaderConsume(the_reader, read_done);
read_avail -= read_done;
info += read_done;
}
@@ -112,14 +112,14 @@ void
FetchSM::process_fetch_read(int event)
{
- INKDebug(DEBUG_TAG, "[%s] I am here read", __FUNCTION__);
+ Debug(DEBUG_TAG, "[%s] I am here read", __FUNCTION__);
int bytes;
int bytes_used;
int actual_bytes_copied = 0;
switch (event) {
- case INK_EVENT_VCONN_READ_READY:
+ case TS_EVENT_VCONN_READ_READY:
bytes = resp_reader->read_avail();
- INKDebug(DEBUG_TAG, "[%s] number of bytes in read ready %d", __FUNCTION__, bytes);
+ Debug(DEBUG_TAG, "[%s] number of bytes in read ready %d", __FUNCTION__, bytes);
while (actual_bytes_copied < bytes) {
actual_bytes_copied = response_buffer->write(resp_reader, bytes, 0);
resp_reader->consume(actual_bytes_copied);
@@ -128,36 +128,36 @@ FetchSM::process_fetch_read(int event)
resp_reader->consume(bytes);
if (header_done == 0 && callback_options == AFTER_HEADER) {
if (client_response_hdr.parse_resp(&http_parser, response_reader, &bytes_used, 0) == PARSE_DONE) {
- //InvokePlugin( INK_EVENT_INTERNAL_60201, (void *) &client_response_hdr);
+ //InvokePlugin( TS_EVENT_INTERNAL_60201, (void *) &client_response_hdr);
InvokePlugin( callback_events.success_event_id, (void *) &client_response_hdr);
header_done = 1;
}
}
read_vio->reenable();
break;
- case INK_EVENT_VCONN_READ_COMPLETE:
- case INK_EVENT_VCONN_EOS:
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ case TS_EVENT_VCONN_EOS:
if(callback_options == AFTER_HEADER || callback_options == AFTER_BODY) {
bytes = response_reader->read_avail();
get_info_from_buffer(response_reader);
- INKDebug(DEBUG_TAG, "[%s] number of bytes %d", __FUNCTION__, bytes);
+ Debug(DEBUG_TAG, "[%s] number of bytes %d", __FUNCTION__, bytes);
if(client_response!=NULL)
client_response[bytes] = '\0';
//client_response[bytes + _headers.size()] = '\0';
- INKDebug(DEBUG_TAG, "[%s] Completed data fetch of size %d, notifying caller", __FUNCTION__, bytes);
- //InvokePlugin( INK_EVENT_INTERNAL_60200, (void *) client_response);
+ Debug(DEBUG_TAG, "[%s] Completed data fetch of size %d, notifying caller", __FUNCTION__, bytes);
+ //InvokePlugin( TS_EVENT_INTERNAL_60200, (void *) client_response);
client_bytes = bytes;
- //InvokePlugin( INK_EVENT_INTERNAL_60200, (void *) this);
+ //InvokePlugin( TS_EVENT_INTERNAL_60200, (void *) this);
InvokePlugin( callback_events.success_event_id, (void *) this);
}
- INKDebug(DEBUG_TAG, "[%s] received EOS", __FUNCTION__);
+ Debug(DEBUG_TAG, "[%s] received EOS", __FUNCTION__);
cleanUp();
break;
- case INK_EVENT_ERROR:
+ case TS_EVENT_ERROR:
default:
- //InvokePlugin(INK_EVENT_ERROR, NULL);
+ //InvokePlugin(TS_EVENT_ERROR, NULL);
InvokePlugin( callback_events.failure_event_id, NULL);
cleanUp();
break;
@@ -168,15 +168,15 @@ FetchSM::process_fetch_read(int event)
void
FetchSM::process_fetch_write(int event)
{
- INKDebug(DEBUG_TAG, "[%s] calling process write", __FUNCTION__);
+ Debug(DEBUG_TAG, "[%s] calling process write", __FUNCTION__);
switch (event) {
- case INK_EVENT_VCONN_WRITE_COMPLETE:
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
//INKVConnShutdown(http_vc, 0, 1) ; why does not this work???
req_finished = true;
break;
- case INK_EVENT_VCONN_WRITE_READY:
- case INK_EVENT_ERROR:
- //InvokePlugin( INK_EVENT_ERROR, NULL);
+ case TS_EVENT_VCONN_WRITE_READY:
+ case TS_EVENT_ERROR:
+ //InvokePlugin( TS_EVENT_ERROR, NULL);
InvokePlugin( callback_events.failure_event_id, NULL);
cleanUp();
default:
@@ -187,14 +187,13 @@ FetchSM::process_fetch_write(int event)
int
FetchSM::fetch_handler(int event, void *edata)
{
- INKDebug(DEBUG_TAG, "[%s] calling fetch_plugin", __FUNCTION__);
+ Debug(DEBUG_TAG, "[%s] calling fetch_plugin", __FUNCTION__);
if (edata == read_vio) {
process_fetch_read(event);
} else if (edata == write_vio) {
process_fetch_write(event);
} else {
- //InvokePlugin( INK_EVENT_ERROR, NULL);
InvokePlugin( callback_events.failure_event_id, NULL);
cleanUp();
}
Modified: trafficserver/traffic/trunk/proxy/FetchSM.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/FetchSM.h?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/FetchSM.h (original)
+++ trafficserver/traffic/trunk/proxy/FetchSM.h Tue Nov 16 20:22:02 2010
@@ -43,10 +43,10 @@ public:
FetchSM()
{
};
- void init(INKCont cont, INKFetchWakeUpOptions options, INKFetchEvent events, const char* headers, int length,unsigned int ip, int port)
+ void init(TSCont cont, TSFetchWakeUpOptions options, TSFetchEvent events, const char* headers, int length,unsigned int ip, int port)
{
//_headers.assign(headers);
- INKDebug("FetchSM", "[%s] FetchSM initialized for request with headers\n--\n%s\n--", __FUNCTION__, headers);
+ Debug("FetchSM", "[%s] FetchSM initialized for request with headers\n--\n%s\n--", __FUNCTION__, headers);
req_finished = 0;
resp_finished = 0;
header_done = 0;
@@ -73,7 +73,7 @@ public:
void process_fetch_write(int event);
void httpConnect();
void cleanUp();
- void get_info_from_buffer(INKIOBufferReader reader);
+ void get_info_from_buffer(TSIOBufferReader reader);
char* resp_get(int* length);
private:
int InvokePlugin(int event, void*data);
@@ -89,7 +89,7 @@ private:
return req_reader->read_avail();
}
- INKVConn http_vc;
+ TSVConn http_vc;
VIO *read_vio;
VIO *write_vio;
MIOBuffer *response_buffer; // response to FetchSM call
@@ -100,11 +100,11 @@ private:
int client_bytes;
MIOBuffer *resp_buffer; // response to HttpConnect Call
IOBufferReader *resp_reader;
- INKCont contp;
+ TSCont contp;
HTTPParser http_parser;
HTTPHdr client_response_hdr;
- INKFetchEvent callback_events;
- INKFetchWakeUpOptions callback_options;
+ TSFetchEvent callback_events;
+ TSFetchWakeUpOptions callback_options;
bool req_finished;
bool header_done;
bool resp_finished;