/****** 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; }