static int
on_mp_read_session_read_response_write2(struct query_state *qstate)
{
struct cache_mp_read_session_read_response *read_response;
ssize_t result;
TRACE_IN(on_mp_read_session_read_response_write2);
read_response = get_cache_mp_read_session_read_response(
&qstate->response);
result = qstate->write_func(qstate, read_response->data,
read_response->data_size);
if (result < 0 || (size_t)result != qstate->kevent_watermark) {
LOG_ERR_3("on_mp_read_session_read_response_write2",
"write failed");
TRACE_OUT(on_mp_read_session_read_response_write2);
return (-1);
}
finalize_comm_element(&qstate->request);
finalize_comm_element(&qstate->response);
qstate->kevent_watermark = sizeof(int);
qstate->process_func = on_mp_read_session_mapper;
qstate->kevent_filter = EVFILT_READ;
TRACE_OUT(on_mp_read_session_read_response_write2);
return (0);
}
/*
* on_rw_mapper is used to process multiple read/write requests during
* one connection session. It's never called in the beginning (on query_state
* creation) as it does not process the multipart requests and does not
* receive credentials
*/
static int
on_rw_mapper(struct query_state *qstate)
{
ssize_t result;
int elem_type;
TRACE_IN(on_rw_mapper);
if (qstate->kevent_watermark == 0) {
qstate->kevent_watermark = sizeof(int);
} else {
result = qstate->read_func(qstate, &elem_type, sizeof(int));
if (result != sizeof(int)) {
TRACE_OUT(on_rw_mapper);
return (-1);
}
switch (elem_type) {
case CET_WRITE_REQUEST:
qstate->kevent_watermark = sizeof(size_t);
qstate->process_func = on_write_request_read1;
break;
case CET_READ_REQUEST:
qstate->kevent_watermark = sizeof(size_t);
qstate->process_func = on_read_request_read1;
break;
default:
TRACE_OUT(on_rw_mapper);
return (-1);
break;
}
}
TRACE_OUT(on_rw_mapper);
return (0);
}
static int __post_summary_for_contest(unsigned int contestid)
{
u32 iterhi, iterlo; int rc = -1;
unsigned int packets, swucount;
struct timeval ttime;
TRACE_OUT((+1,"__post_summary_for_contest(%u)\n",contestid));
if (CliGetContestInfoSummaryData( contestid, &packets, &iterhi, &iterlo,
&ttime, &swucount ) == 0)
{
if (packets)
{
char ratebuf[15];
TRACE_OUT((0,"pkts=%u, iter=%u:%u, time=%lu:%lu, swucount=%u\n", packets,
iterhi, iterlo, ttime.tv_sec, ttime.tv_usec, swucount ));
Log("%s: Summary: %u packet%s (%u.%02u stats units)\n%s%c- [%s/s]\n",
CliGetContestNameFromID(contestid),
packets, ((packets==1)?(""):("s")),
swucount/100, swucount%100,
CliGetTimeString(&ttime,2), ((packets)?(' '):(0)),
ProblemComputeRate( contestid, ttime.tv_sec, ttime.tv_usec,
iterhi, iterlo, 0, 0, ratebuf, sizeof(ratebuf)) );
}
rc = 0;
}
TRACE_OUT((-1,"__post_summary_for_contest()\n"));
return rc;
}
static int
on_write_response_write1(struct query_state *qstate)
{
struct cache_write_response *write_response;
ssize_t result;
TRACE_IN(on_write_response_write1);
write_response = get_cache_write_response(&qstate->response);
result = qstate->write_func(qstate, &write_response->error_code,
sizeof(int));
if (result != sizeof(int)) {
TRACE_OUT(on_write_response_write1);
return (-1);
}
finalize_comm_element(&qstate->request);
finalize_comm_element(&qstate->response);
qstate->kevent_watermark = sizeof(int);
qstate->kevent_filter = EVFILT_READ;
qstate->process_func = on_rw_mapper;
TRACE_OUT(on_write_response_write1);
return (0);
}
static int
on_write_request_read2(struct query_state *qstate)
{
struct cache_write_request *write_request;
ssize_t result;
TRACE_IN(on_write_request_read2);
write_request = get_cache_write_request(&qstate->request);
result = qstate->read_func(qstate, write_request->entry,
write_request->entry_length);
result += qstate->read_func(qstate, write_request->cache_key +
qstate->eid_str_length, write_request->cache_key_size);
if (write_request->data_size != 0)
result += qstate->read_func(qstate, write_request->data,
write_request->data_size);
if (result != qstate->kevent_watermark) {
TRACE_OUT(on_write_request_read2);
return (-1);
}
write_request->cache_key_size += qstate->eid_str_length;
qstate->kevent_watermark = 0;
if (write_request->data_size != 0)
qstate->process_func = on_write_request_process;
else
qstate->process_func = on_negative_write_request_process;
TRACE_OUT(on_write_request_read2);
return (0);
}
static int
on_read_request_read2(struct query_state *qstate)
{
struct cache_read_request *read_request;
ssize_t result;
TRACE_IN(on_read_request_read2);
read_request = get_cache_read_request(&qstate->request);
result = qstate->read_func(qstate, read_request->entry,
read_request->entry_length);
result += qstate->read_func(qstate,
read_request->cache_key + qstate->eid_str_length,
read_request->cache_key_size);
if (result != qstate->kevent_watermark) {
TRACE_OUT(on_read_request_read2);
return (-1);
}
read_request->cache_key_size += qstate->eid_str_length;
qstate->kevent_watermark = 0;
qstate->process_func = on_read_request_process;
TRACE_OUT(on_read_request_read2);
return (0);
}
static int
on_read_response_write1(struct query_state *qstate)
{
struct cache_read_response *read_response;
ssize_t result;
TRACE_IN(on_read_response_write1);
read_response = get_cache_read_response(&qstate->response);
result = qstate->write_func(qstate, &read_response->error_code,
sizeof(int));
if (read_response->error_code == 0) {
result += qstate->write_func(qstate, &read_response->data_size,
sizeof(size_t));
if (result != qstate->kevent_watermark) {
TRACE_OUT(on_read_response_write1);
return (-1);
}
qstate->kevent_watermark = read_response->data_size;
qstate->process_func = on_read_response_write2;
} else {
if (result != qstate->kevent_watermark) {
TRACE_OUT(on_read_response_write1);
return (-1);
}
qstate->kevent_watermark = 0;
qstate->process_func = NULL;
}
TRACE_OUT(on_read_response_write1);
return (0);
}
static int
on_read_response_write2(struct query_state *qstate)
{
struct cache_read_response *read_response;
ssize_t result;
TRACE_IN(on_read_response_write2);
read_response = get_cache_read_response(&qstate->response);
if (read_response->data_size > 0) {
result = qstate->write_func(qstate, read_response->data,
read_response->data_size);
if (result != qstate->kevent_watermark) {
TRACE_OUT(on_read_response_write2);
return (-1);
}
}
finalize_comm_element(&qstate->request);
finalize_comm_element(&qstate->response);
qstate->kevent_watermark = sizeof(int);
qstate->kevent_filter = EVFILT_READ;
qstate->process_func = on_rw_mapper;
TRACE_OUT(on_read_response_write2);
return (0);
}
static int
on_mp_write_session_write_request_read2(struct query_state *qstate)
{
struct cache_mp_write_session_write_request *write_request;
ssize_t result;
TRACE_IN(on_mp_write_session_write_request_read2);
write_request = get_cache_mp_write_session_write_request(
&qstate->request);
result = qstate->read_func(qstate, write_request->data,
write_request->data_size);
if (result < 0 || (size_t)result != qstate->kevent_watermark) {
LOG_ERR_3("on_mp_write_session_write_request_read2",
"read failed");
TRACE_OUT(on_mp_write_session_write_request_read2);
return (-1);
}
qstate->kevent_watermark = 0;
qstate->process_func = on_mp_write_session_write_request_process;
TRACE_OUT(on_mp_write_session_write_request_read2);
return (0);
}
static int
on_mp_write_session_write_response_write1(struct query_state *qstate)
{
struct cache_mp_write_session_write_response *write_response;
ssize_t result;
TRACE_IN(on_mp_write_session_write_response_write1);
write_response = get_cache_mp_write_session_write_response(
&qstate->response);
result = qstate->write_func(qstate, &write_response->error_code,
sizeof(int));
if (result != sizeof(int)) {
LOG_ERR_3("on_mp_write_session_write_response_write1",
"write failed");
TRACE_OUT(on_mp_write_session_write_response_write1);
return (-1);
}
if (write_response->error_code == 0) {
finalize_comm_element(&qstate->request);
finalize_comm_element(&qstate->response);
qstate->kevent_watermark = sizeof(int);
qstate->process_func = on_mp_write_session_mapper;
qstate->kevent_filter = EVFILT_READ;
} else {
qstate->kevent_watermark = 0;
qstate->process_func = 0;
}
TRACE_OUT(on_mp_write_session_write_response_write1);
return (0);
}
/*
* The functions below are used to process write requests.
* - on_write_request_read1 and on_write_request_read2 read the request itself
* - on_write_request_process processes it (if the client requests to
* cache the negative result, the on_negative_write_request_process is used)
* - on_write_response_write1 sends the response
*/
static int
on_write_request_read1(struct query_state *qstate)
{
struct cache_write_request *write_request;
ssize_t result;
TRACE_IN(on_write_request_read1);
if (qstate->kevent_watermark == 0)
qstate->kevent_watermark = sizeof(size_t) * 3;
else {
init_comm_element(&qstate->request, CET_WRITE_REQUEST);
write_request = get_cache_write_request(&qstate->request);
result = qstate->read_func(qstate, &write_request->entry_length,
sizeof(size_t));
result += qstate->read_func(qstate,
&write_request->cache_key_size, sizeof(size_t));
result += qstate->read_func(qstate,
&write_request->data_size, sizeof(size_t));
if (result != sizeof(size_t) * 3) {
TRACE_OUT(on_write_request_read1);
return (-1);
}
if (BUFSIZE_INVALID(write_request->entry_length) ||
BUFSIZE_INVALID(write_request->cache_key_size) ||
(BUFSIZE_INVALID(write_request->data_size) &&
(write_request->data_size != 0))) {
TRACE_OUT(on_write_request_read1);
return (-1);
}
write_request->entry = (char *)calloc(1,
write_request->entry_length + 1);
assert(write_request->entry != NULL);
write_request->cache_key = (char *)calloc(1,
write_request->cache_key_size +
qstate->eid_str_length);
assert(write_request->cache_key != NULL);
memcpy(write_request->cache_key, qstate->eid_str,
qstate->eid_str_length);
if (write_request->data_size != 0) {
write_request->data = (char *)calloc(1,
write_request->data_size);
assert(write_request->data != NULL);
}
qstate->kevent_watermark = write_request->entry_length +
write_request->cache_key_size +
write_request->data_size;
qstate->process_func = on_write_request_read2;
}
TRACE_OUT(on_write_request_read1);
return (0);
}
bool Pattern::Compare(const wchar_t* wildStr, int wildOff, const wchar_t* rawStr, int rawOff)
{
#ifdef TRACING
std::wcout << std::endl << "\tCompare: " << TRACE_OUT(wildStr) << TRACE_OUT(wildOff) << TRACE_OUT(rawStr) << TRACE_OUT(rawOff) << std::endl;
#endif
const wchar_t EOS = L'\0';
while (wildStr[wildOff])
{
if (rawStr[rawOff] == EOS)
return (wcscmp(wildStr+wildOff, L"*") == 0);
if (wildStr[wildOff] == L'*')
{
if (wildStr[wildOff + 1] == EOS)
return true;
do
{
// Find match with char after '*'
while (rawStr[rawOff] &&
!Pattern::ChrCmp(rawStr[rawOff], wildStr[wildOff+1]))
rawOff++;
if (rawStr[rawOff] &&
Compare(wildStr, wildOff + 1, rawStr, rawOff))
return true;
if (rawStr[rawOff])
++rawOff;
} while (rawStr[rawOff]);
if (rawStr[rawOff] == EOS)
return (wcscmp(wildStr+wildOff+1, L"*") == 0);
}
else if (wildStr[wildOff] == L'?')
{
if (rawStr[rawOff] == EOS)
return false;
rawOff++;
}
else
{
if (!Pattern::ChrCmp(rawStr[rawOff], wildStr[wildOff]))
return false;
if (wildStr[wildOff] == EOS)
return true;
++rawOff;
}
++wildOff;
}
return (wildStr[wildOff] == rawStr[rawOff]);
}
/*
* The functions below are used to process write requests.
* - on_transform_request_read1 and on_transform_request_read2 read the
* request itself
* - on_transform_request_process processes it
* - on_transform_response_write1 sends the response
*/
static int
on_transform_request_read1(struct query_state *qstate)
{
struct cache_transform_request *transform_request;
ssize_t result;
TRACE_IN(on_transform_request_read1);
if (qstate->kevent_watermark == 0)
qstate->kevent_watermark = sizeof(size_t) + sizeof(int);
else {
init_comm_element(&qstate->request, CET_TRANSFORM_REQUEST);
transform_request =
get_cache_transform_request(&qstate->request);
result = qstate->read_func(qstate,
&transform_request->entry_length, sizeof(size_t));
result += qstate->read_func(qstate,
&transform_request->transformation_type, sizeof(int));
if (result != sizeof(size_t) + sizeof(int)) {
TRACE_OUT(on_transform_request_read1);
return (-1);
}
if ((transform_request->transformation_type != TT_USER) &&
(transform_request->transformation_type != TT_ALL)) {
TRACE_OUT(on_transform_request_read1);
return (-1);
}
if (transform_request->entry_length != 0) {
if (BUFSIZE_INVALID(transform_request->entry_length)) {
TRACE_OUT(on_transform_request_read1);
return (-1);
}
transform_request->entry = (char *)calloc(1,
transform_request->entry_length + 1);
assert(transform_request->entry != NULL);
qstate->process_func = on_transform_request_read2;
} else
qstate->process_func = on_transform_request_process;
qstate->kevent_watermark = transform_request->entry_length;
}
TRACE_OUT(on_transform_request_read1);
return (0);
}
/*
* The functions below are used to process read requests.
* - on_read_request_read1 and on_read_request_read2 read the request itself
* - on_read_request_process processes it
* - on_read_response_write1 and on_read_response_write2 send the response
*/
static int
on_read_request_read1(struct query_state *qstate)
{
struct cache_read_request *read_request;
ssize_t result;
TRACE_IN(on_read_request_read1);
if (qstate->kevent_watermark == 0)
qstate->kevent_watermark = sizeof(size_t) * 2;
else {
init_comm_element(&qstate->request, CET_READ_REQUEST);
read_request = get_cache_read_request(&qstate->request);
result = qstate->read_func(qstate,
&read_request->entry_length, sizeof(size_t));
result += qstate->read_func(qstate,
&read_request->cache_key_size, sizeof(size_t));
if (result != sizeof(size_t) * 2) {
TRACE_OUT(on_read_request_read1);
return (-1);
}
if (BUFSIZE_INVALID(read_request->entry_length) ||
BUFSIZE_INVALID(read_request->cache_key_size)) {
TRACE_OUT(on_read_request_read1);
return (-1);
}
read_request->entry = (char *)calloc(1,
read_request->entry_length + 1);
assert(read_request->entry != NULL);
read_request->cache_key = (char *)calloc(1,
read_request->cache_key_size +
qstate->eid_str_length);
assert(read_request->cache_key != NULL);
memcpy(read_request->cache_key, qstate->eid_str,
qstate->eid_str_length);
qstate->kevent_watermark = read_request->entry_length +
read_request->cache_key_size;
qstate->process_func = on_read_request_read2;
}
TRACE_OUT(on_read_request_read1);
return (0);
}
static struct cache_policy_item_ *
cache_lfu_policy_get_next_item(struct cache_policy_ *policy,
struct cache_policy_item_ *item)
{
struct cache_lfu_policy_ *lfu_policy;
struct cache_lfu_policy_item_ *lfu_item;
int i;
TRACE_IN(cache_lfu_policy_get_next_item);
lfu_policy = (struct cache_lfu_policy_ *)policy;
lfu_item = TAILQ_NEXT((struct cache_lfu_policy_item_ *)item, entries);
if (lfu_item == NULL)
{
for (i = ((struct cache_lfu_policy_item_ *)item)->frequency + 1;
i < CACHELIB_MAX_FREQUENCY; ++i) {
if (!TAILQ_EMPTY(&(lfu_policy->groups[i]))) {
lfu_item = TAILQ_FIRST(&(lfu_policy->groups[i]));
break;
}
}
}
TRACE_OUT(cache_lfu_policy_get_next_item);
return ((struct cache_policy_item_ *)lfu_item);
}
/*
* Clears the specified configuration entry (clears the cache for positive and
* and negative entries) and also for all multipart entries.
*/
static void
clear_config_entry(struct configuration_entry *config_entry)
{
size_t i;
TRACE_IN(clear_config_entry);
configuration_lock_entry(config_entry, CELT_POSITIVE);
if (config_entry->positive_cache_entry != NULL)
transform_cache_entry(
config_entry->positive_cache_entry,
CTT_CLEAR);
configuration_unlock_entry(config_entry, CELT_POSITIVE);
configuration_lock_entry(config_entry, CELT_NEGATIVE);
if (config_entry->negative_cache_entry != NULL)
transform_cache_entry(
config_entry->negative_cache_entry,
CTT_CLEAR);
configuration_unlock_entry(config_entry, CELT_NEGATIVE);
configuration_lock_entry(config_entry, CELT_MULTIPART);
for (i = 0; i < config_entry->mp_cache_entries_size; ++i)
transform_cache_entry(
config_entry->mp_cache_entries[i],
CTT_CLEAR);
configuration_unlock_entry(config_entry, CELT_MULTIPART);
TRACE_OUT(clear_config_entry);
}
static struct cache_policy_item_ *
cache_lfu_policy_get_prev_item(struct cache_policy_ *policy,
struct cache_policy_item_ *item)
{
struct cache_lfu_policy_ *lfu_policy;
struct cache_lfu_policy_item_ *lfu_item;
int i;
TRACE_IN(cache_lfu_policy_get_prev_item);
lfu_policy = (struct cache_lfu_policy_ *)policy;
lfu_item = TAILQ_PREV((struct cache_lfu_policy_item_ *)item,
cache_lfu_policy_group_, entries);
if (lfu_item == NULL)
{
for (i = ((struct cache_lfu_policy_item_ *)item)->frequency - 1;
i >= 0; --i)
if (!TAILQ_EMPTY(&(lfu_policy->groups[i]))) {
lfu_item = TAILQ_LAST(&(lfu_policy->groups[i]),
cache_lfu_policy_group_);
break;
}
}
TRACE_OUT(cache_lfu_policy_get_prev_item);
return ((struct cache_policy_item_ *)lfu_item);
}
/*
* The functions below are used to process multipart read sessions read
* requests. User doesn't have to pass any kind of data, besides the
* request identificator itself. So we don't need any XXX_read functions and
* start with the XXX_process function.
* - on_mp_read_session_read_request_process processes it
* - on_mp_read_session_read_response_write1 and
* on_mp_read_session_read_response_write2 sends the response
*/
static int
on_mp_read_session_read_request_process(struct query_state *qstate)
{
struct cache_mp_read_session_read_response *read_response;
TRACE_IN(on_mp_read_session_response_process);
init_comm_element(&qstate->response, CET_MP_READ_SESSION_READ_RESPONSE);
read_response = get_cache_mp_read_session_read_response(
&qstate->response);
configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
read_response->error_code = cache_mp_read(
(cache_mp_read_session)qstate->mdata, NULL,
&read_response->data_size);
if (read_response->error_code == 0) {
read_response->data = malloc(read_response->data_size);
assert(read_response != NULL);
read_response->error_code = cache_mp_read(
(cache_mp_read_session)qstate->mdata,
read_response->data,
&read_response->data_size);
}
configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
if (read_response->error_code == 0)
qstate->kevent_watermark = sizeof(size_t) + sizeof(int);
else
qstate->kevent_watermark = sizeof(int);
qstate->process_func = on_mp_read_session_read_response_write1;
qstate->kevent_filter = EVFILT_WRITE;
TRACE_OUT(on_mp_read_session_response_process);
return (0);
}
/*
* Initializes the cache_policy_ structure by filling it with appropriate
* functions pointers
*/
struct cache_policy_ *
init_cache_lfu_policy(void)
{
int i;
struct cache_lfu_policy_ *retval;
TRACE_IN(init_cache_lfu_policy);
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent_data.create_item_func = cache_lfu_policy_create_item;
retval->parent_data.destroy_item_func = cache_lfu_policy_destroy_item;
retval->parent_data.add_item_func = cache_lfu_policy_add_item;
retval->parent_data.update_item_func = cache_lfu_policy_update_item;
retval->parent_data.remove_item_func = cache_lfu_policy_remove_item;
retval->parent_data.get_first_item_func =
cache_lfu_policy_get_first_item;
retval->parent_data.get_last_item_func =
cache_lfu_policy_get_last_item;
retval->parent_data.get_next_item_func =
cache_lfu_policy_get_next_item;
retval->parent_data.get_prev_item_func =
cache_lfu_policy_get_prev_item;
for (i = 0; i < CACHELIB_MAX_FREQUENCY; ++i)
TAILQ_INIT(&(retval->groups[i]));
TRACE_OUT(init_cache_lfu_policy);
return ((struct cache_policy_ *)retval);
}
int
configuration_entry_add_mp_cache_entry(struct configuration_entry *config_entry,
cache_entry c_entry)
{
cache_entry *new_mp_entries, *old_mp_entries;
TRACE_IN(configuration_entry_add_mp_cache_entry);
++config_entry->mp_cache_entries_size;
new_mp_entries = malloc(sizeof(*new_mp_entries) *
config_entry->mp_cache_entries_size);
assert(new_mp_entries != NULL);
new_mp_entries[0] = c_entry;
if (config_entry->mp_cache_entries_size - 1 > 0) {
memcpy(new_mp_entries + 1,
config_entry->mp_cache_entries,
(config_entry->mp_cache_entries_size - 1) *
sizeof(cache_entry));
}
old_mp_entries = config_entry->mp_cache_entries;
config_entry->mp_cache_entries = new_mp_entries;
free(old_mp_entries);
qsort(config_entry->mp_cache_entries,
config_entry->mp_cache_entries_size,
sizeof(cache_entry),
configuration_entry_cache_mp_sort_cmp);
TRACE_OUT(configuration_entry_add_mp_cache_entry);
return (0);
}
static int
on_mp_write_session_write_request_process(struct query_state *qstate)
{
struct cache_mp_write_session_write_request *write_request;
struct cache_mp_write_session_write_response *write_response;
TRACE_IN(on_mp_write_session_write_request_process);
init_comm_element(&qstate->response,
CET_MP_WRITE_SESSION_WRITE_RESPONSE);
write_response = get_cache_mp_write_session_write_response(
&qstate->response);
write_request = get_cache_mp_write_session_write_request(
&qstate->request);
configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
write_response->error_code = cache_mp_write(
(cache_mp_write_session)qstate->mdata,
write_request->data,
write_request->data_size);
configuration_unlock_entry(qstate->config_entry, CELT_MULTIPART);
qstate->kevent_watermark = sizeof(int);
qstate->process_func = on_mp_write_session_write_response_write1;
qstate->kevent_filter = EVFILT_WRITE;
TRACE_OUT(on_mp_write_session_write_request_process);
return (0);
}
/*
* Uses the qstate fields to process an "alternate" write - when the buffer is
* too large to be sent during one socket write operation
*/
ssize_t
query_io_buffer_write(struct query_state *qstate, const void *buf,
size_t nbytes)
{
ssize_t result;
TRACE_IN(query_io_buffer_write);
if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL))
return (-1);
if (nbytes < qstate->io_buffer + qstate->io_buffer_size -
qstate->io_buffer_p)
result = nbytes;
else
result = qstate->io_buffer + qstate->io_buffer_size -
qstate->io_buffer_p;
memcpy(qstate->io_buffer_p, buf, result);
qstate->io_buffer_p += result;
if (qstate->io_buffer_p == qstate->io_buffer + qstate->io_buffer_size) {
qstate->use_alternate_io = 1;
qstate->io_buffer_p = qstate->io_buffer;
qstate->write_func = query_socket_write;
qstate->read_func = query_socket_read;
}
TRACE_OUT(query_io_buffer_write);
return (result);
}
/*
* Clears the specified configuration entry by deleting only the elements,
* that are owned by the user with specified eid_str.
*/
static void
clear_config_entry_part(struct configuration_entry *config_entry,
const char *eid_str, size_t eid_str_length)
{
cache_entry *start, *finish, *mp_entry;
TRACE_IN(clear_config_entry_part);
configuration_lock_entry(config_entry, CELT_POSITIVE);
if (config_entry->positive_cache_entry != NULL)
transform_cache_entry_part(
config_entry->positive_cache_entry,
CTT_CLEAR, eid_str, eid_str_length, KPPT_LEFT);
configuration_unlock_entry(config_entry, CELT_POSITIVE);
configuration_lock_entry(config_entry, CELT_NEGATIVE);
if (config_entry->negative_cache_entry != NULL)
transform_cache_entry_part(
config_entry->negative_cache_entry,
CTT_CLEAR, eid_str, eid_str_length, KPPT_LEFT);
configuration_unlock_entry(config_entry, CELT_NEGATIVE);
configuration_lock_entry(config_entry, CELT_MULTIPART);
if (configuration_entry_find_mp_cache_entries(config_entry,
eid_str, &start, &finish) == 0) {
for (mp_entry = start; mp_entry != finish; ++mp_entry)
transform_cache_entry(*mp_entry, CTT_CLEAR);
}
configuration_unlock_entry(config_entry, CELT_MULTIPART);
TRACE_OUT(clear_config_entry_part);
}
/*
* Uses the qstate fields to process an "alternate" read - when the buffer is
* too large to be received during one socket read operation
*/
ssize_t
query_io_buffer_read(struct query_state *qstate, void *buf, size_t nbytes)
{
ssize_t result;
TRACE_IN(query_io_buffer_read);
if ((qstate->io_buffer_size == 0) || (qstate->io_buffer == NULL))
return (-1);
if (nbytes < qstate->io_buffer + qstate->io_buffer_size -
qstate->io_buffer_p)
result = nbytes;
else
result = qstate->io_buffer + qstate->io_buffer_size -
qstate->io_buffer_p;
memcpy(buf, qstate->io_buffer_p, result);
qstate->io_buffer_p += result;
if (qstate->io_buffer_p == qstate->io_buffer + qstate->io_buffer_size) {
free(qstate->io_buffer);
qstate->io_buffer = NULL;
qstate->write_func = query_socket_write;
qstate->read_func = query_socket_read;
}
TRACE_OUT(query_io_buffer_read);
return (result);
}
cache_entry register_new_mp_cache_entry(struct query_state *qstate,
const char *dec_cache_entry_name)
{
cache_entry c_entry;
char *en_bkp;
TRACE_IN(register_new_mp_cache_entry);
c_entry = INVALID_CACHE_ENTRY;
configuration_lock_entry(qstate->config_entry, CELT_MULTIPART);
configuration_lock_wrlock(s_configuration);
en_bkp = qstate->config_entry->mp_cache_params.cep.entry_name;
qstate->config_entry->mp_cache_params.cep.entry_name =
(char *)dec_cache_entry_name;
register_cache_entry(s_cache, (struct cache_entry_params *)
&qstate->config_entry->mp_cache_params);
qstate->config_entry->mp_cache_params.cep.entry_name = en_bkp;
configuration_unlock(s_configuration);
configuration_lock_rdlock(s_configuration);
c_entry = find_cache_entry(s_cache,
dec_cache_entry_name);
configuration_unlock(s_configuration);
configuration_entry_add_mp_cache_entry(qstate->config_entry,
c_entry);
configuration_unlock_entry(qstate->config_entry,
CELT_MULTIPART);
TRACE_OUT(register_new_mp_cache_entry);
return (c_entry);
}
void
configuration_unlock(struct configuration *config)
{
TRACE_IN(configuration_unlock);
pthread_rwlock_unlock(&config->rwlock);
TRACE_OUT(configuration_unlock);
}
/*
* Initializes cache_queue_policy_ by filling the structure with the functions
* pointers, defined above
*/
static struct cache_queue_policy_ *
init_cache_queue_policy(void)
{
struct cache_queue_policy_ *retval;
TRACE_IN(init_cache_queue_policy);
retval = calloc(1,
sizeof(*retval));
assert(retval != NULL);
retval->parent_data.create_item_func = cache_queue_policy_create_item;
retval->parent_data.destroy_item_func = cache_queue_policy_destroy_item;
retval->parent_data.add_item_func = cache_queue_policy_add_item;
retval->parent_data.remove_item_func = cache_queue_policy_remove_item;
retval->parent_data.get_first_item_func =
cache_queue_policy_get_first_item;
retval->parent_data.get_last_item_func =
cache_queue_policy_get_last_item;
retval->parent_data.get_next_item_func =
cache_queue_policy_get_next_item;
retval->parent_data.get_prev_item_func =
cache_queue_policy_get_prev_item;
TAILQ_INIT(&retval->head);
TRACE_OUT(init_cache_queue_policy);
return (retval);
}
LSearch::LSearch(int _dim, function_type _funct) : PSO(0.0, ///<The w parameter (influence of old vel - momentum)
0.0, ///<The minimum value for w -- decreased by time or level
0.0, ///<Influence of personal best
0.0, ///<Influence of global best
0.0, ///<vmax = vmaxRatio*xmax, with vmaxRatio=0 no vmax is enforced
0.0, ///<Constriction factor, used by #Bird
0, ///<Swarmsize
_dim, ///<Dimension of the search space
0, ///<Height of the pyramid, ignored for #seqSwarm
0, ///<Branches per node of the pyramid, ignored for #seqSwarm
0, ///<Swap allowed every swapDelay steps in #PyramidSwarm, ignored for #Swarm
_funct, ///<#function_type selection
noNoise, ///<#noiseStyle_type selection, set in #optFunction
0.0, ///<sigma parameter for gaussian distributed noise
seqSwarm) ///<#swarm_type selection
{
TRACE_IN("LSearch::LSearch");
DEBUG("New LSearch :");
DEBUG1("dim = ",_dim);
int a=0;
for (int i=0; i<get_dim(); i++)
currSolution.push_back(randDoubleRange(optFunction->get_min_x(), optFunction->get_max_x()));
currentVal = evalFunction(currSolution);
TRACE_OUT("LSearch::LSearch",0);
}
void
fill_configuration_defaults(struct configuration *config)
{
size_t len, i;
TRACE_IN(fill_configuration_defaults);
assert(config != NULL);
if (config->socket_path != NULL)
free(config->socket_path);
len = strlen(DEFAULT_SOCKET_PATH);
config->socket_path = calloc(1, len + 1);
assert(config->socket_path != NULL);
memcpy(config->socket_path, DEFAULT_SOCKET_PATH, len);
len = strlen(DEFAULT_PIDFILE_PATH);
config->pidfile_path = calloc(1, len + 1);
assert(config->pidfile_path != NULL);
memcpy(config->pidfile_path, DEFAULT_PIDFILE_PATH, len);
config->socket_mode = S_IFSOCK | S_IRUSR | S_IWUSR |
S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
config->force_unlink = 1;
config->query_timeout = DEFAULT_QUERY_TIMEOUT;
config->threads_num = DEFAULT_THREADS_NUM;
for (i = 0; i < config->entries_size; ++i)
destroy_configuration_entry(config->entries[i]);
config->entries_size = 0;
TRACE_OUT(fill_configuration_defaults);
}
void DpsAppendTarget(DPS_AGENT *Indexer, const char *url, const char *lang, const int hops, int parent) {
DPS_DOCUMENT *Doc, *Save;
size_t i;
TRACE_IN(Indexer, "AppendTarget");
DPS_GETLOCK(Indexer, DPS_LOCK_THREAD);
DPS_GETLOCK(Indexer, DPS_LOCK_CONF);
if (Indexer->Conf->Targets.num_rows > 0) {
for (i = Indexer->Conf->Targets.num_rows - 1; i > 0; i--) {
Doc = &Indexer->Conf->Targets.Doc[i];
if ((strcasecmp(DpsVarListFindStr(&Doc->Sections, "URL", ""), url) == 0)
&& (strcmp(DpsVarListFindStr(&Doc->RequestHeaders, "Accept-Language", ""), lang) == 0)) {
DPS_RELEASELOCK(Indexer, DPS_LOCK_CONF);
DPS_RELEASELOCK(Indexer, DPS_LOCK_THREAD);
TRACE_OUT(Indexer);
return;
}
}
}
if ((Indexer->Conf->Targets.Doc =
DpsRealloc(Save = Indexer->Conf->Targets.Doc, (Indexer->Conf->Targets.num_rows + 1) * sizeof(DPS_DOCUMENT))) == NULL) {
Indexer->Conf->Targets.Doc = Save;
DPS_RELEASELOCK(Indexer, DPS_LOCK_CONF);
DPS_RELEASELOCK(Indexer, DPS_LOCK_THREAD);
TRACE_OUT(Indexer);
return;
}
Doc = &Indexer->Conf->Targets.Doc[Indexer->Conf->Targets.num_rows];
DpsDocInit(Doc);
DpsVarListAddStr(&Doc->Sections, "URL", url);
DpsVarListAddInt(&Doc->Sections, "Hops", hops);
DpsVarListDel(&Doc->Sections, "URL_ID");
DpsVarListReplaceInt(&Doc->Sections, "Referrer-ID", parent);
if (*lang != '\0') DpsVarListAddStr(&Doc->RequestHeaders, "Accept-Language", lang);
if (DPS_OK == DpsURLAction(Indexer, Doc, DPS_URL_ACTION_FINDBYURL)) {
urlid_t url_id = DpsVarListFindInt(&Doc->Sections, "DP_ID", 0);
if (url_id != 0) Indexer->Conf->Targets.num_rows++;
else DpsDocFree(Doc);
}
/* fprintf(stderr, "-- AppandTarget: url:%s URL_ID:%d\n", url, DpsStrHash32(url));*/
DPS_RELEASELOCK(Indexer, DPS_LOCK_CONF);
DpsURLAction(Indexer, Doc, DPS_URL_ACTION_ADD);
DPS_RELEASELOCK(Indexer, DPS_LOCK_THREAD);
TRACE_OUT(Indexer);
return;
}
