/****** 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);
}
/*
* commlib error callback function
*/
void on_communication_error(const cl_application_error_list_elem_t* commlib_error) {
if (commlib_error != NULL) {
/* print any communication error to stderr: */
fprintf(stderr, "COMMLIB ERROR: %s (%s)\n",
cl_get_error_text(commlib_error->cl_error),
commlib_error->cl_info);
}
}
static int shadowd_is_old_master_enrolled(int sge_test_heartbeat, int sge_qmaster_port, char *oldqmaster)
{
cl_com_handle_t* handle = NULL;
cl_com_SIRM_t* status = NULL;
int ret;
int is_up_and_running = 0;
int commlib_error = CL_RETVAL_OK;
DENTER(TOP_LAYER, "shadowd_is_old_master_enrolled");
/*
* This is for testsuite testing to simulate qmaster outage.
* For testing the environment variable SGE_TEST_HEARTBEAT_TIMEOUT
* has to be set!
*/
if (sge_test_heartbeat > 0) {
DRETURN(is_up_and_running);
}
handle=cl_com_create_handle(&commlib_error, CL_CT_TCP, CL_CM_CT_MESSAGE, CL_FALSE, sge_qmaster_port, CL_TCP_DEFAULT,(char*)prognames[SHADOWD] , 0, 1,0 );
if (handle == NULL) {
CRITICAL((SGE_EVENT, SFNMAX, cl_get_error_text(commlib_error)));
DRETURN(is_up_and_running);
}
DPRINTF(("Try to send status information message to previous master host "SFQ" to port %ld\n", oldqmaster, sge_qmaster_port));
ret = cl_commlib_get_endpoint_status(handle,oldqmaster ,(char*)prognames[QMASTER] , 1, &status);
if (ret != CL_RETVAL_OK) {
DPRINTF(("cl_commlib_get_endpoint_status() returned "SFQ"\n", cl_get_error_text(ret)));
is_up_and_running = 0;
DPRINTF(("old qmaster not responding - No master found\n"));
} else {
DPRINTF(("old qmaster is still running\n"));
is_up_and_running = 1;
}
if (status != NULL) {
DPRINTF(("endpoint is up since %ld seconds and has status %ld\n", status->runtime, status->application_status));
cl_com_free_sirm_message(&status);
}
cl_commlib_shutdown_handle(handle,CL_FALSE);
DRETURN(is_up_and_running);
}
static void gethostbyaddr_communication_error(const cl_application_error_list_elem_t* commlib_error)
{
if (commlib_error != NULL) {
switch (commlib_error->cl_err_type) {
case CL_LOG_ERROR: {
if (commlib_error->cl_info != NULL) {
fprintf(stderr, "%s: %s\n", cl_get_error_text(commlib_error->cl_error), commlib_error->cl_info);
} else {
fprintf(stderr, "%s\n", cl_get_error_text(commlib_error->cl_error));
}
error_reported = 1;
break;
}
default: {
break;
}
}
}
}
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;
}
/****** spool/utilities/spool_default_validate_func() ****************
* NAME
* spool_default_validate_func() -- validate objects
*
* SYNOPSIS
* bool
* spool_default_validate_func(lList **answer_list,
* const lListElem *type,
* const lListElem *rule,
* const lListElem *object,
* const char *key,
* const sge_object_type object_type)
*
* FUNCTION
* Verifies an object.
*
* INPUTS
* lList **answer_list - to return error messages
* const lListElem *type - object type description
* const lListElem *rule - rule to use
* const lListElem *object - object to validate
* const sge_object_type object_type - object type
*
* RESULT
* bool - true on success, else false
*
* NOTES
* This function should not be called directly, it is called by the
* spooling framework.
*
* SEE ALSO
*******************************************************************************/
bool spool_default_validate_func(lList **answer_list,
const lListElem *type,
const lListElem *rule,
lListElem *object,
const sge_object_type object_type)
{
bool ret = true;
DENTER(TOP_LAYER, "spool_default_validate_func");
switch(object_type) {
case SGE_TYPE_ADMINHOST:
case SGE_TYPE_EXECHOST:
case SGE_TYPE_SUBMITHOST:
{
int cl_ret;
int key_nm = object_type_get_key_nm(object_type);
char *old_name = strdup(lGetHost(object, key_nm));
/* try hostname resolving */
if (strcmp(old_name, SGE_GLOBAL_NAME) != 0) {
cl_ret = sge_resolve_host(object, key_nm);
/* if hostname resolving failed: create error */
if (cl_ret != CL_RETVAL_OK) {
if (cl_ret != CL_RETVAL_GETHOSTNAME_ERROR) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_SPOOL_CANTRESOLVEHOSTNAME_SS,
old_name, cl_get_error_text(ret));
ret = false;
} else {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_WARNING,
MSG_SPOOL_CANTRESOLVEHOSTNAME_SS,
old_name, cl_get_error_text(ret));
}
} else {
/* if hostname resolving changed hostname: spool */
const char *new_name;
new_name = lGetHost(object, key_nm);
if (strcmp(old_name, new_name) != 0) {
spooling_write_func write_func =
(spooling_write_func)lGetRef(rule, SPR_write_func);
spooling_delete_func delete_func =
(spooling_delete_func)lGetRef(rule, SPR_delete_func);
write_func(answer_list, type, rule, object, new_name,
object_type);
delete_func(answer_list, type, rule, old_name, object_type);
}
}
}
sge_free(&old_name);
if (object_type == SGE_TYPE_EXECHOST && ret) {
lListElem *load_value;
lList *master_centry_list = *object_type_get_master_list(SGE_TYPE_CENTRY);
/* all spooled load values are static, therefore we tag them here */
for_each(load_value, lGetList(object, EH_load_list)) {
lSetBool(load_value, HL_static, true);
}
/* necessary to init double values of consumable configuration */
centry_list_fill_request(lGetList(object, EH_consumable_config_list),
NULL, master_centry_list, true, false, true);
/* necessary to setup actual list of exechost */
debit_host_consumable(NULL, object, master_centry_list, 0, true, NULL);
if (ensure_attrib_available(NULL, object,
EH_consumable_config_list)) {
ret = false;
}
}
}
/* return
0 reaped a task cleanly
1 no message (asynchronuous mode)
-1 got an error
NOTES
MT-NOTE: rcv_from_execd() is not MT safe
*/
static int rcv_from_execd(sge_gdi_ctx_class_t *ctx, int options, int tag)
{
int ret;
char *msg = NULL;
u_long32 msg_len = 0;
sge_pack_buffer pb;
u_short from_id;
char host[1024];
lListElem *rt_rcv;
u_long32 exit_status=0;
sge_tid_t tid = NULL;
DENTER(TOP_LAYER, "rcv_from_execd");
host[0] = '\0';
from_id = 1;
do {
/* FIX_CONST */
ret = gdi2_receive_message(ctx, (char*)prognames[EXECD], &from_id, host, &tag,
&msg, &msg_len, (options & OPT_SYNCHRON) ? 1:0);
if (ret != CL_RETVAL_OK && ret != CL_RETVAL_SYNC_RECEIVE_TIMEOUT) {
sprintf(lasterror, MSG_GDI_MESSAGERECEIVEFAILED_SI , cl_get_error_text(ret), ret);
DEXIT;
return -1;
}
} while (options&OPT_SYNCHRON && ret == CL_RETVAL_SYNC_RECEIVE_TIMEOUT);
if (ret==CL_RETVAL_SYNC_RECEIVE_TIMEOUT) {
DEXIT;
return 1;
}
ret = init_packbuffer_from_buffer(&pb, msg, msg_len);
if(ret != PACK_SUCCESS) {
sprintf(lasterror, MSG_GDI_ERRORUNPACKINGGDIREQUEST_S, cull_pack_strerror(ret));
DEXIT;
return -1;
}
switch (tag) {
case TAG_TASK_EXIT:
unpackstr(&pb, &tid);
unpackint(&pb, &exit_status);
break;
case TAG_JOB_EXECUTION:
unpackstr(&pb, &tid);
break;
default:
break;
}
clear_packbuffer(&pb);
switch (tag) {
case TAG_TASK_EXIT:
/* change state in exited task */
if (!(rt_rcv = lGetElemStr(remote_task_list, RT_tid,
tid))) {
sprintf(lasterror, MSG_GDI_TASKNOTFOUND_S, tid);
sge_free(&tid);
DEXIT;
return -1;
}
lSetUlong(rt_rcv, RT_status, exit_status);
lSetUlong(rt_rcv, RT_state, RT_STATE_EXITED);
break;
case TAG_JOB_EXECUTION:
/* search task without taskid */
if (!(rt_rcv = lGetElemStr(remote_task_list, RT_tid, "none"))) {
sprintf(lasterror, MSG_GDI_TASKNOTFOUNDNOIDGIVEN_S , tid);
DEXIT;
return -1;
}
lSetString(rt_rcv, RT_tid, tid);
break;
default:
break;
}
sge_free(&tid);
DEXIT;
return 0;
}
/****** gdi/sge/sge_qexecve() ************************************************
* NAME
* sge_qexecve() -- start a task in a tightly integrated par. job
*
* SYNOPSIS
* sge_tid_t sge_qexecve(const char *hostname, const char *queuename,
* const char *cwd, const lList *environment
* const lList *path_aliases)
*
* FUNCTION
* Starts a task in a tightly integrated job.
* Builds a job object describing the task,
* connects to the commd on the targeted execution host,
* deliveres the job object and waits for an answer.
* The answer from the execution daemon on the execution host
* contains a task id that is returned to the caller of the function.
*
* INPUTS
* const char *hostname - name of the host on which to start the task
* const lList *environment - list containing environment variable
* settings for the task that override the
* default environment
* const lList *path_aliases - optional a path alias list
*
* RESULT
* sge_tid_t - the task id, if the task can be executed,
* a value <= 0 indicates an error.
*
* NOTES
* MT-NOTE: sge_qexecve() is not MT safe
******************************************************************************/
sge_tid_t sge_qexecve(sge_gdi_ctx_class_t *ctx,
const char *hostname, const char *queuename,
const char *cwd, const lList *environment,
const lList *path_aliases)
{
char myname[256];
const char *s;
int ret, uid;
sge_tid_t tid = NULL;
lListElem *petrep;
lListElem *rt;
sge_pack_buffer pb;
u_long32 jobid, jataskid;
u_long32 dummymid = 0;
const char *env_var_name = "SGE_TASK_ID";
DENTER(TOP_LAYER, "sge_qexecve");
if (hostname == NULL) {
sprintf(lasterror, MSG_GDI_INVALIDPARAMETER_SS, "sge_qexecve", "hostname");
DRETURN(NULL);
}
/* resolve user */
if (sge_uid2user((uid=getuid()), myname, sizeof(myname)-1, MAX_NIS_RETRIES)) {
sprintf(lasterror, MSG_GDI_RESOLVINGUIDTOUSERNAMEFAILED_IS ,
uid, strerror(errno));
DRETURN(NULL);
}
if ((s=getenv("JOB_ID")) == NULL) {
sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, "JOB_ID");
DRETURN(NULL);
}
if (sscanf(s, sge_u32, &jobid) != 1) {
sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, "JOB_ID");
DRETURN(NULL);
}
if ((s=getenv(env_var_name)) != NULL) {
if (strcmp(s, "undefined") == 0) {
jataskid = 1;
} else {
if (sscanf(s, sge_u32, &jataskid) != 1) {
sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, env_var_name);
DRETURN(NULL);
}
}
} else {
sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, env_var_name);
DRETURN(NULL);
}
/* ---- build up pe task request structure (see gdilib/sge_petaskL.h) */
petrep = lCreateElem(PETR_Type);
lSetUlong(petrep, PETR_jobid, jobid);
lSetUlong(petrep, PETR_jataskid, jataskid);
lSetString(petrep, PETR_owner, myname);
lSetUlong(petrep, PETR_submission_time, sge_get_gmt());
if (cwd != NULL) {
lSetString(petrep, PETR_cwd, cwd);
}
if (environment != NULL) {
lSetList(petrep, PETR_environment, lCopyList("environment", environment));
}
if (path_aliases != NULL) {
lSetList(petrep, PETR_path_aliases, lCopyList("path_aliases", path_aliases));
}
if (queuename != NULL) {
lSetString(petrep, PETR_queuename, queuename);
}
if (init_packbuffer(&pb, 1024, 0) != PACK_SUCCESS) {
lFreeElem(&petrep);
sprintf(lasterror, SFNMAX, MSG_GDI_OUTOFMEMORY);
DRETURN(NULL);
}
pack_job_delivery(&pb, petrep);
ret = gdi2_send_message_pb(ctx, 1, prognames[EXECD], 1, hostname,
TAG_JOB_EXECUTION, &pb, &dummymid);
clear_packbuffer(&pb);
lFreeElem(&petrep);
if (ret != CL_RETVAL_OK) {
sprintf(lasterror, MSG_GDI_SENDTASKTOEXECDFAILED_SS, hostname, cl_get_error_text(ret));
DRETURN(NULL);
}
/* add list into our remote task list */
rt = lAddElemStr(&remote_task_list, RT_tid, "none", RT_Type);
lSetHost(rt, RT_hostname, hostname);
lSetUlong(rt, RT_state, RT_STATE_WAIT4ACK);
rcv_from_execd(ctx, OPT_SYNCHRON, TAG_JOB_EXECUTION);
tid = (sge_tid_t) lGetString(rt, RT_tid);
if (strcmp(tid, "none") == 0) {
tid = NULL;
sprintf(lasterror, MSG_GDI_EXECDONHOSTDIDNTACCEPTTASK_S, hostname);
}
/* now close message to execd */
cl_commlib_shutdown_handle(cl_com_get_handle("execd_handle", 0), false);
DRETURN(tid);
}
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;
}
extern int main(int argc, char** argv)
{
struct sigaction sa;
static int runs = 100;
cl_com_handle_t* handle = NULL;
cl_com_message_t* message = NULL;
cl_com_endpoint_t* sender = NULL;
int bytes_received = 0;
unsigned long total_bytes_sent = 0;
unsigned long total_bytes_received = 0;
unsigned long total_connections = 0;
unsigned long total_connection_sum = 0;
#if 1
char* welcome_text = "Welcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\nWelcome to the tcp framework module!Welcome to the tcp framework module!Welcome to the tcp framework module!\n";
#else
char* welcome_text = "This message is from thread 1";
#endif
struct timeval now;
long start_time;
long appl_start_time;
long end_time;
int retval = CL_RETVAL_PARAMS;
int welcome_text_size;
int close_connection = 0;
unsigned long last_mid = 0;
int i;
cl_framework_t framework = CL_CT_TCP;
cl_xml_connection_autoclose_t autoclose;
/* setup signalhandling */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sighandler_client; /* one handler for all signals */
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGPIPE, &sa, NULL);
if (argc < 7) {
printf("wrong parameters, param1 = server host, param2 = port number, param3 = client id, param4=debug_level, param5=sleep time, param6=do_close, [param7=framework(TCP/SSL)]\n");
exit(1);
}
prof_mt_init();
cl_com_setup_commlib(CL_NO_THREAD, (cl_log_t)atoi(argv[4]), NULL);
if (atoi(argv[6]) != 0) {
close_connection = 1;
}
if (argv[7]) {
framework = CL_CT_UNDEFINED;
if (strcmp(argv[7], "TCP") == 0) {
framework=CL_CT_TCP;
printf("using TCP framework\n");
}
if (strcmp(argv[7], "SSL") == 0) {
framework=CL_CT_SSL;
printf("using SSL framework\n");
}
if (framework == CL_CT_UNDEFINED) {
printf("unexpected framework type\n");
exit(1);
}
}
cl_com_set_alias_file("./alias_file");
if ( framework == CL_CT_SSL) {
cl_ssl_setup_t ssl_config;
ssl_config.ssl_method = CL_SSL_v23; /* v23 method */
ssl_config.ssl_CA_cert_pem_file = getenv("SSL_CA_CERT_FILE"); /* CA certificate file */
ssl_config.ssl_CA_key_pem_file = NULL; /* private certificate file of CA (not used) */
ssl_config.ssl_cert_pem_file = getenv("SSL_CERT_FILE"); /* certificates file */
ssl_config.ssl_key_pem_file = getenv("SSL_KEY_FILE"); /* key file */
ssl_config.ssl_rand_file = getenv("SSL_RAND_FILE"); /* rand file (if RAND_status() not ok) */
ssl_config.ssl_crl_file = getenv("SSL_CRL_FILE"); /* revocation list file */
ssl_config.ssl_reconnect_file = NULL; /* file for reconnect data (not used) */
ssl_config.ssl_refresh_time = 0; /* key alive time for connections (not used) */
ssl_config.ssl_password = NULL; /* password for encrypted keyfiles (not used) */
ssl_config.ssl_verify_func = NULL; /* function callback for peer user/name check */
if (ssl_config.ssl_CA_cert_pem_file == NULL ||
ssl_config.ssl_cert_pem_file == NULL ||
ssl_config.ssl_key_pem_file == NULL ||
ssl_config.ssl_rand_file == NULL) {
printf("please set the following environment variables:\n");
printf("SSL_CA_CERT_FILE = CA certificate file\n");
printf("SSL_CERT_FILE = certificates file\n");
printf("SSL_KEY_FILE = key file\n");
printf("(optional) SSL_RAND_FILE = rand file (if RAND_status() not ok)\n");
}
cl_com_specify_ssl_configuration(&ssl_config);
}
CL_LOG_STR(CL_LOG_INFO,"connection to server on host", argv[1]);
CL_LOG_INT(CL_LOG_INFO,"using port",atoi(argv[2]));
CL_LOG_STR(CL_LOG_INFO,"component is","client");
CL_LOG_INT(CL_LOG_INFO,"id ist",atoi(argv[3]));
#define SELECT_TIMEOUT 1
#if 0
#define CREATE_SERVICE
#endif
#ifdef CREATE_SERVICE
cl_com_append_known_endpoint_from_name(argv[1], "server", 1,atoi(argv[2]),CL_CM_AC_DISABLED , 1);
handle=cl_com_create_handle(NULL,framework,CL_CM_CT_MESSAGE , CL_TRUE, 0 , CL_TCP_DEFAULT, "client", atoi(argv[3]),SELECT_TIMEOUT,0 );
if (handle == NULL) {
printf("could not get handle\n");
exit(1);
} else {
int my_port;
cl_com_get_service_port(handle,&my_port);
printf("I'm reachable at port %d!\n", my_port);
}
#else
handle=cl_com_create_handle(NULL,framework,CL_CM_CT_MESSAGE , CL_FALSE, atoi(argv[2]) , CL_TCP_DEFAULT,"client", atoi(argv[3]),SELECT_TIMEOUT,0 );
if (handle == NULL) {
printf("could not get handle\n");
exit(1);
}
#endif
cl_com_set_auto_close_mode(handle,CL_CM_AC_ENABLED );
cl_com_get_auto_close_mode(handle,&autoclose);
if (autoclose != CL_CM_AC_ENABLED ) {
printf("could not enable autoclose\n");
exit(1);
}
printf("local hostname is \"%s\"\n", handle->local->comp_host);
printf("local component is \"%s\"\n", handle->local->comp_name);
printf("local component id is \"%ld\"\n", handle->local->comp_id);
#ifdef CREATE_SERVICE
cl_com_get_known_endpoint_port_from_name(argv[1], "server", 1, &i);
printf("connecting to port \"%d\" on host \"%s\"\n", i, argv[1]);
#else
cl_com_get_connect_port(handle, &i);
printf("connecting to port \"%d\" on host \"%s\"\n", i, argv[1]);
#endif
gettimeofday(&now,NULL);
start_time = now.tv_sec;
appl_start_time = start_time;
welcome_text_size = strlen(welcome_text) + 1;
if (getenv("CL_RUNS")) {
runs = atoi(getenv("CL_RUNS"));
} else {
runs = -1; /* disable runs shutdown */
}
while(do_shutdown != 1) {
unsigned long mid = 0;
int my_sent_error = 0;
CL_LOG(CL_LOG_INFO,"main loop");
if (runs > 0) {
runs--;
}
/* printf("sending to \"%s\" ...\n", argv[1]); */
/* CL_LOG(CL_LOG_ERROR,"sending ack message ..."); */
my_sent_error = cl_commlib_send_message(handle, argv[1], "server", 1, CL_MIH_MAT_ACK, (cl_byte_t**)&welcome_text , welcome_text_size, &mid ,0,0, CL_TRUE, CL_FALSE);
if ( retval == CL_RETVAL_CONNECTION_NOT_FOUND ) {
CL_LOG(CL_LOG_ERROR,"after new connection");
}
if (last_mid >= mid || mid == 1) {
total_connections++;
total_connection_sum++;
}
last_mid = mid;
#if 1
if (my_sent_error != CL_RETVAL_OK) {
printf("cl_commlib_send_message() returned %s\n", cl_get_error_text(my_sent_error));
#ifdef CREATE_SERVICE
cl_com_get_known_endpoint_port_from_name(argv[1], "server", 1, &i);
printf("connecting to port \"%d\" on host \"%s\"\n", i, argv[1]);
#else
cl_com_get_connect_port(handle, &i);
printf("connecting to port \"%d\" on host \"%s\"\n", i, argv[1]);
#endif
/* exit(1); */
#if CL_DO_SLOW
sleep(atoi(argv[5]));
#endif
cl_commlib_trigger(handle,1);
continue;
}
#endif
#if 1
retval = CL_RETVAL_PARAMS;
while (retval != CL_RETVAL_OK ) {
while ( (retval=cl_commlib_receive_message(handle,NULL, NULL, 0, CL_FALSE, 0, &message, &sender)) == CL_RETVAL_OK) {
if (message != NULL) {
cl_com_free_endpoint(&sender);
cl_com_free_message(&message);
} else {
break;
}
}
if ( retval == CL_RETVAL_CONNECTION_NOT_FOUND ) {
CL_LOG(CL_LOG_ERROR,"connection not found (1)");
break;
}
retval = cl_commlib_check_for_ack(handle, argv[1], "server", 1, mid, CL_TRUE );
if (retval != CL_RETVAL_MESSAGE_WAIT_FOR_ACK && retval != CL_RETVAL_OK) {
printf("retval of cl_commlib_check_for_ack(%ld) is %s\n",mid,cl_get_error_text(retval));
/* exit(1); */
break;
}
if (retval == CL_RETVAL_OK) {
CL_LOG_INT(CL_LOG_INFO,"received ack for message mid", (int)mid);
} else {
cl_commlib_trigger(handle, 1);
}
if ( retval == CL_RETVAL_CONNECTION_NOT_FOUND ) {
CL_LOG(CL_LOG_ERROR,"connection not found (2)");
break;
}
/* printf("retval of cl_commlib_check_for_ack(%ld) is %s\n",mid,cl_get_error_text(retval)); */
}
if (retval == CL_RETVAL_CONNECTION_NOT_FOUND) {
cl_commlib_trigger(handle, 1);
continue;
}
#endif
total_bytes_sent = total_bytes_sent + welcome_text_size;
CL_LOG_INT(CL_LOG_INFO,"bytes sent:", welcome_text_size);
bytes_received = 0;
while (bytes_received != welcome_text_size ) {
cl_commlib_trigger(handle, 1);
CL_LOG_INT(CL_LOG_INFO,"waiting for mid .... ", (int)mid);
retval = cl_commlib_receive_message(handle,NULL, NULL, 0, CL_FALSE, mid, &message, &sender);
CL_LOG_STR(CL_LOG_INFO,"waiting for bytes ...", cl_get_error_text(retval));
if (retval == CL_RETVAL_CONNECTION_NOT_FOUND) {
#if CL_DO_SLOW
/* CL_LOG(CL_LOG_ERROR,"connection not found"); */
if (atoi(argv[5]) > 0) {
printf("sleeping...\n");
sleep(atoi(argv[5]));
}
#endif
break;
}
if (message != NULL) {
/* printf("received message from \"%s\"\n", sender->comp_host); */
CL_LOG_INT(CL_LOG_INFO,"bytes received:", (int)message->message_length);
if (strcmp((char*)message->message, welcome_text) != 0) {
printf("------------------------> message transfer error\n");
}
total_bytes_received = total_bytes_received + message->message_length;
bytes_received = bytes_received + (int)message->message_length;
cl_com_free_endpoint(&sender);
cl_com_free_message(&message);
}
while ( (retval = cl_commlib_receive_message(handle,NULL, NULL, 0, CL_FALSE, 0, &message, &sender)) == CL_RETVAL_OK) {
if (message != NULL) {
cl_com_free_endpoint(&sender);
cl_com_free_message(&message);
} else {
break;
}
}
if (retval == CL_RETVAL_CONNECTION_NOT_FOUND) {
CL_LOG(CL_LOG_ERROR,"connection not found (3)");
break;
}
#if CL_DO_SLOW
sleep(atoi(argv[5]));
#endif
if (do_shutdown == 1) {
break;
}
}
#if CL_DO_SLOW
sleep(atoi(argv[5]));
#endif
gettimeofday(&now,NULL);
end_time = now.tv_sec;
if (end_time - start_time >= 2 ) {
cl_com_connection_t* con = NULL;
cl_connection_list_elem_t* elem = NULL;
/* printf("Kbit/s sent: %.2f ", ((total_bytes_sent * 8.0)/1024.0) / (double)(end_time - start_time));
printf("Kbit/s read: %.2f ", ((total_bytes_received * 8.0)/1024.0) / (double)(end_time - start_time)); */
printf("KBit/s : %.2f ", (((total_bytes_received + total_bytes_sent) * 8.0)/1024.0) / (double)(end_time - start_time));
printf("connections/s: %.2f ", (double) total_connections / (double)(end_time - start_time));
printf("avg. connections/s: %.2f", (double) total_connection_sum / (double)(end_time - appl_start_time));
cl_raw_list_lock(handle->connection_list);
elem = cl_connection_list_get_first_elem(handle->connection_list);
if (elem != NULL) {
con = elem->connection;
if (elem->connection->local) {
printf("[for comp host, comp name, comp id: \"%s\", \"%s\", \"%ld\"] \n",con->local->comp_host, con->local->comp_name , con->local->comp_id);
}
} else {
printf(" \n");
}
cl_raw_list_unlock(handle->connection_list);
start_time = now.tv_sec;
total_bytes_sent = 0;
total_bytes_received = 0;
total_connections = 0;
fflush(stdout);
}
if (close_connection != 0) {
while (cl_commlib_shutdown_handle(handle, CL_TRUE) == CL_RETVAL_MESSAGE_IN_BUFFER) {
printf("got message\n");
message = NULL;
cl_commlib_receive_message(handle,NULL, NULL, 0, CL_FALSE, 0, &message, &sender);
if (message != NULL) {
cl_com_free_endpoint(&sender);
cl_com_free_message(&message);
} else {
printf("error shutdown handle");
exit(-1);
break;
}
}
#ifdef CREATE_SERVICE
handle=cl_com_create_handle(NULL,framework,CL_CM_CT_MESSAGE , CL_TRUE, 0 , CL_TCP_DEFAULT, "client", atoi(argv[3]),SELECT_TIMEOUT,0 );
if (handle == NULL) {
printf("could not get handle\n");
exit(-1);
} else {
int my_port;
cl_com_get_service_port(handle,&my_port);
printf("I'm reachable at port %d!\n", my_port);
}
#else
handle=cl_com_create_handle(NULL,framework,CL_CM_CT_MESSAGE , CL_FALSE, atoi(argv[2]) , CL_TCP_DEFAULT, "client", atoi(argv[3]), SELECT_TIMEOUT,0 );
if (handle == NULL) {
printf("could not get handle\n");
exit(-1);
}
#endif
cl_com_set_auto_close_mode(handle,CL_CM_AC_ENABLED );
cl_com_get_auto_close_mode(handle,&autoclose);
if (autoclose != CL_CM_AC_ENABLED ) {
printf("could not enable autoclose\n");
exit(1);
}
}
if (runs == 0) {
do_shutdown = 1;
}
}
printf("do_shutdown received\n");
fflush(stdout);
while (cl_commlib_shutdown_handle(handle, CL_TRUE) == CL_RETVAL_MESSAGE_IN_BUFFER) {
printf("got message\n");
message = NULL;
cl_commlib_receive_message(handle,NULL, NULL, 0, CL_FALSE, 0, &message, &sender);
if (message != NULL) {
cl_com_free_endpoint(&sender);
cl_com_free_message(&message);
} else {
break;
}
}
printf("cleanup commlib ...\n");
cl_com_cleanup_commlib();
printf("main done\n");
fflush(stdout);
return 0;
}
/*
* main()
*/
extern int main(int argc, char** argv) {
cl_com_handle_t* handle = NULL;
cl_com_message_t* message = NULL;
cl_com_endpoint_t* sender = NULL;
cl_ssl_setup_t ssl_config;
cl_framework_t framework = CL_CT_TCP;
int ret_val = CL_RETVAL_OK;
const int fd_in = 0;
const int fd_out = 1;
char fd_in_data[255];
char fd_out_data[255];
char* reg = NULL;
int error = CL_RETVAL_OK;
reg = "reg";
fd_in_data[0] = '\0';
fd_out_data[0] = '\0';
/* check command line argument count */
if (argc <= 3) {
usage();
exit(1);
}
/* get service host and port as also the connection mode from command line */
server_host = argv[1];
handle_port = atoi(argv[2]);
if (handle_port <= 0) {
fprintf(stderr,"need a port number > 0\n");
usage();
exit(1);
}
if (argv[3]) {
if (strcmp(argv[3], "SSL") == 0) {
framework=CL_CT_SSL;
printf("using SSL framework\n");
}
}else{
printf("using TCP framework\n");
}
/* set the ssl environment */
if(framework == CL_CT_SSL){
memset(&ssl_config, 0, sizeof(ssl_config));
ssl_config.ssl_method = CL_SSL_v23; /* v23 method */
ssl_config.ssl_CA_cert_pem_file = getenv("SSL_CA_CERT_FILE"); /* CA certificate file */
ssl_config.ssl_CA_key_pem_file = NULL; /* private certificate file of CA (not used) */
ssl_config.ssl_cert_pem_file = getenv("SSL_CERT_FILE"); /* certificates file */
ssl_config.ssl_key_pem_file = getenv("SSL_KEY_FILE"); /* key file */
ssl_config.ssl_rand_file = getenv("SSL_RAND_FILE"); /* rand file (if RAND_status() not ok) */
ssl_config.ssl_crl_file = getenv("SSL_CRL_FILE"); /* revocation list file */
ssl_config.ssl_reconnect_file = NULL; /* file for reconnect data (not used) */
ssl_config.ssl_refresh_time = 0; /* key alive time for connections (not used) */
ssl_config.ssl_password = NULL; /* password for encrypted keyfiles (not used) */
ssl_config.ssl_verify_func = my_ssl_verify_func; /* function callback for peer user/name check */
if (ssl_config.ssl_CA_cert_pem_file == NULL ||
ssl_config.ssl_cert_pem_file == NULL ||
ssl_config.ssl_key_pem_file == NULL ||
ssl_config.ssl_rand_file == NULL) {
printf("please set the following environment variables:\n");
printf("SSL_CA_CERT_FILE = CA certificate file\n");
printf("SSL_CERT_FILE = certificates file\n");
printf("SSL_KEY_FILE = key file\n");
printf("(optional) SSL_RAND_FILE = rand file (if RAND_status() not ok)\n");
}
}
/* setup signalhandling */
setup_signal_handler();
/* setup commlib */
error = cl_com_setup_commlib(CL_RW_THREAD, CL_LOG_OFF, NULL);
if(error != CL_RETVAL_OK){
fprintf(stderr, "cl_com_setup_commlib failed with: %s\n", cl_get_error_text(error));
}
/* setup commlib error function callback */
cl_com_set_error_func(on_communication_error);
if (framework == CL_CT_SSL) {
cl_com_specify_ssl_configuration(&ssl_config);
}
/* create communication handle */
handle=cl_com_create_handle(&error,
framework,
CL_CM_CT_MESSAGE,
false,
handle_port,
CL_TCP_DEFAULT,
"client", 0,
5, 0 );
if (handle == NULL) {
fprintf(stderr, "could not create communication handle with error: %s\n", cl_get_error_text(error));
cl_com_cleanup_commlib();
exit(1);
}
/* print out some info output */
printf("client running:\n");
printf("host: \"%s\"\n", handle->local->comp_host);
printf("name: \"%s\"\n", handle->local->comp_name);
printf("id: \"%ld\"\n", handle->local->comp_id);
ret_val = cl_com_external_fd_register(handle, fd_in, fd_in_cb, CL_R_SELECT, fd_in_data);
if (ret_val != CL_RETVAL_OK) {
printf("could not register stdin-fd: %s\n", cl_get_error_text(ret_val));
do_shutdown = 1;
}else{
printf("stdin-fd was registered\n");
}
ret_val = cl_com_external_fd_register(handle, fd_out, fd_out_cb, CL_W_SELECT, fd_out_data);
if (ret_val != CL_RETVAL_OK) {
printf("could not register stdout-fd: %s\n", cl_get_error_text(ret_val));
do_shutdown = 1;
}else{
printf("stdout-fd was registered\n");
}
/* register at the server */
ret_val = cl_commlib_send_message(handle,
server_host, "server", 1,
CL_MIH_MAT_NAK,
(cl_byte_t**)®, strlen(reg)+1,
NULL, 0, 0,
true, false);
if (ret_val != CL_RETVAL_OK) {
do_shutdown = 1;
}
/* application main loop */
while ( do_shutdown == 0 ) {
CL_LOG(CL_LOG_WARNING, "App: start looping");
cl_commlib_trigger(handle, 1);
CL_LOG(CL_LOG_WARNING, "App: trigger was done");
ret_val = cl_commlib_receive_message(handle,NULL, NULL, 0, false, 0, &message, &sender);
if (message != NULL) {
CL_LOG(CL_LOG_WARNING, "App: std_out received");
pthread_mutex_lock(&data_mutex);
CL_LOG(CL_LOG_WARNING, "App: std_out got mutex");
strcat(fd_out_data, (const char*)message->message);
pthread_mutex_unlock(&data_mutex);
CL_LOG(CL_LOG_WARNING, "App: std_out released mutex");
cl_com_external_fd_set_write_ready(handle, fd_out);
CL_LOG(CL_LOG_WARNING, "App: std_out set write ready flag");
cl_com_free_message(&message);
cl_com_free_endpoint(&sender);
}
pthread_mutex_lock(&data_in_mutex);
if(ready == 1) {
cl_byte_t* bp = NULL;
CL_LOG(CL_LOG_WARNING, "App: std_in send");
bp = (cl_byte_t*) fd_in_data;
cl_commlib_send_message(handle,
server_host, "server", 1,
CL_MIH_MAT_NAK,
&bp, strlen(fd_in_data)+1,
NULL, 0, 0,
true, false);
ready = 0;
fd_in_data[0] = '\0';
}
pthread_mutex_unlock(&data_in_mutex);
}
printf("shutting down ...\n");
cl_com_external_fd_unregister(handle, fd_in);
cl_com_external_fd_unregister(handle, fd_out);
/* here the application goes down - shutdown communication lib */
while ( cl_commlib_shutdown_handle(handle, true) == CL_RETVAL_MESSAGE_IN_BUFFER) {
message = NULL;
cl_commlib_receive_message(handle,NULL, NULL, 0, false, 0, &message, &sender);
if (message != NULL) {
printf("ignoring message from \"%s\"\n", sender->comp_host);
cl_com_free_message(&message);
cl_com_free_endpoint(&sender);
message = NULL;
}
}
/* cleanup commlib */
cl_com_cleanup_commlib();
return 0;
}
/*
* Delete configuration 'confp' from cluster configuration.
*
* TODO: A fix for IZ issue #79 is needed. For this to be done it may be
* necessary to introduce something like 'protected' configuration entries.
*/
int
sge_del_configuration(sge_gdi_ctx_class_t *ctx,
lListElem *aConf, lList **anAnswer,
char *aUser, char *aHost)
{
const char *tmp_name = NULL;
char unique_name[CL_MAXHOSTLEN];
int ret = -1;
DENTER(TOP_LAYER, "sge_del_configuration");
if (!aConf || !aUser || !aHost) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((tmp_name = lGetHost(aConf, CONF_name)) == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS,
lNm2Str(CONF_name), SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
/*
* Due to CR 6319231 IZ 1760:
* try to resolve the hostname
* if it is not resolveable then
* ignore this and use the hostname stored in the configuration obj
* or use the given name if no object can be found
*/
ret = sge_resolve_hostname(tmp_name, unique_name, EH_name, sizeof(unique_name));
if (ret != CL_RETVAL_OK) {
lListElem *conf_obj = NULL;
DPRINTF(("%s: error %s resolving host %s\n", SGE_FUNC,
cl_get_error_text(ret), tmp_name));
conf_obj = sge_get_configuration_for_host(tmp_name);
if (conf_obj != NULL) {
DPRINTF(("using hostname stored in configuration object\n"));
strcpy(unique_name, lGetHost(conf_obj, CONF_name));
lFreeElem(&conf_obj);
} else {
ERROR((SGE_EVENT, MSG_SGETEXT_CANT_DEL_CONFIG2_S, tmp_name));
answer_list_add(anAnswer, SGE_EVENT,
STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
}
/* Do not allow to delete global configuration */
if (!strcasecmp(SGE_GLOBAL_NAME, unique_name)) {
ERROR((SGE_EVENT, MSG_SGETEXT_CANT_DEL_CONFIG_S, unique_name));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
sge_event_spool(ctx, anAnswer, 0, sgeE_CONFIG_DEL, 0, 0, unique_name, NULL, NULL, NULL, NULL, NULL, true, true);
remove_conf_by_name(unique_name);
INFO((SGE_EVENT, MSG_SGETEXT_REMOVEDFROMLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF ));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
update_reschedule_unknown_timout_values(unique_name);
/* invalidate cached configuration values */
mconf_set_new_config(true);
DRETURN(STATUS_OK);
}
extern int main(void)
{
int retval;
const char* param2 = "param2";
const char* param3 = "param3";
char* val2 = "val2";
char* val3 = "val3";
char* ret_char = NULL;
printf("commlib setup ...\n");
retval = cl_com_setup_commlib(CL_NO_THREAD , CL_LOG_INFO, NULL );
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
retval = cl_com_set_parameter_list_value(param2, val2);
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
retval = cl_com_set_parameter_list_value(param3, val3);
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
retval = cl_com_get_parameter_list_value(param3, &ret_char);
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
retval = cl_com_remove_parameter_list_value(param2);
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
printf("Print element got from commlib:\n");
printf("parameter: %s\n", param3);
printf("value: %s\n", ret_char);
free(ret_char);
ret_char = NULL;
printf("\nappend parameter ...\n");
retval = cl_com_set_parameter_list_value(param2, val2);
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
printf("\nappend parameter ...\n");
retval = cl_com_set_parameter_list_value("param11", "val11");
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
retval = cl_com_get_parameter_list_string(&ret_char);
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
printf("Print string got from commlib:\n");
printf("Parameter string: %s\n", ret_char);
free(ret_char);
printf("commlib cleanup ...\n");
retval = cl_com_cleanup_commlib();
if (retval != CL_RETVAL_OK) {
printf("%s\n\n",cl_get_error_text(retval));
exit(1);
}
printf("main done\n");
return 0;
}
extern int main(int argc, char** argv)
{
struct sigaction sa;
struct timeval now;
time_t last_time = 0;
time_t shutdown_time = 0;
int i,first_message_sent = 0;
int no_output = 0;
cl_byte_t *reference = NULL;
prof_mt_init();
if (argc < 4) {
printf("syntax: debug_level vmaster_port vmaster_host [no_output]\n");
exit(1);
}
if (argc >= 5) {
if (strcmp(argv[4],"no_output") == 0) {
printf("virtual event client: no_output option set\n");
no_output = 1;
}
}
/* setup signalhandling */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sighandler_client; /* one handler for all signals */
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGPIPE, &sa, NULL);
gettimeofday(&now,NULL);
shutdown_time = now.tv_sec + SGE_TEST_VIRTUAL_CLIENT_SHUTDOWN_TIMEOUT;
printf("startup commlib ...\n");
cl_com_setup_commlib(CL_NO_THREAD , (cl_log_t)atoi(argv[1]), NULL);
printf("setting up handle for connect port %d\n", atoi(argv[2]) );
handle=cl_com_create_handle(NULL,CL_CT_TCP,CL_CM_CT_MESSAGE , CL_FALSE, atoi(argv[2]) , CL_TCP_DEFAULT,"virtual_event_client", 0, 1,0 );
if (handle == NULL) {
printf("could not get handle\n");
exit(1);
}
printf("local hostname is \"%s\"\n", handle->local->comp_host);
printf("local component is \"%s\"\n", handle->local->comp_name);
printf("local component id is \"%ld\"\n", handle->local->comp_id);
cl_com_get_connect_port(handle, &i);
printf("connecting to port \"%d\" on host \"%s\"\n", i, argv[3]);
printf("virtual event client is running ...\n");
while(do_shutdown == 0) {
int retval = 0;
cl_com_message_t* message = NULL;
cl_com_endpoint_t* sender = NULL;
gettimeofday(&now,NULL);
if (now.tv_sec != last_time && !no_output) {
printf("virtual event client["pid_t_fmt"] message count[sent |%d|] events[received |%d|]...\n",
getpid(), snd_messages, events_received);
last_time = now.tv_sec;
}
if (now.tv_sec > shutdown_time ) {
printf("shutting down test - timeout\n");
do_shutdown = 1;
}
retval = cl_commlib_receive_message(handle, NULL, NULL, 0, /* handle, comp_host, comp_name , comp_id, */
CL_TRUE, 0, /* syncron, response_mid */
&message, &sender );
if ( retval != CL_RETVAL_OK) {
if ( retval == CL_RETVAL_CONNECTION_NOT_FOUND ) {
#if 0
printf("opening connection to %s/%s/%d\n", argv[3], "virtual_master", 1);
#endif
/* shutdown when virtual qmaster is not running anymore */
if (events_received > 0) {
do_shutdown = 1;
printf("lost connection to %s/%s/%d\n", argv[3], "virtual_master", 1);
}
retval = cl_commlib_open_connection(handle, argv[3], "virtual_master", 1);
if (retval == CL_RETVAL_OK) {
first_message_sent = 0;
}
}
} else {
#if 0
printf("received message from %s/%s/%ld: \"%s\" (%ld bytes)\n", sender->comp_host,sender->comp_name,sender->comp_id, message->message, message->message_length);
#endif
gettimeofday(&now,NULL);
shutdown_time = now.tv_sec + SGE_TEST_VIRTUAL_CLIENT_SHUTDOWN_TIMEOUT;
events_received++;
cl_com_free_message(&message);
cl_com_free_endpoint(&sender);
}
#if 0
printf("status: %s\n",cl_get_error_text(retval));
#endif
if ( first_message_sent == 0) {
char data[6] = "event";
reference = (cl_byte_t *)data;
first_message_sent = 1;
retval = cl_commlib_send_message(handle, argv[3], "virtual_master", 1,
CL_MIH_MAT_ACK,
&reference, 6,
NULL, 0, 0 , CL_TRUE, CL_TRUE );
if (retval == CL_RETVAL_OK) {
snd_messages++;
}
#if 0
printf("sending a event hello message: %s\n",cl_get_error_text(retval) );
#endif
}
}
printf("shutdown commlib ...\n");
cl_com_cleanup_commlib();
printf("main done\n");
return 0;
}
/****** qmaster/sge_qmaster_main/main() ****************************************
* NAME
* main() -- qmaster entry point
*
* SYNOPSIS
* int main(int argc, char* argv[])
*
* FUNCTION
* Qmaster entry point.
*
* NOTE: The main thread must block all signals before any additional thread
* is created. Failure to do so will ruin signal handling!
*
* INPUTS
* int argc - number of commandline arguments
* char* argv[] - commandline arguments
*
* RESULT
* 0 - success
*
* NOTES
* We check whether 'SGE_ROOT' is set before we daemonize. Once qmaster is
* a daemon, we are no longer connected to a terminal and hence can not
* output an error message to stdout or stderr.
*
* We need to inovke 'prepare_enroll()' *before* the user id is switched via
* 'become_admin_user()'. This is because qmaster must be able to bind a so
* called reserved port (requires root privileges) if configured to do so.
*
*******************************************************************************/
int main(int argc, char* argv[])
{
int max_enroll_tries;
int ret_val;
int file_descriptor_settings_result = 0;
bool has_daemonized = false;
sge_gdi_ctx_class_t *ctx = NULL;
u_long32 start_time = sge_get_gmt();
monitoring_t monitor;
DENTER_MAIN(TOP_LAYER, "qmaster");
sge_monitor_init(&monitor, "MAIN", NONE_EXT, MT_WARNING, MT_ERROR);
prof_mt_init();
sge_get_root_dir(true, NULL, 0, true);
#ifdef __SGE_COMPILE_WITH_GETTEXT__
sge_init_language_func((gettext_func_type)gettext, (setlocale_func_type)setlocale, (bindtextdomain_func_type)bindtextdomain, (textdomain_func_type)textdomain);
sge_init_language(NULL,NULL);
#endif
/*
* qmaster doesn't support any commandline anymore,
* but we should show version string and -help option
*/
if (argc != 1) {
sigset_t sig_set;
sigfillset(&sig_set);
pthread_sigmask(SIG_SETMASK, &sig_set, NULL);
sge_qmaster_thread_init(&ctx, QMASTER, MAIN_THREAD, true);
sge_process_qmaster_cmdline(argv);
SGE_EXIT((void**)&ctx, 1);
}
/*
* daemonize qmaster
* set file descriptor limits
* and initialize libraries to be used in multi threaded environment
* also take care that finished child processed of this process become
* zombie jobs
*/
has_daemonized = sge_daemonize_qmaster();
file_descriptor_settings_result = set_file_descriptor_limit();
#if !defined(INTERIX) && !defined(CYGWIN)
init_sig_action_and_mask();
#endif
/* init qmaster threads without becomming admin user */
sge_qmaster_thread_init(&ctx, QMASTER, MAIN_THREAD, false);
ctx->set_daemonized(ctx, has_daemonized);
/* this must be done as root user to be able to bind ports < 1024 */
max_enroll_tries = 30;
while (cl_com_get_handle(prognames[QMASTER],1) == NULL) {
ctx->prepare_enroll(ctx);
max_enroll_tries--;
if (max_enroll_tries <= 0) {
/* exit after 30 seconds */
CRITICAL((SGE_EVENT, MSG_QMASTER_COMMUNICATION_ERRORS ));
SGE_EXIT((void**)&ctx, 1);
}
if (cl_com_get_handle(prognames[QMASTER],1) == NULL) {
/* sleep when prepare_enroll() failed */
sleep(1);
}
}
/*
* now the commlib up and running. Set qmaster application status function
* (commlib callback function for qping status information response
* messages (SIRM))
*/
ret_val = cl_com_set_status_func(sge_qmaster_application_status);
if (ret_val != CL_RETVAL_OK) {
ERROR((SGE_EVENT, cl_get_error_text(ret_val)));
}
/*
* now we become admin user change into the correct root directory set the
* the target for logging messages
*/
sge_become_admin_user(ctx->get_admin_user(ctx));
sge_chdir_exit(ctx->get_qmaster_spool_dir(ctx), 1);
log_state_set_log_file(ERR_FILE);
ctx->set_exit_func(ctx, sge_exit_func);
#if defined(SOLARIS)
/* Init shared SMF libs if necessary */
if (sge_smf_used() == 1 && sge_smf_init_libs() != 0) {
SGE_EXIT((void**)&ctx, 1);
}
#endif
/*
* We do increment the heartbeat manually here. This is the 'startup heartbeat'.
* The first time the hearbeat will be incremented through the heartbeat event
* handler is after about HEARTBEAT_INTERVAL seconds. The hardbeat event handler
* is setup during the initialisazion of the timer thread.
*/
inc_qmaster_heartbeat(QMASTER_HEARTBEAT_FILE, HEARTBEAT_INTERVAL, NULL);
/*
* Event master module has to be initialized already here because
* sge_setup_qmaster() might already access it although event delivery
* thread is not running.
*
* Corresponding shutdown is done in sge_event_master_terminate();
*
* EB: In my opinion the init function should called in
* sge_event_master_initialize(). Is it possible to move that call?
*/
sge_event_master_init();
sge_setup_qmaster(ctx, argv);
#ifndef USE_POLL
if (file_descriptor_settings_result == 1) {
WARNING((SGE_EVENT, MSG_QMASTER_FD_SETSIZE_LARGER_THAN_LIMIT_U, sge_u32c(FD_SETSIZE)));
WARNING((SGE_EVENT, MSG_QMASTER_FD_SETSIZE_COMPILE_MESSAGE1_U, sge_u32c(FD_SETSIZE - 20)));
WARNING((SGE_EVENT, MSG_QMASTER_FD_SETSIZE_COMPILE_MESSAGE2));
WARNING((SGE_EVENT, MSG_QMASTER_FD_SETSIZE_COMPILE_MESSAGE3));
}
#endif
/*
* Setup all threads and initialize corresponding modules.
* Order is important!
*/
sge_signaler_initialize(ctx);
sge_event_master_initialize(ctx);
sge_timer_initialize(ctx, &monitor);
sge_worker_initialize(ctx);
#if 0
sge_test_initialize(ctx);
#endif
sge_listener_initialize(ctx);
sge_scheduler_initialize(ctx, NULL);
#ifndef NO_JNI
sge_jvm_initialize(ctx, NULL);
#endif
INFO((SGE_EVENT, "qmaster startup took "sge_u32" seconds", sge_get_gmt() - start_time));
/*
* Block till signal from signal thread arrives us
*/
sge_thread_wait_for_signal();
/*
* Shutdown all threads and shutdown corresponding modules.
* Order is important!
*/
#ifndef NO_JNI
sge_jvm_terminate(ctx, NULL);
#endif
sge_scheduler_terminate(ctx, NULL);
sge_listener_terminate();
#if 0
sge_test_terminate(ctx);
#endif
sge_worker_terminate(ctx);
sge_timer_terminate();
sge_event_master_terminate();
sge_signaler_terminate();
/*
* Remaining shutdown operations
*/
sge_clean_lists();
sge_monitor_free(&monitor);
sge_shutdown((void**)&ctx, sge_qmaster_get_exit_state());
sge_prof_cleanup();
DEXIT;
return 0;
} /* main() */
int main(int argc,char *argv[]) {
struct hostent *he = NULL;
char* resolved_name = NULL;
int retval = CL_RETVAL_OK;
char **tp,**tp2;
int name_only = 0;
int sge_aliasing = 0;
int all_option = 0;
int system_error = 0;
if (argc < 1 ) {
usage();
}
if (argc >= 2) {
if (!strcmp(argv[1], "-help")) {
usage();
}
if (!strcmp(argv[1], "-name")) {
if (argc != 2) {
usage();
}
name_only = 1;
}
if (!strcmp(argv[1], "-aname")) {
if (argc != 2) {
usage();
}
name_only = 1;
sge_aliasing = 1;
}
if (!strcmp(argv[1], "-all")) {
if (argc != 2) {
usage();
}
name_only = 0;
sge_aliasing = 1;
all_option = 1;
}
}
if (name_only == 0 && argc != 1 && all_option == 0) {
usage();
}
retval = cl_com_setup_commlib(CL_NO_THREAD ,CL_LOG_OFF, NULL);
if (retval != CL_RETVAL_OK) {
fprintf(stderr,"%s\n",cl_get_error_text(retval));
exit(1);
}
if (sge_aliasing ) {
const char *alias_path = sge_get_alias_path();
cl_com_set_alias_file(alias_path);
sge_free(&alias_path);
}
retval = cl_com_gethostname(&resolved_name, NULL, &he, &system_error);
if (retval != CL_RETVAL_OK) {
char* err_text = cl_com_get_h_error_string(system_error);
if (err_text == NULL) {
err_text = strdup(strerror(system_error));
if (err_text == NULL) {
err_text = strdup("unexpected error");
}
}
fprintf(stderr,"error resolving local host: %s (%s)\n",cl_get_error_text(retval), err_text);
sge_free(&err_text);
cl_com_cleanup_commlib();
exit(1);
}
if (name_only) {
if (sge_aliasing) {
if (resolved_name != NULL) {
printf("%s\n",resolved_name);
} else {
printf("%s\n","unexpected error");
}
} else {
if (he != NULL) {
printf("%s\n",he->h_name);
} else {
printf("%s\n","could not get hostent struct");
}
}
} else {
if (he != NULL) {
printf(MSG_SYSTEM_HOSTNAMEIS_S , he->h_name);
printf("\n");
if (resolved_name != NULL && all_option) {
printf("SGE name: %s\n",resolved_name);
}
printf("%s", MSG_SYSTEM_ALIASES);
for (tp = he->h_aliases; *tp; tp++) {
printf("%s ", *tp);
}
printf("\n");
printf("%s", MSG_SYSTEM_ADDRESSES);
for (tp2 = he->h_addr_list; *tp2; tp2++) {
printf("%s ", inet_ntoa(* (struct in_addr *) *tp2)); /* inet_ntoa() is not MT save */
}
printf("\n");
} else {
fprintf(stderr,"%s\n","could not get hostent struct");
}
}
sge_free(&resolved_name);
sge_free_hostent(&he);
retval = cl_com_cleanup_commlib();
if (retval != CL_RETVAL_OK) {
fprintf(stderr,"%s\n",cl_get_error_text(retval));
exit(1);
}
return 0;
}
/****** qmaster/sge_mod_configuration() ****************************************
* NAME
* sge_mod_configuration() -- modify cluster configuration
*
* SYNOPSIS
* int sge_mod_configuration(lListElem *aConf, lList **anAnswer, char *aUser,
* char *aHost)
*
* FUNCTION
* Modify cluster configuration. 'confp' is a pointer to a 'CONF_Type' list
* element and does contain the modified configuration entry. Adding a new
* configuration entry is also viewed as a modification.
*
* INPUTS
* lListElem *aConf - CONF_Type element containing the modified conf
* lList **anAnswer - answer list
* char *aUser - target user
* char *aHost - target host
*
* RESULT
* int - 0 success
* -1 error
*
* NOTES
* MT-NOTE: sge_mod_configuration() is MT safe
*
*******************************************************************************/
int sge_mod_configuration(sge_gdi_ctx_class_t *ctx, lListElem *aConf, lList **anAnswer, char *aUser, char *aHost)
{
lListElem *old_conf;
const char *tmp_name = NULL;
char unique_name[CL_MAXHOSTLEN];
int ret = -1;
const char *cell_root = ctx->get_cell_root(ctx);
const char *qualified_hostname = ctx->get_qualified_hostname(ctx);
u_long32 progid = ctx->get_who(ctx);
DENTER(TOP_LAYER, "sge_mod_configuration");
if (!aConf || !aUser || !aHost) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((tmp_name = lGetHost(aConf, CONF_name)) == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS, lNm2Str(CONF_name), SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((ret = sge_resolve_hostname(tmp_name, unique_name, EH_name, sizeof(unique_name)))
!= CL_RETVAL_OK) {
DPRINTF(("%s: error %s resolving host %s\n", SGE_FUNC, cl_get_error_text(ret), tmp_name));
ERROR((SGE_EVENT, MSG_SGETEXT_CANTRESOLVEHOST_S, tmp_name));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((ret = check_config(anAnswer, aConf))) {
DRETURN(ret);
}
if ((old_conf = sge_get_configuration_for_host(unique_name)) != NULL) {
int ret = -1;
ret = do_mod_config(ctx, unique_name, old_conf, aConf, anAnswer);
lFreeElem(&old_conf);
if (ret == 0) {
INFO((SGE_EVENT, MSG_SGETEXT_MODIFIEDINLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
} else {
DRETURN(STATUS_EUNKNOWN);
}
} else {
do_add_config(ctx, unique_name, aConf, anAnswer);
INFO((SGE_EVENT, MSG_SGETEXT_ADDEDTOLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
}
if (strcmp(SGE_GLOBAL_NAME, unique_name) == 0) {
sge_add_event(0, sgeE_GLOBAL_CONFIG, 0, 0, NULL, NULL, NULL, NULL);
}
/*
** is the configuration change relevant for the qmaster itsself?
** if so, initialise conf struct anew
*/
if (strcmp(unique_name, SGE_GLOBAL_NAME) == 0 || sge_hostcmp(unique_name, qualified_hostname) == 0) {
lListElem *local = NULL;
lListElem *global = NULL;
lList *answer_list = NULL;
char* qmaster_params = NULL;
int accounting_flush_time = mconf_get_accounting_flush_time();
if ((local = sge_get_configuration_for_host(qualified_hostname)) == NULL) {
WARNING((SGE_EVENT, MSG_CONF_NOLOCAL_S, qualified_hostname));
}
if ((global = sge_get_configuration_for_host(SGE_GLOBAL_NAME)) == NULL) {
ERROR((SGE_EVENT, SFNMAX, MSG_CONF_NOGLOBAL));
}
if (merge_configuration(&answer_list, progid, cell_root, global, local, NULL) != 0) {
ERROR((SGE_EVENT, MSG_CONF_CANTMERGECONFIGURATIONFORHOST_S, qualified_hostname));
}
answer_list_output(&answer_list);
/* Restart the accounting flush event if needed. */
if ((accounting_flush_time == 0) &&
(mconf_get_accounting_flush_time() != 0)) {
te_event_t ev = te_new_event(time(NULL), TYPE_ACCOUNTING_TRIGGER, ONE_TIME_EVENT, 1, 0, NULL);
te_add_event(ev);
te_free_event(&ev);
}
lFreeElem(&local);
lFreeElem(&global);
sge_show_conf();
/* 'max_unheard' may have changed */
cl_commlib_set_connection_param(cl_com_get_handle("qmaster", 1), HEARD_FROM_TIMEOUT, mconf_get_max_unheard());
/* fetching qmaster_params and begin to parse */
qmaster_params = mconf_get_qmaster_params();
/* updating the commlib paramterlist and gdi_timeout with new or changed parameters */
cl_com_update_parameter_list(qmaster_params);
sge_free(&qmaster_params);
}
/* invalidate configuration cache */
mconf_set_new_config(true);
DRETURN(STATUS_OK);
}
int main(int argc, char *argv[])
{
struct hostent *he = NULL;
char* resolved_name = NULL;
int retval = CL_RETVAL_OK;
char* ip_string = NULL;
char** tp = NULL;
char** tp2 = NULL;
int name_only = 0;
int sge_aliasing = 0;
int all_option = 0;
int system_error = 0;
#if defined(CRAY)
struct sockaddr_in addr;
#else
struct in_addr addr;
#endif
if (argc < 2) {
usage();
}
ip_string = argv[1];
if (!strcmp(argv[1], "-help")) {
usage();
}
if (!strcmp(argv[1], "-name")) {
if (argc != 3) {
usage();
}
name_only = 1;
ip_string = argv[2];
}
if (!strcmp(argv[1], "-aname")) {
if (argc != 3) {
usage();
}
name_only = 1;
sge_aliasing = 1;
ip_string = argv[2];
}
if (!strcmp(argv[1], "-all")) {
if (argc != 3) {
usage();
}
name_only = 0;
sge_aliasing = 1;
all_option = 1;
ip_string = argv[2];
}
retval = cl_com_setup_commlib(CL_NO_THREAD ,CL_LOG_OFF, NULL);
if (retval != CL_RETVAL_OK) {
fprintf(stderr,"%s\n",cl_get_error_text(retval));
exit(1);
}
if (sge_aliasing ) {
cl_com_set_alias_file(sge_get_alias_path());
}
retval = cl_com_set_error_func(gethostbyaddr_communication_error);
if (retval != CL_RETVAL_OK) {
fprintf(stderr,"%s\n",cl_get_error_text(retval));
exit(1);
}
#if defined(CRAY)
addr.sin_addr.s_addr = inet_addr(ip_string);
#else
addr.s_addr = inet_addr(ip_string);
#endif
retval = cl_com_cached_gethostbyaddr(&addr, &resolved_name, &he, &system_error);
if (retval != CL_RETVAL_OK) {
cl_com_cleanup_commlib();
if (error_reported == 0) {
char* err_text = cl_com_get_h_error_string(system_error);
if (err_text == NULL) {
err_text = strdup(strerror(system_error));
if (err_text == NULL) {
err_text = strdup("unexpected error");
}
}
if ( ip_string == NULL) {
ip_string = "NULL";
}
fprintf(stderr,"error resolving ip "SFQ": %s (%s)\n",ip_string, cl_get_error_text(retval), err_text);
free(err_text);
err_text = NULL;
}
exit(1);
}
if (he == NULL) {
fprintf(stderr,"%s\n","could not get hostent struct");
}
if (name_only) {
if (sge_aliasing) {
if (resolved_name != NULL) {
printf("%s\n",resolved_name);
} else {
fprintf(stderr,"%s\n","unexpected error");
exit(1);
}
} else {
if (he != NULL) {
printf("%s\n",he->h_name);
} else {
fprintf(stderr,"%s\n","could not get hostent struct");
exit(1);
}
}
} else {
if (he != NULL) {
printf(MSG_SYSTEM_HOSTNAMEIS_S,he->h_name);
printf("\n");
}
if (resolved_name != NULL && all_option) {
printf("SGE name: %s\n",resolved_name);
free(resolved_name);
resolved_name = NULL;
}
if (he != NULL) {
printf(MSG_SYSTEM_ALIASES );
for (tp = he->h_aliases; *tp; tp++)
printf("%s ", *tp);
printf("\n");
printf(MSG_SYSTEM_ADDRESSES );
for (tp2 = he->h_addr_list; *tp2; tp2++)
printf("%s ", inet_ntoa(* (struct in_addr *) *tp2)); /* inet_ntoa() is not MT save */
printf("\n");
}
}
sge_free_hostent(&he);
if (resolved_name != NULL) {
free(resolved_name);
resolved_name = NULL;
}
retval = cl_com_cleanup_commlib();
if (retval != CL_RETVAL_OK) {
fprintf(stderr,"%s\n",cl_get_error_text(retval));
exit(1);
}
return 0;
}
/****** run_ijs_server() *******************************************************
* NAME
* run_ijs_server() -- The servers main loop
*
* SYNOPSIS
* int run_ijs_server(u_long32 job_id, int nostdin, int noshell,
* int is_rsh, int is_qlogin, int force_pty,
* int *p_exit_status)
*
* FUNCTION
* The main loop of the commlib server, handling the data transfer from
* and to the client.
*
* INPUTS
* COMM_HANDLE *handle - Handle of the COMM server
* u_long32 job_id - SGE job id of this job
* int nostdin - The "-nostdin" switch
* int noshell - The "-noshell" switch
* int is_rsh - Is it a qrsh with commandline?
* int is_qlogin - Is it a qlogin or qrsh without commandline?
* int suspend_remote - suspend_remote switch of qrsh
* int force_pty - The user forced use of pty by the "-pty yes" switch
*
* OUTPUTS
* int *p_exit_status - The exit status of qrsh_starter in case of
* "qrsh <command>" or the exit status of the shell in
* case of "qrsh <no command>"/"qlogin".
* If the job was signalled, the exit code is 128+signal.
*
* RESULT
* int - 0: Ok.
* 1: Invalid parameter
* 2: Log list not initialized
* 3: Error setting terminal mode
* 4: Can't create tty_to_commlib thread
* 5: Can't create commlib_to_tty thread
* 6: Error shutting down commlib connection
* 7: Error resetting terminal mode
*
* NOTES
* MT-NOTE: run_ijs_server is not MT-safe
*******************************************************************************/
int run_ijs_server(COMM_HANDLE *handle, const char *remote_host,
u_long32 job_id,
int nostdin, int noshell,
int is_rsh, int is_qlogin, ternary_t force_pty,
ternary_t suspend_remote,
int *p_exit_status, dstring *p_err_msg)
{
int ret = 0, ret_val = 0;
THREAD_HANDLE *pthread_tty_to_commlib = NULL;
THREAD_HANDLE *pthread_commlib_to_tty = NULL;
THREAD_LIB_HANDLE *thread_lib_handle = NULL;
cl_raw_list_t *cl_com_log_list = NULL;
DENTER(TOP_LAYER, "run_ijs_server");
if (handle == NULL || p_err_msg == NULL || p_exit_status == NULL || remote_host == NULL) {
return 1;
}
g_comm_handle = handle;
g_hostname = strdup(remote_host);
cl_com_log_list = cl_com_get_log_list();
if (cl_com_log_list == NULL) {
return 2;
}
g_nostdin = nostdin;
g_noshell = noshell;
g_pid = getpid();
g_is_rsh = is_rsh;
if (suspend_remote == UNSET || suspend_remote == NO) {
g_suspend_remote = 0;
} else {
g_suspend_remote = 1;
}
/*
* qrsh without command and qlogin both have is_rsh == 0 and is_qlogin == 1
* qrsh with command and qsh don't need to set terminal mode.
* If the user requested a pty we also have to set terminal mode.
* But only if stdout is still connected to a tty and not redirected
* to a file or a pipe.
*/
if (isatty(STDOUT_FILENO) == 1 &&
((force_pty == UNSET && is_rsh == 0 && is_qlogin == 1) || force_pty == YES)) {
/*
* Set this terminal to raw mode, just output everything, don't interpret
* it. Let the pty on the client side interpret the characters.
*/
ret = terminal_enter_raw_mode();
if (ret != 0) {
sge_dstring_sprintf(p_err_msg, "can't set terminal to raw mode: %s (%d)",
strerror(ret), ret);
return 3;
} else {
g_raw_mode_state = 1;
}
}
/*
* Setup thread list and create two worker threads
*/
thread_init_lib(&thread_lib_handle);
/*
* From here on, we have to cleanup the list in case of errors, this is
* why we "goto cleanup" in case of error.
*/
DPRINTF(("creating worker threads\n"));
DPRINTF(("creating tty_to_commlib thread\n"));
ret = create_thread(thread_lib_handle, &pthread_tty_to_commlib, cl_com_log_list,
"tty_to_commlib thread", 1, tty_to_commlib);
if (ret != CL_RETVAL_OK) {
sge_dstring_sprintf(p_err_msg, "can't create tty_to_commlib thread: %s",
cl_get_error_text(ret));
ret_val = 4;
goto cleanup;
}
DPRINTF(("creating commlib_to_tty thread\n"));
ret = create_thread(thread_lib_handle, &pthread_commlib_to_tty, cl_com_log_list,
"commlib_to_tty thread", 1, commlib_to_tty);
if (ret != CL_RETVAL_OK) {
sge_dstring_sprintf(p_err_msg, "can't create commlib_to_tty thread: %s",
cl_get_error_text(ret));
ret_val = 5;
goto cleanup;
}
/*
* From here on, the two worker threads are doing all the work.
* This main thread is just waiting until the client closes the
* connection to us, which causes the commlib_to_tty thread to
* exit. Then it closes the tty_to_commlib thread, too, and
* cleans up everything.
*/
DPRINTF(("waiting for end of commlib_to_tty thread\n"));
thread_join(pthread_commlib_to_tty);
DPRINTF(("shutting down tty_to_commlib thread\n"));
thread_shutdown(pthread_tty_to_commlib);
/*
* Close stdin to awake the tty_to_commlib-thread from the select() call.
* thread_shutdown() doesn't work on all architectures.
*/
close(STDIN_FILENO);
DPRINTF(("waiting for end of tty_to_commlib thread\n"));
thread_join(pthread_tty_to_commlib);
cleanup:
/*
* Set our terminal back to 'unraw' mode. Should be done automatically
* by OS on process end, but we want to be sure.
*/
ret = terminal_leave_raw_mode();
DPRINTF(("terminal_leave_raw_mode() returned %s (%d)\n", strerror(ret), ret));
if (ret != 0) {
sge_dstring_sprintf(p_err_msg, "error resetting terminal mode: %s (%d)", strerror(ret));
ret_val = 7;
}
*p_exit_status = g_exit_status;
thread_cleanup_lib(&thread_lib_handle);
DRETURN(ret_val);
}
extern int
main(int argc, char** argv)
{
int retval = 0;
int arg = 0;
struct in_addr addr;
struct in_addr addr2;
char* rhost = NULL;
int loops = -1;
if (argc < 3) {
printf("usage: test_cl_hostname_list <DEBUGLEVEL> hostnames\n");
exit(1);
}
printf("commlib setup ...\n");
retval = cl_com_setup_commlib(CL_NO_THREAD, (cl_log_t)atoi(argv[1]), NULL);
printf("%s\n\n",cl_get_error_text(retval));
printf("reslovling host addr 129.157.141.10 ...\n");
addr = inet_makeaddr(129*256+157,141*256+10);
printf("ip addr: %s\n",inet_ntoa(addr)); /* inet_ntoa() is not MT save */
addr2 = inet_makeaddr(192*256+168,11*256+1);
printf("ip addr2: %s\n",inet_ntoa(addr2)); /* inet_ntoa() is not MT save */
while ((loops--) != 0) {
arg = 2;
printf("loop\n\n\n");
while( argv[arg] != NULL) {
printf("resolving host \"%s\" ...\n", argv[arg]);
retval = cl_com_cached_gethostbyname(argv[arg],&rhost,NULL,NULL,NULL);
printf("%s\n",cl_get_error_text(retval));
if (rhost != NULL) {
printf(" -> host resolved as \"%s\"\n", rhost );
free(rhost);
rhost = NULL;
}
printf("cl_com_gethostbyaddr ... %s\n", inet_ntoa(addr)); /* inet_ntoa() is not MT save */
retval = cl_com_cached_gethostbyaddr(&addr, &rhost, NULL, NULL);
printf("%s\n",cl_get_error_text(retval));
if (retval == CL_RETVAL_OK) {
printf(" -> host name is \"%s\"\n", rhost);
}
free(rhost);
rhost = NULL;
printf("cl_com_gethostbyaddr ... %s\n",inet_ntoa(addr2) ); /* inet_ntoa() is not MT save */
retval = cl_com_cached_gethostbyaddr(&addr2, &rhost, NULL, NULL);
printf("%s\n",cl_get_error_text(retval));
if (retval == CL_RETVAL_OK) {
printf(" -> host name is \"%s\"\n", rhost);
}
free(rhost);
rhost = NULL;
printf("***********************************************************\n");
arg++;
}
sleep(1);
}
printf("commlib cleanup ...\n");
retval = cl_com_cleanup_commlib();
printf("%s\n\n",cl_get_error_text(retval));
printf("main done\n");
return 0;
}
/*-------------------------------------------------------------------------*/
int main(int argc, char **argv)
{
int ret;
int my_pid;
int ret_val;
int printed_points = 0;
int max_enroll_tries;
static char tmp_err_file_name[SGE_PATH_MAX];
time_t next_prof_output = 0;
int execd_exit_state = 0;
lList **master_job_list = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
lList *alp = NULL;
DENTER_MAIN(TOP_LAYER, "execd");
#if defined(LINUX)
gen_procList ();
#endif
prof_mt_init();
set_thread_name(pthread_self(),"Execd Thread");
prof_set_level_name(SGE_PROF_CUSTOM1, "Execd Thread", NULL);
prof_set_level_name(SGE_PROF_CUSTOM2, "Execd Dispatch", NULL);
#ifdef __SGE_COMPILE_WITH_GETTEXT__
/* init language output for gettext() , it will use the right language */
sge_init_language_func((gettext_func_type) gettext,
(setlocale_func_type) setlocale,
(bindtextdomain_func_type) bindtextdomain,
(textdomain_func_type) textdomain);
sge_init_language(NULL,NULL);
#endif /* __SGE_COMPILE_WITH_GETTEXT__ */
/* This needs a better solution */
umask(022);
/* Initialize path for temporary logging until we chdir to spool */
my_pid = getpid();
sprintf(tmp_err_file_name,"%s."sge_U32CFormat"", TMP_ERR_FILE_EXECD, sge_u32c(my_pid));
log_state_set_log_file(tmp_err_file_name);
/* exit func for SGE_EXIT() */
sge_sig_handler_in_main_loop = 0;
sge_setup_sig_handlers(EXECD);
if (sge_setup2(&ctx, EXECD, MAIN_THREAD, &alp, false) != AE_OK) {
answer_list_output(&alp);
SGE_EXIT((void**)&ctx, 1);
}
ctx->set_exit_func(ctx, execd_exit_func);
#if defined(SOLARIS)
/* Init shared SMF libs if necessary */
if (sge_smf_used() == 1 && sge_smf_init_libs() != 0) {
SGE_EXIT((void**)&ctx, 1);
}
#endif
/* prepare daemonize */
if (!getenv("SGE_ND")) {
sge_daemonize_prepare(ctx);
}
if ((ret=sge_occupy_first_three())>=0) {
CRITICAL((SGE_EVENT, MSG_FILE_REDIRECTFD_I, ret));
SGE_EXIT((void**)&ctx, 1);
}
lInit(nmv);
/* unset XAUTHORITY if set */
if (getenv("XAUTHORITY") != NULL) {
sge_unsetenv("XAUTHORITY");
}
parse_cmdline_execd(argv);
/* exit if we can't get communication handle (bind port) */
max_enroll_tries = 30;
while (cl_com_get_handle(prognames[EXECD],1) == NULL) {
ctx->prepare_enroll(ctx);
max_enroll_tries--;
if (max_enroll_tries <= 0 || shut_me_down) {
/* exit after 30 seconds */
if (printed_points != 0) {
printf("\n");
}
CRITICAL((SGE_EVENT, MSG_COM_ERROR));
SGE_EXIT((void**)&ctx, 1);
}
if (cl_com_get_handle(prognames[EXECD],1) == NULL) {
/* sleep when prepare_enroll() failed */
sleep(1);
if (max_enroll_tries < 27) {
printf(".");
printed_points++;
fflush(stdout);
}
}
}
if (printed_points != 0) {
printf("\n");
}
/*
* now the commlib up and running. Set execd application status function
* ( commlib callback function for qping status information response
* messages (SIRM) )
*/
ret_val = cl_com_set_status_func(sge_execd_application_status);
if (ret_val != CL_RETVAL_OK) {
ERROR((SGE_EVENT, cl_get_error_text(ret_val)) );
}
/* test connection */
{
cl_com_SIRM_t* status = NULL;
ret_val = cl_commlib_get_endpoint_status(ctx->get_com_handle(ctx),
(char *)ctx->get_master(ctx, true),
(char*)prognames[QMASTER], 1, &status);
if (ret_val != CL_RETVAL_OK) {
ERROR((SGE_EVENT, cl_get_error_text(ret_val)));
ERROR((SGE_EVENT, MSG_CONF_NOCONFBG));
}
cl_com_free_sirm_message(&status);
}
/* finalize daeamonize */
if (!getenv("SGE_ND")) {
sge_daemonize_finalize(ctx);
}
/* daemonizes if qmaster is unreachable */
sge_setup_sge_execd(ctx, tmp_err_file_name);
/* are we using qidle or not */
sge_ls_qidle(mconf_get_use_qidle());
sge_ls_gnu_ls(1);
DPRINTF(("use_qidle: %d\n", mconf_get_use_qidle()));
/* test load sensor (internal or external) */
{
lList *report_list = sge_build_load_report(ctx->get_qualified_hostname(ctx), ctx->get_binary_path(ctx));
lFreeList(&report_list);
}
/* here we have to wait for qmaster registration */
while (sge_execd_register_at_qmaster(ctx, false) != 0) {
if (sge_get_com_error_flag(EXECD, SGE_COM_ACCESS_DENIED, true)) {
/* This is no error */
DPRINTF(("***** got SGE_COM_ACCESS_DENIED from qmaster *****\n"));
}
if (sge_get_com_error_flag(EXECD, SGE_COM_ENDPOINT_NOT_UNIQUE, false)) {
execd_exit_state = SGE_COM_ENDPOINT_NOT_UNIQUE;
break;
}
if (shut_me_down != 0) {
break;
}
sleep(30);
}
/*
* Terminate on SIGTERM or hard communication error
*/
if (execd_exit_state != 0 || shut_me_down != 0) {
sge_shutdown((void**)&ctx, execd_exit_state);
DRETURN(execd_exit_state);
}
/*
* We write pid file when we are connected to qmaster. Otherwise an old
* execd might overwrite our pidfile.
*/
sge_write_pid(EXECD_PID_FILE);
/*
* At this point we are sure we are the only sge_execd and we are connected
* to the current qmaster. First we have to report any reaped children
* that might exist.
*/
starting_up();
/*
* Log a warning message if execd hasn't been started by a superuser
*/
if (!sge_is_start_user_superuser()) {
WARNING((SGE_EVENT, MSG_SWITCH_USER_NOT_ROOT));
}
#ifdef COMPILE_DC
if (ptf_init()) {
CRITICAL((SGE_EVENT, MSG_EXECD_NOSTARTPTF));
SGE_EXIT((void**)&ctx, 1);
}
INFO((SGE_EVENT, MSG_EXECD_STARTPDCANDPTF));
#endif
master_job_list = object_type_get_master_list(SGE_TYPE_JOB);
*master_job_list = lCreateList("Master_Job_List", JB_Type);
job_list_read_from_disk(master_job_list, "Master_Job_List",
0, SPOOL_WITHIN_EXECD,
job_initialize_job);
/* clean up jobs hanging around (look in active_dir) */
clean_up_old_jobs(ctx, 1);
execd_trash_load_report();
sge_set_flush_lr_flag(true);
sge_sig_handler_in_main_loop = 1;
if (thread_prof_active_by_id(pthread_self())) {
prof_start(SGE_PROF_CUSTOM1, NULL);
prof_start(SGE_PROF_CUSTOM2, NULL);
prof_start(SGE_PROF_GDI_REQUEST, NULL);
} else {
prof_stop(SGE_PROF_CUSTOM1, NULL);
prof_stop(SGE_PROF_CUSTOM2, NULL);
prof_stop(SGE_PROF_GDI_REQUEST, NULL);
}
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM1);
/* Start dispatching */
execd_exit_state = sge_execd_process_messages(ctx);
/*
* This code is only reached when dispatcher terminates and execd goes down.
*/
/* log if we received SIGPIPE signal */
if (sge_sig_handler_sigpipe_received) {
sge_sig_handler_sigpipe_received = 0;
INFO((SGE_EVENT, "SIGPIPE received\n"));
}
#if defined(LINUX)
free_procList();
#endif
lFreeList(master_job_list);
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM1);
if (prof_is_active(SGE_PROF_ALL)) {
time_t now = (time_t)sge_get_gmt();
if (now > next_prof_output) {
prof_output_info(SGE_PROF_ALL, false, "profiling summary:\n");
prof_reset(SGE_PROF_ALL,NULL);
next_prof_output = now + 60;
}
}
sge_prof_cleanup();
sge_shutdown((void**)&ctx, execd_exit_state);
DRETURN(execd_exit_state);
}
