/****** sge_client_ijs/stop_ijs_server() ***************************************
* NAME
* stop_ijs_server() -- stops the commlib server for the builtin
* interactive job support
*
* SYNOPSIS
* int stop_ijs_server(COMM_HANDLE **phandle, dstring *p_err_msg)
*
* FUNCTION
* Stops the commlib server for the commlib connection between the shepherd
* of the interactive job (qrsh/qlogin) and the qrsh/qlogin command.
* Over this connectin the stdin/stdout/stderr input/output is transferred.
*
* INPUTS
* COMM_HANDLE **phandle - Pointer to the COMM server handle. Gets set to
* NULL in this function.
* dstring *p_err_msg - Contains the error reason in case of error.
*
* RESULT
* int - 0: OK
* 1: Invalid Parameter: phandle = NULL
* 2: General error shutting down the COMM server,
* see p_err_msg for details
*
* NOTES
* MT-NOTE: stop_ijs_server() is not MT safe
*
* SEE ALSO
* sge_client_ijs/start_ijs_server()
* sge_client_ijs/run_ijs_server()
* sge_client_ijs/force_ijs_server_shutdown()
*******************************************************************************/
int stop_ijs_server(COMM_HANDLE **phandle, dstring *p_err_msg)
{
int ret = 0;
DENTER(TOP_LAYER, "stop_ijs_server");
if (phandle == NULL) {
ret = 1;
} else if (*phandle != NULL) {
cl_com_set_error_func(NULL);
#if 0
cl_log_list_set_log_level(cl_com_get_log_list(), CL_LOG_OFF);
#endif
cl_com_ignore_timeouts(CL_TRUE);
DPRINTF(("shut down the connection from our side\n"));
ret = cl_commlib_shutdown_handle(*phandle, CL_FALSE);
if (ret != CL_RETVAL_OK) {
sge_dstring_sprintf(p_err_msg, "error shutting down the connection: %s",
cl_get_error_text(ret));
ret = 2;
}
*phandle = NULL;
}
DRETURN(ret);
}
int main(int argc, char **argv)
{
int test = 1;
int my_error = 0;
cl_raw_list_t* list = NULL;
cl_raw_list_t* log_list = NULL;
my_error = cl_log_list_setup(&log_list, "test_dummy", 0, CL_LOG_FLUSHED , NULL);
printf("log list setup: %s\n", cl_get_error_text(my_error));
cl_log_list_set_log_level(log_list,CL_LOG_DEBUG);
cl_raw_list_setup(&list, "dummy_list",1);
cl_raw_list_append_elem( list , (void*) &test);
printf("list entries: %ld\n", cl_raw_list_get_elem_count(list));
my_error = CL_LOG(CL_LOG_INFO,"hallo");
printf("log: %s\n", cl_get_error_text(my_error));
printf("log list entries: %ld\n", cl_raw_list_get_elem_count(log_list));
cl_raw_list_remove_elem( list , cl_raw_list_search_elem( list, (void*) &test) );
printf("list entries: %ld\n", cl_raw_list_get_elem_count(list));
my_error = cl_raw_list_cleanup(&list);
if ( my_error != CL_RETVAL_OK) {
printf("error cl_raw_list_cleanup() -> %s\n", cl_get_error_text(my_error));
exit(1);
}
while (argc>1) {
dummy(argv[argc-1]);
argc--;
}
cl_log_list_cleanup(&log_list);
return 0;
}
extern int main(int argc, char** argv)
{
cl_raw_list_t* log_list = NULL;
cl_thread_settings_t* thread_p = NULL;
cl_thread_settings_t* log_thread = NULL;
cl_thread_settings_t* dummy_thread_p = NULL;
int count = 2;
if (argc != 2) {
printf("please enter 0 for standard log function, 1 for special\n");
exit(1);
}
/* setup log list */
if (atoi(argv[1]) == 0) {
cl_log_list_setup(&log_list,"application",0,CL_LOG_IMMEDIATE, NULL);
} else {
cl_log_list_setup(&log_list,"application",0,CL_LOG_IMMEDIATE, my_log_flush_list);
}
/* setup log thread */
log_thread = (cl_thread_settings_t*) malloc(sizeof(cl_thread_settings_t));
cl_thread_setup(log_thread, log_list, "log thread", 1,my_log_thread, NULL, NULL, CL_TT_USER1);
cl_log_list_set_log_level(log_list,CL_LOG_DEBUG );
/* setup thread list */
cl_thread_list_setup(&thread_list,"thread list");
/* setup first thread */
cl_thread_list_create_thread(thread_list, &dummy_thread_p, log_list, "1st thread", 1, my_test_thread, NULL, NULL, CL_TT_USER1);
/* setup second thread */
cl_thread_list_create_thread(thread_list, &dummy_thread_p, log_list, "2nd thread", 2, my_test_thread, NULL, NULL, CL_TT_USER1);
thread_p = cl_thread_list_get_thread_by_id(thread_list, 1);
CL_LOG_STR( CL_LOG_INFO, "My thread name is ", thread_p->thread_name );
thread_p = cl_thread_list_get_thread_by_name(thread_list, "2nd thread");
CL_LOG_STR( CL_LOG_INFO, "My thread name is ", thread_p->thread_name );
while ( count < 10 ) {
int id;
char new_thread_name[255];
count++;
CL_LOG_INT(CL_LOG_INFO, "number of threads: ", (int)cl_raw_list_get_elem_count(thread_list) );
thread_p = cl_thread_list_get_first_thread(thread_list);
id = thread_p->thread_id;
CL_LOG_INT( CL_LOG_INFO, "delete thread: ", id );
cl_thread_list_delete_thread_by_id(thread_list, id);
CL_LOG_INT(CL_LOG_INFO, "thread deleted, id: ", id );
sprintf(new_thread_name,"thread nr %d", count);
CL_LOG( CL_LOG_INFO, "adding thread ...");
cl_thread_list_create_thread(thread_list,&dummy_thread_p, log_list,new_thread_name, id, my_test_thread, NULL, NULL, CL_TT_USER1);
CL_LOG( CL_LOG_INFO, "adding thread done");
}
/* remove all threads from thread list */
while ( (thread_p=cl_thread_list_get_first_thread(thread_list)) != NULL ) {
int id = thread_p->thread_id;
CL_LOG_INT( CL_LOG_INFO, "delete thread: ", id );
CL_LOG_INT( CL_LOG_INFO, "event calls: ", (int)thread_p->thread_event_count );
cl_thread_list_delete_thread_by_id(thread_list, id);
CL_LOG_INT( CL_LOG_INFO, "thread deleted, id: ", id );
}
CL_LOG_INT( CL_LOG_INFO, "log event calls: ", (int)log_thread->thread_event_count );
CL_LOG( CL_LOG_INFO, "cleaning up thread list");
cl_thread_list_cleanup(&thread_list);
/* shutdown of log thread */
cl_thread_shutdown(log_thread);
cl_thread_join(log_thread);
cl_thread_cleanup(log_thread);
free(log_thread);
/* cleanup log list */
CL_LOG( CL_LOG_INFO, "cleaning up log list");
printf( "cl_log_list_cleanup() returned: %s\n", cl_get_error_text(cl_log_list_cleanup(&log_list)));
printf("main done\n");
return 0;
}
/****** commlib_to_tty() *******************************************************
* NAME
* commlib_to_tty() -- commlib_to_tty thread entry point and main loop
*
* SYNOPSIS
* void* commlib_to_tty(void *t_conf)
*
* FUNCTION
* Entry point and main loop of the commlib_to_tty thread.
* Reads data from the commlib and writes it to the tty.
*
* INPUTS
* void *t_conf - pointer to cl_thread_settings_t struct of the thread
*
* RESULT
* void* - always NULL
*
* NOTES
* MT-NOTE: commlib_to_tty is MT-safe ?
*
* SEE ALSO
*******************************************************************************/
void* commlib_to_tty(void *t_conf)
{
recv_message_t recv_mess;
dstring err_msg = DSTRING_INIT;
int ret = 0, do_exit = 0;
DENTER(TOP_LAYER, "commlib_to_tty");
thread_func_startup(t_conf);
while (do_exit == 0) {
/*
* wait blocking for a message from commlib
*/
recv_mess.cl_message = NULL;
recv_mess.data = NULL;
DPRINTF(("commlib_to_tty: recv_message()\n"));
ret = comm_recv_message(g_comm_handle, CL_TRUE, &recv_mess, &err_msg);
if (ret != COMM_RETVAL_OK) {
/* check if we are still connected to anybody. */
/* if not - exit. */
DPRINTF(("commlib_to_tty: error receiving message: %s\n",
sge_dstring_get_string(&err_msg)));
if (comm_get_connection_count(g_comm_handle, &err_msg) == 0) {
DPRINTF(("commlib_to_tty: no endpoint found\n"));
do_exit = 1;
continue;
}
}
DPRINTF(("commlib_to_tty: received a message\n"));
thread_testcancel(t_conf);
client_check_window_change(g_comm_handle);
if (received_signal == SIGHUP ||
received_signal == SIGINT ||
received_signal == SIGQUIT ||
received_signal == SIGTERM) {
/* If we receive one of these signals, we must terminate */
DPRINTF(("commlib_to_tty: shutting down because of signal %d\n",
received_signal));
do_exit = 1;
continue;
}
DPRINTF(("'parsing' message\n"));
/*
* 'parse' message
* A 1 byte prefix tells us what kind of message it is.
* See sge_ijs_comm.h for message types.
*/
if (recv_mess.cl_message != NULL) {
char buf[100];
switch (recv_mess.type) {
case STDOUT_DATA_MSG:
/* copy recv_mess.data to buf to append '\0' */
memcpy(buf, recv_mess.data, MIN(99, recv_mess.cl_message->message_length - 1));
buf[MIN(99, recv_mess.cl_message->message_length - 1)] = 0;
DPRINTF(("commlib_to_tty: received stdout message, writing to tty.\n"));
DPRINTF(("commlib_to_tty: message is: %s\n", buf));
/* TODO: If it's not possible to write all data to the tty, retry blocking
* until all data was written. The commlib must block then, too.
*/
if (sge_writenbytes(STDOUT_FILENO, recv_mess.data,
(int)(recv_mess.cl_message->message_length-1))
!= (int)(recv_mess.cl_message->message_length-1)) {
DPRINTF(("commlib_to_tty: sge_writenbytes() error\n"));
}
break;
case STDERR_DATA_MSG:
DPRINTF(("commlib_to_tty: received stderr message, writing to tty.\n"));
/* TODO: If it's not possible to write all data to the tty, retry blocking
* until all data was written. The commlib must block then, too.
*/
if (sge_writenbytes(STDERR_FILENO, recv_mess.data,
(int)(recv_mess.cl_message->message_length-1))
!= (int)(recv_mess.cl_message->message_length-1)) {
DPRINTF(("commlib_to_tty: sge_writenbytes() error\n"));
}
break;
case WINDOW_SIZE_CTRL_MSG:
/* control message */
/* we don't expect a control message */
DPRINTF(("commlib_to_tty: received window size message! "
"This was unexpected!\n"));
break;
case REGISTER_CTRL_MSG:
/* control message */
/* a client registered with us. With the next loop, the
* cl_commlib_trigger function will send the WINDOW_SIZE_CTRL_MSG
* (and perhaps some data messages), which is already in the
* send_messages list of the connection, to the client.
*/
DPRINTF(("commlib_to_tty: received register message!\n"));
/* Send the settings in response */
sprintf(buf, "noshell = %d", g_noshell);
ret = (int)comm_write_message(g_comm_handle, g_hostname, COMM_CLIENT, 1,
(unsigned char*)buf, strlen(buf)+1, SETTINGS_CTRL_MSG, &err_msg);
DPRINTF(("commlib_to_tty: sent SETTINGS_CTRL_MSG, ret = %d\n", ret));
break;
case UNREGISTER_CTRL_MSG:
/* control message */
/* the client wants to quit, as this is the last message the client
* sends, we can be sure to have received all messages from the
* client. We answer with a UNREGISTER_RESPONSE_CTRL_MSG so
* the client knows that it can quit now. We can quit, also.
*/
DPRINTF(("commlib_to_tty: received unregister message!\n"));
DPRINTF(("commlib_to_tty: writing UNREGISTER_RESPONSE_CTRL_MSG\n"));
/* copy recv_mess.data to buf to append '\0' */
memcpy(buf, recv_mess.data, MIN(99, recv_mess.cl_message->message_length - 1));
buf[MIN(99, recv_mess.cl_message->message_length - 1)] = 0;
/* the UNREGISTER_CTRL_MSG contains the exit status of the
* qrsh_starter in case of qrsh <command> and the exit status
* of the shell for qlogin/qrsh <no command>.
* If the job was signalled, the exit code is 128+signal.
*/
sscanf(buf, "%d", &g_exit_status);
comm_write_message(g_comm_handle, g_hostname, COMM_CLIENT, 1,
(unsigned char*)" ", 1, UNREGISTER_RESPONSE_CTRL_MSG, &err_msg);
DPRINTF(("commlib_to_tty: received exit_status from shepherd: %d\n",
g_exit_status));
comm_flush_write_messages(g_comm_handle, &err_msg);
do_exit = 1;
#if 0
cl_log_list_set_log_level(cl_com_get_log_list(), CL_LOG_OFF);
cl_com_set_error_func(NULL);
#endif
break;
}
}
comm_free_message(&recv_mess, &err_msg);
}
thread_func_cleanup(t_conf);
DPRINTF(("commlib_to_tty: exiting commlib_to_tty thread!\n"));
sge_dstring_free(&err_msg);
DEXIT;
return NULL;
}
