static bool
sge_gdi_task_verify(sge_gdi_task_class_t * task, lList **answer_list)
{
bool ret = true;
#if 0
int operation = 0;
lList *list = NULL;
u_long32 target = 0;
#endif
DENTER(TOP_LAYER, "sge_gdi_task_verify");
#if 0
operation = SGE_GDI_GET_OPERATION(task->command);
list = task->data_list;
target = task->target;
/* EB: TODO: this check does not work for AR objects why? */
if (!list
&& !(operation == SGE_GDI_PERMCHECK || operation == SGE_GDI_GET
|| operation == SGE_GDI_TRIGGER || (operation == SGE_GDI_DEL
&& target ==
SGE_STN_LIST))
) {
answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC,
ANSWER_QUALITY_ERROR, MSG_GDI_GDI_VERIFY_REQUEST_FAILED);
ret = false;
}
#endif
DRETURN(ret);
}
void *
sge_worker_main(void *arg)
{
bool do_endlessly = true;
cl_thread_settings_t *thread_config = (cl_thread_settings_t*)arg;
sge_gdi_ctx_class_t *ctx = NULL;
monitoring_t monitor;
monitoring_t *monitorp = &monitor;
time_t next_prof_output = 0;
DENTER(TOP_LAYER, "sge_worker_main");
DPRINTF(("started"));
cl_thread_func_startup(thread_config);
sge_monitor_init(&monitor, thread_config->thread_name, GDI_EXT, MT_WARNING, MT_ERROR);
sge_qmaster_thread_init(&ctx, QMASTER, WORKER_THREAD, true);
/* register at profiling module */
set_thread_name(pthread_self(), "Worker Thread");
conf_update_thread_profiling("Worker Thread");
while (do_endlessly) {
sge_gdi_packet_class_t *packet = NULL;
/*
* Wait for packets. As long as packets are available cancelation
* of this thread is ignored. The shutdown procedure in the main
* thread takes care that packet producers will be terminated
* before all worker threads so that this won't be a problem.
*/
MONITOR_IDLE_TIME(
sge_tq_wait_for_task(Master_Task_Queue, 1, SGE_TQ_GDI_PACKET, (void *)&packet),
&monitor, mconf_get_monitor_time(), mconf_is_monitor_message());
MONITOR_SET_QLEN((monitorp), sge_tq_get_task_count(Master_Task_Queue));
if (packet != NULL) {
sge_gdi_task_class_t *task = packet->first_task;
bool is_only_read_request = true;
thread_start_stop_profiling();
#ifdef SEND_ANSWER_IN_LISTENER
#else
/*
* prepare buffer for sending an answer
*/
if (packet->is_intern_request == false && packet->is_gdi_request == true) {
init_packbuffer(&(packet->pb), 0, 0);
}
#endif
MONITOR_MESSAGES((monitorp));
if (packet->is_gdi_request == true) {
/*
* test if a write lock is necessary
*/
task = packet->first_task;
while (task != NULL) {
u_long32 command = SGE_GDI_GET_OPERATION(task->command);
if (command != SGE_GDI_GET) {
is_only_read_request = false;
break;
}
task = task->next;
}
} else {
is_only_read_request = false;
}
/*
* acquire the correct lock
*/
if (is_only_read_request) {
MONITOR_WAIT_TIME(SGE_LOCK(LOCK_GLOBAL, LOCK_READ), monitorp);
} else {
MONITOR_WAIT_TIME(SGE_LOCK(LOCK_GLOBAL, LOCK_WRITE), monitorp);
}
if (packet->is_gdi_request == true) {
/*
* do the GDI request
*/
task = packet->first_task;
while (task != NULL) {
sge_c_gdi(ctx, packet, task, &(task->answer_list), &monitor);
task = task->next;
}
} else {
task = packet->first_task;
sge_c_report(ctx, packet->host, packet->commproc, packet->commproc_id,
task->data_list, &monitor);
}
/*
* do unlock
*/
if (is_only_read_request) {
SGE_UNLOCK(LOCK_GLOBAL, LOCK_READ)
} else {
SGE_UNLOCK(LOCK_GLOBAL, LOCK_WRITE)
}
if (packet->is_gdi_request == true) {
#ifdef SEND_ANSWER_IN_LISTENER
sge_gdi_packet_broadcast_that_handled(packet);
#else
/*
* Send the answer to the client
*/
if (packet->is_intern_request == false) {
MONITOR_MESSAGES_OUT(monitorp);
sge_gdi2_send_any_request(ctx, 0, NULL,
packet->host, packet->commproc, packet->commproc_id,
&(packet->pb), TAG_GDI_REQUEST,
packet->response_id, NULL);
clear_packbuffer(&(packet->pb));
# ifdef BLOCK_LISTENER
sge_gdi_packet_broadcast_that_handled(packet);
# else
sge_gdi_packet_free(&packet);
# endif
/*
* Code only for TS:
*
* Following if-block will only be executed in testsuite if the qmaster
* parameter __TEST_SLEEP_AFTER_REQUEST is defined. This will block the
* worker thread if it handled a request. Only this makes sure that
* other worker threads can handle incoming requests. Otherwise
* it might be possible that one worker threads handles all requests
* on fast qmaster hosts if testsuite is not fast enough to generate
* gdi requests.
*/
if (mconf_get_enable_test_sleep_after_request() == true) {
sleep(5);
}
} else {
sge_gdi_packet_broadcast_that_handled(packet);
/* this is an internal request, packet will get destroyed later,
* where the caller waits for the answer
* make sure it is no longer accessed here
*/
packet = NULL;
}
#endif
} else {
sge_gdi_packet_free(&packet);
}
thread_output_profiling("worker thread profiling summary:\n",
&next_prof_output);
sge_monitor_output(&monitor);
} else {
