/* do a clean exit */
void clean_exit(int sig) {
gm_log( GM_LOG_TRACE, "clean_exit(%d)\n", sig);
if(mod_gm_opt->pidfile != NULL)
unlink(mod_gm_opt->pidfile);
/* stop all children */
stop_children(GM_WORKER_STOP);
/* detach shm */
if(shmdt(shm) < 0)
perror("shmdt");
/*
* clean up shared memory
* will be removed when last client detaches
*/
if( shmctl( shmid, IPC_RMID, 0 ) == -1 ) {
perror("shmctl");
} else {
gm_log( GM_LOG_DEBUG, "shared memory deleted\n");
}
gm_log( GM_LOG_INFO, "mod_gearman worker exited\n");
mod_gm_free_opt(mod_gm_opt);
exit( EXIT_SUCCESS );
}
/* work starts here */
int main (int argc, char **argv) {
int rc;
/*
* allocate options structure
* and parse command line
*/
if(parse_arguments(argc, argv) != GM_OK) {
print_usage();
exit( STATE_UNKNOWN );
}
/* set logging */
mod_gm_opt->debug_level = GM_LOG_INFO;
mod_gm_opt->logmode = GM_LOG_MODE_TOOLS;
/* init crypto functions */
if(mod_gm_opt->encryption == GM_ENABLED) {
mod_gm_crypt_init(mod_gm_opt->crypt_key);
} else {
mod_gm_opt->transportmode = GM_ENCODE_ONLY;
}
/* create client */
if ( create_client( mod_gm_opt->server_list, &client ) != GM_OK ) {
printf( "send_multi UNKNOWN: cannot start client\n" );
exit( STATE_UNKNOWN );
}
/* create duplicate client */
if ( create_client_dup( mod_gm_opt->dupserver_list, &client_dup ) != GM_OK ) {
printf( "send_multi UNKNOWN: cannot start client for duplicate server\n" );
exit( STATE_UNKNOWN );
}
/* send result message */
signal(SIGALRM, alarm_sighandler);
rc = read_multi_stream(stdin);
/* if rc > 0, it contains the number of checks being submitted,
otherwise its an error code (-1 - WARNING, -2 - CRITICAL, -3 - UNKNOWN) */
if (rc == 0) {
printf( "send_multi UNKNOWN: %d check_multi child checks submitted\n", rc );
rc=STATE_UNKNOWN;
}
else if (rc > 0) {
printf( "send_multi OK: %d check_multi child check%s submitted\n", rc, (rc>1)?"s":"" );
rc=STATE_OK;
} else {
rc*=-1;
}
gearman_client_free( &client );
if( mod_gm_opt->dupserver_num )
gearman_client_free( &client_dup );
mod_gm_free_opt(mod_gm_opt);
exit( rc );
}
/* deregister all events */
int nebmodule_deinit( int flags, int reason ) {
int x;
gm_log( GM_LOG_TRACE, "nebmodule_deinit(%i, %i)\n", flags, reason );
/* should be removed already, but just for the case it wasn't */
neb_deregister_callback( NEBCALLBACK_PROCESS_DATA, gearman_module_handle );
neb_deregister_callback( NEBCALLBACK_TIMED_EVENT_DATA, gearman_module_handle );
/* only if we have hostgroups defined or general hosts enabled */
if ( mod_gm_opt->do_hostchecks == GM_ENABLED && ( mod_gm_opt->hostgroups_num > 0 || mod_gm_opt->hosts == GM_ENABLED ))
neb_deregister_callback( NEBCALLBACK_HOST_CHECK_DATA, gearman_module_handle );
/* only if we have groups defined or general services enabled */
if ( mod_gm_opt->servicegroups_num > 0 || mod_gm_opt->hostgroups_num > 0 || mod_gm_opt->services == GM_ENABLED )
neb_deregister_callback( NEBCALLBACK_SERVICE_CHECK_DATA, gearman_module_handle );
if ( mod_gm_opt->events == GM_ENABLED )
neb_deregister_callback( NEBCALLBACK_EVENT_HANDLER_DATA, gearman_module_handle );
if ( mod_gm_opt->perfdata == GM_ENABLED ) {
neb_deregister_callback( NEBCALLBACK_HOST_CHECK_DATA, gearman_module_handle );
neb_deregister_callback( NEBCALLBACK_SERVICE_CHECK_DATA, gearman_module_handle );
}
/* register export callbacks */
for(x=0;x<GM_NEBTYPESSIZE;x++) {
if(mod_gm_opt->exports[x]->elem_number > 0)
neb_deregister_callback( x, gearman_module_handle );
}
neb_deregister_callback( NEBCALLBACK_PROCESS_DATA, gearman_module_handle );
gm_log( GM_LOG_DEBUG, "deregistered callbacks\n" );
/* stop result threads */
for(x = 0; x < result_threads_running; x++) {
pthread_cancel(result_thr[x]);
pthread_join(result_thr[x], NULL);
}
/* cleanup */
free_client(&client);
/* close old logfile */
if(mod_gm_opt->logfile_fp != NULL) {
fclose(mod_gm_opt->logfile_fp);
}
mod_gm_free_opt(mod_gm_opt);
return NEB_OK;
}
/* do a clean exit */
void clean_worker_exit(int sig) {
int *shm;
/* give us 30 seconds to stop */
signal(SIGALRM, exit_sighandler);
alarm(30);
gm_log( GM_LOG_TRACE, "clean_worker_exit(%d)\n", sig);
/* clear gearmans job, otherwise it would be retried and retried */
if(current_gearman_job != NULL) {
if(sig == SIGINT) {
/* if worker stopped with sigint, let the job retry */
} else {
send_failed_result(current_job, sig);
gearman_job_send_complete(current_gearman_job, NULL, 0);
}
/* make sure no processes are left over */
kill_child_checks();
}
gm_log( GM_LOG_TRACE, "cleaning worker\n");
gearman_worker_unregister_all(&worker);
gearman_job_free_all( &worker );
gm_log( GM_LOG_TRACE, "cleaning client\n");
gearman_client_free( &client );
mod_gm_free_opt(mod_gm_opt);
#ifdef EMBEDDEDPERL
deinit_embedded_perl(0);
#endif
if(worker_run_mode == GM_WORKER_STANDALONE)
exit( EXIT_SUCCESS );
/* Now we attach the segment to our data space. */
if((shm = shmat(shmid, NULL, 0)) == (int *) -1) {
perror("shmat");
gm_log( GM_LOG_TRACE, "worker finished: %d\n", getpid() );
_exit( EXIT_FAILURE );
}
/* clean our pid from worker list */
if( shm[shm_index] == current_pid || shm[shm_index] == -current_pid ) {
shm[shm_index] = -1;
}
/* detach from shared memory */
if(shmdt(shm) < 0)
perror("shmdt");
_exit( EXIT_SUCCESS );
}
int main (int argc, char **argv, char **env) {
argc = argc; argv = argv; env = env;
char *result, *error;
char cmd[120];
int x;
/* set hostname */
gethostname(hostname, GM_BUFFERSIZE-1);
/* create options structure and set debug level */
mod_gm_opt = malloc(sizeof(mod_gm_opt_t));
set_default_options(mod_gm_opt);
mod_gm_opt->debug_level = 4;
#ifdef EMBEDDEDPERL
char p1[150];
snprintf(p1, 150, "--p1_file=worker/mod_gearman2_p1.pl");
parse_args_line(mod_gm_opt, p1, 0);
init_embedded_perl(env);
#endif
gm_job_t * exec_job;
exec_job = ( gm_job_t * )malloc( sizeof *exec_job );
set_default_job(exec_job, mod_gm_opt);
strcpy(cmd, "BLAH=BLUB /bin/hostname");
printf("this should be popen\n");
run_check(cmd, &result, &error);
free(result);
free(error);
strcpy(cmd, "/bin/hostname");
printf("this should be execvp\n");
run_check(cmd, &result, &error);
free(result);
free(error);
mod_gm_opt->debug_level = 0;
for(x=0;x<100;x++) {
run_check(cmd, &result, &error);
free(result);
free(error);
}
free_job(exec_job);
mod_gm_free_opt(mod_gm_opt);
#ifdef EMBEDDEDPERL
deinit_embedded_perl(0);
#endif
exit(0);
}
/* work starts here */
int main (int argc, char **argv) {
int rc;
/*
* allocate options structure
* and parse command line
*/
if(parse_arguments(argc, argv) != GM_OK) {
print_usage();
exit( STATE_UNKNOWN );
}
/* set logging */
mod_gm_opt->debug_level = GM_LOG_INFO;
mod_gm_opt->logmode = GM_LOG_MODE_TOOLS;
/* init crypto functions */
if(mod_gm_opt->encryption == GM_ENABLED) {
mod_gm_crypt_init(mod_gm_opt->crypt_key);
} else {
mod_gm_opt->transportmode = GM_ENCODE_ONLY;
}
/* create client */
if ( create_client( mod_gm_opt->server_list, &client ) != GM_OK ) {
printf( "send_gearman UNKNOWN: cannot start client\n" );
exit( STATE_UNKNOWN );
}
current_client = &client;
/* create duplicate client */
if ( mod_gm_opt->dupserver_num > 0 ) {
if ( create_client( mod_gm_opt->dupserver_list, &client_dup ) != GM_OK ) {
printf( "send_gearman UNKNOWN: cannot start client for duplicate server\n" );
exit( STATE_UNKNOWN );
}
}
current_client_dup = &client_dup;
/* send result message */
signal(SIGALRM, alarm_sighandler);
rc = send_result();
gearman_client_free( &client );
if( mod_gm_opt->dupserver_num )
gearman_client_free( &client_dup );
mod_gm_free_opt(mod_gm_opt);
exit( rc );
}
/* print usage */
void print_usage() {
printf("usage:\n");
printf("\n");
printf("send_gearman [ --debug=<lvl> ]\n");
printf(" [ --help|-h ]\n");
printf("\n");
printf(" [ --config=<configfile> ]\n");
printf("\n");
printf(" [ --server=<server> ]\n");
printf("\n");
printf(" [ --timeout|-t=<timeout> ]\n");
printf(" [ --delimiter|-d=<delimiter> ]\n");
printf("\n");
printf(" [ --encryption=<yes|no> ]\n");
printf(" [ --key=<string> ]\n");
printf(" [ --keyfile=<file> ]\n");
printf("\n");
printf(" [ --host=<hostname> ]\n");
printf(" [ --service=<servicename> ]\n");
printf(" [ --result_queue=<queue> ]\n");
printf(" [ --message|-m=<pluginoutput> ]\n");
printf(" [ --returncode|-r=<returncode> ]\n");
printf("\n");
printf("for sending active checks:\n");
printf(" [ --active ]\n");
printf(" [ --starttime=<unixtime> ]\n");
printf(" [ --finishtime=<unixtime> ]\n");
printf(" [ --latency=<seconds> ]\n");
printf("\n");
printf("plugin output is read from stdin unless --message is used.\n");
printf("Use this mode when plugin has multiple lines of plugin output.\n");
printf("\n");
printf("Note: When using a delimiter (-d) you may also submit one result\n");
printf(" for each line.\n");
printf(" Service Checks:\n");
printf(" <host_name>[tab]<svc_description>[tab]<return_code>[tab]<plugin_output>[newline]\n");
printf("\n");
printf(" Host Checks:\n");
printf(" <host_name>[tab]<return_code>[tab]<plugin_output>[newline]\n");
printf("\n");
printf("see README for a detailed explaination of all options.\n");
printf("\n");
mod_gm_free_opt(mod_gm_opt);
exit( STATE_UNKNOWN );
}
int main (int argc, char **argv, char **env) {
argc = argc; argv = argv; env = env;
#ifndef EMBEDDEDPERL
plan(1);
ok(1, "skipped epn tests");
return exit_status();
#endif
#ifdef EMBEDDEDPERL
int rc, rrc;
char *result, *error;
char cmd[120];
plan(21);
/* create options structure and set debug level */
mod_gm_opt = malloc(sizeof(mod_gm_opt_t));
set_default_options(mod_gm_opt);
char cmds[150];
strcpy(cmds, "--p1_file=worker/mod_gearman2_p1.pl");
parse_args_line(mod_gm_opt, cmds, 0);
strcpy(cmds, "--enable_embedded_perl=on");
parse_args_line(mod_gm_opt, cmds, 0);
strcpy(cmds, "--use_embedded_perl_implicitly=on");
parse_args_line(mod_gm_opt, cmds, 0);
/*
* mod_gm_opt->debug_level=4;
* dumpconfig(mod_gm_opt, GM_WORKER_MODE);
*/
ok(p1_file != NULL, "p1_file: %s", p1_file);
/*****************************************
* send_gearman
*/
init_embedded_perl(env);
rc=file_uses_embedded_perl("t/ok.pl");
cmp_ok(rc, "==", TRUE, "ok.pl: file_uses_embedded_perl returned rc %d", rc);
rc=file_uses_embedded_perl("t/noepn.pl");
cmp_ok(rc, "==", FALSE, "noepn.pl: file_uses_embedded_perl returned rc %d", rc);
strcpy(cmd, "./t/fail.pl");
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "ePN failed to compile", "returned result string");
like(error, "^$", "returned error string");
free(result);
free(error);
strcpy(cmd, "./t/ok.pl");
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "test plugin OK", "returned result string");
unlike(result, "plugin did not call exit", "returned result string");
like(error, "^$", "returned error string");
free(result);
free(error);
strcpy(cmd, "./t/crit.pl");
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 2, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "test plugin CRITICAL", "returned result string");
like(error, "some errors on stderr", "returned error string");
free(result);
free(error);
strcpy(cmd, "./t/noexit.pl");
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 3, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "sample output but no exit", "returned result string");
like(result, "plugin did not call exit", "returned result string");
like(error, "^$", "returned error string");
free(result);
free(error);
/* test mini epn */
strcpy(cmd, "./mod_gearman2_mini_epn ./t/ok.pl");
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "plugin return code: 0", "contains return code");
like(result, "perl plugin output: 'test plugin OK", "contains plugin output");
like(error, "^$", "returned error string");
free(result);
free(error);
/*****************************************
* clean up
*/
mod_gm_free_opt(mod_gm_opt);
deinit_embedded_perl(0);
return exit_status();
#endif
}
int main(void) {
plan(60);
/* lowercase */
char test[100];
ok(lc(NULL) == NULL, "lc(NULL)");
strcpy(test, "Yes"); like(lc(test), "yes", "lc(yes)");
strcpy(test, "YES"); like(lc(test), "yes", "lc(YES)");
strcpy(test, "yeS"); like(lc(test), "yes", "lc(yeS)");
/* trim */
strcpy(test, " text "); like(ltrim(test), "text ", "ltrim()");
strcpy(test, " text "); like(rtrim(test), " text", "rtrim()");
strcpy(test, " text "); like(trim(test), "text", "trim()");
char *test2;
test2 = strdup(" text "); like(trim(test2), "text", "trim()");
free(test2);
/* parse_yes_or_no */
ok(parse_yes_or_no(NULL, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 1");
ok(parse_yes_or_no(NULL, GM_DISABLED) == GM_DISABLED, "parse_yes_or_no 2");
strcpy(test, ""); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 3");
strcpy(test, ""); ok(parse_yes_or_no(test, GM_DISABLED) == GM_DISABLED, "parse_yes_or_no 4");
strcpy(test, "yes"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 5");
strcpy(test, "true"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 6");
strcpy(test, "Yes"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 7");
strcpy(test, "1"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 8");
strcpy(test, "On"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_ENABLED, "parse_yes_or_no 9");
strcpy(test, "Off"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 10");
strcpy(test, "false"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 11");
strcpy(test, "no"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 12");
strcpy(test, "0"); ok(parse_yes_or_no(test, GM_ENABLED) == GM_DISABLED, "parse_yes_or_no 13");
/* trim */
ok(trim(NULL) == NULL, "trim(NULL)");
strcpy(test, " test "); like(trim(test), "^test$", "trim(' test ')");
strcpy(test, "\ntest\n"); like(trim(test), "^test$", "trim('\\ntest\\n')");
/* reading keys */
mod_gm_opt_t *mod_gm_opt;
mod_gm_opt = malloc(sizeof(mod_gm_opt_t));
int rc = set_default_options(mod_gm_opt);
ok(rc == 0, "setting default options");
mod_gm_opt->keyfile = strdup("t/data/test1.key");
read_keyfile(mod_gm_opt);
//printf_hex(mod_gm_opt->crypt_key, 32);
test[0]='\x0';
int i = 0;
char hex[4];
for(i=0; i<32; i++) {
hex[0] = '\x0';
snprintf(hex, 4, "%02x", mod_gm_opt->crypt_key[i]);
strncat(test, hex, 4);
}
like(test, "3131313131313131313131313131313131313131313131313131313131310000", "read keyfile t/data/test1.key");
free(mod_gm_opt->keyfile);
mod_gm_opt->keyfile = strdup("t/data/test2.key");
read_keyfile(mod_gm_opt);
like(mod_gm_opt->crypt_key, "abcdef", "reading keyfile t/data/test2.key");
free(mod_gm_opt->keyfile);
mod_gm_opt->keyfile = strdup("t/data/test3.key");
read_keyfile(mod_gm_opt);
//printf_hex(mod_gm_opt->crypt_key, 32);
like(mod_gm_opt->crypt_key, "11111111111111111111111111111111", "reading keyfile t/data/test3.key");
ok(strlen(mod_gm_opt->crypt_key) == 32, "key size for t/data/test3.key");
/* encrypt */
char * key = "test1234";
char * encrypted = malloc(GM_BUFFERSIZE);
char * text = "test message";
char * base = "a7HqhQEE8TQBde9uknpPYQ==";
mod_gm_crypt_init(key);
int len;
len = mod_gm_encrypt(&encrypted, text, GM_ENCODE_AND_ENCRYPT);
ok(len == 24, "length of encrypted only");
like(encrypted, base, "encrypted string");
/* decrypt */
char * decrypted = malloc(GM_BUFFERSIZE);
mod_gm_decrypt(&decrypted, encrypted, GM_ENCODE_AND_ENCRYPT);
like(decrypted, text, "decrypted text");
free(decrypted);
free(encrypted);
/* base 64 */
char * base64 = malloc(GM_BUFFERSIZE);
len = mod_gm_encrypt(&base64, text, GM_ENCODE_ONLY);
ok(len == 16, "length of encode only");
like(base64, "dGVzdCBtZXNzYWdl", "base64 only string");
/* debase 64 */
char * debase64 = malloc(GM_BUFFERSIZE);
mod_gm_decrypt(&debase64, base64, GM_ENCODE_ONLY);
like(debase64, text, "debase64 text");
free(debase64);
free(base64);
/* file_exists */
ok(file_exists("01_utils") == 1, "file_exists('01_utils')");
ok(file_exists("non-exist") == 0, "file_exists('non-exist')");
/* nr2signal */
char * signame1 = nr2signal(9);
like(signame1, "SIGKILL", "get SIGKILL for 9");
free(signame1);
char * signame2 = nr2signal(15);
like(signame2, "SIGTERM", "get SIGTERM for 15");
free(signame2);
/* string2timeval */
struct timeval t;
string2timeval("100.50", &t);
ok(t.tv_sec == 100, "string2timeval 1");
ok(t.tv_usec == 50, "string2timeval 2");
string2timeval("100", &t);
ok(t.tv_sec == 100, "string2timeval 3");
ok(t.tv_usec == 0, "string2timeval 4");
string2timeval("", &t);
ok(t.tv_sec == 0, "string2timeval 5");
ok(t.tv_usec == 0, "string2timeval 6");
string2timeval(NULL, &t);
ok(t.tv_sec == 0, "string2timeval 7");
ok(t.tv_usec == 0, "string2timeval 8");
/* command line parsing */
mod_gm_free_opt(mod_gm_opt);
mod_gm_opt = renew_opts();
strcpy(test, "server=host:4730");
parse_args_line(mod_gm_opt, test, 0);
like(mod_gm_opt->server_list[0], "host:4730", "server=host:4730");
ok(mod_gm_opt->server_num == 1, "server_number = %d", mod_gm_opt->server_num);
mod_gm_free_opt(mod_gm_opt);
mod_gm_opt = renew_opts();
strcpy(test, "server=:4730");
parse_args_line(mod_gm_opt, test, 0);
like(mod_gm_opt->server_list[0], "localhost:4730", "server=:4730");
ok(mod_gm_opt->server_num == 1, "server_number = %d", mod_gm_opt->server_num);
mod_gm_free_opt(mod_gm_opt);
mod_gm_opt = renew_opts();
strcpy(test, "server=localhost:4730");
parse_args_line(mod_gm_opt, test, 0);
strcpy(test, "server=localhost:4730");
parse_args_line(mod_gm_opt, test, 0);
like(mod_gm_opt->server_list[0], "localhost:4730", "duplicate server");
ok(mod_gm_opt->server_num == 1, "server_number = %d", mod_gm_opt->server_num);
mod_gm_free_opt(mod_gm_opt);
mod_gm_opt = renew_opts();
strcpy(test, "server=localhost:4730,localhost:4730,:4730,host:4730,");
parse_args_line(mod_gm_opt, test, 0);
like(mod_gm_opt->server_list[0], "localhost:4730", "duplicate server");
like(mod_gm_opt->server_list[1], "host:4730", "duplicate server");
ok(mod_gm_opt->server_num == 2, "server_number = %d", mod_gm_opt->server_num);
/* escape newlines */
char * escaped = gm_escape_newlines(" test\n", GM_DISABLED);
is(escaped, " test\\n", "untrimmed escape string");
free(escaped);
escaped = gm_escape_newlines(" test\n", GM_ENABLED);
is(escaped, "test", "trimmed escape string");
free(escaped);
/* md5 sum */
char * sum = NULL;
strcpy(test, "");
sum = md5sum(test);
like(sum, "d41d8cd98f00b204e9800998ecf8427e", "md5sum()");
free(sum);
strcpy(test, "The quick brown fox jumps over the lazy dog.");
sum = md5sum(test);
like(sum, "e4d909c290d0fb1ca068ffaddf22cbd0", "md5sum()");
free(sum);
mod_gm_free_opt(mod_gm_opt);
return exit_status();
}
/* main tests */
int main (int argc, char **argv, char **env) {
argc = argc; argv = argv; env = env;
int status, chld, rc;
int tests = 125;
int rrc;
char cmd[150];
char *result, *error, *message, *output;
plan(tests);
mod_gm_opt = malloc(sizeof(mod_gm_opt_t));
set_default_options(mod_gm_opt);
#ifdef EMBEDDEDPERL
char p1[150];
snprintf(p1, 150, "--p1_file=worker/mod_gearman_p1.pl");
parse_args_line(mod_gm_opt, p1, 0);
init_embedded_perl(env);
#endif
char options[150];
snprintf(options, 150, "--server=127.0.0.1:%d", GEARMAND_TEST_PORT);
ok(parse_args_line(mod_gm_opt, options, 0) == 0, "parse_args_line()");
mod_gm_opt->debug_level = GM_LOG_ERROR;
worker_logfile = my_tmpfile();
if(!ok(worker_logfile != NULL, "created temp logile: %s", worker_logfile)) {
diag("could not create temp logfile");
exit( EXIT_FAILURE );
}
/* first fire up a gearmand server and one worker */
start_gearmand((void*)NULL);
sleep(2);
start_worker((void*)NULL);
sleep(2);
/* wait one second and catch died procs */
while((chld = waitpid(-1, &status, WNOHANG)) != -1 && chld > 0) {
diag( "waitpid() %d exited with %d\n", chld, status);
status = 0;
}
if(!ok(gearmand_pid > 0, "'gearmand started with port %d and pid: %d", GEARMAND_TEST_PORT, gearmand_pid)) {
diag("make sure gearmand is in your PATH. Common locations are /usr/sbin or /usr/local/sbin");
exit( EXIT_FAILURE );
}
if(!ok(pid_alive(gearmand_pid) == TRUE, "gearmand alive")) {
check_logfile("/tmp/gearmand.log", 3);
kill(gearmand_pid, SIGTERM);
kill(worker_pid, SIGTERM);
exit( EXIT_FAILURE );
}
if(!ok(worker_pid > 0, "worker started with pid: %d", worker_pid))
diag("could not start worker");
if(!ok(pid_alive(worker_pid) == TRUE, "worker alive")) {
check_logfile(worker_logfile, 3);
kill(gearmand_pid, SIGTERM);
kill(worker_pid, SIGTERM);
exit( EXIT_FAILURE );
}
skip(gearmand_pid <= 0 || worker_pid <= 0,
tests-3, /* Number of tests to skip */
"Skipping all tests, no need to go on without gearmand or worker");
/* create server / clients */
mod_gm_opt->transportmode = GM_ENCODE_ONLY;
create_modules();
/* send big job */
send_big_jobs(GM_ENCODE_ONLY);
//diag_queues();
wait_for_empty_queue("eventhandler", 20);
wait_for_empty_queue("service", 20);
//diag_queues();
do_result_work(1);
//diag_queues();
wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);
/*****************************************
* test check
*/
//diag_queues();
test_servicecheck(GM_ENCODE_ONLY, "./t/crit.pl");
//diag_queues();
wait_for_empty_queue("eventhandler", 20);
wait_for_empty_queue("service", 5);
//diag_queues();
do_result_work(1);
//diag_queues();
wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);
//diag_queues();
like(last_result, "test plugin CRITICAL", "stdout output from ./t/crit.pl");
like(last_result, "some errors on stderr", "stderr output from ./t/crit.pl");
/*****************************************
* test check2
*/
//diag_queues();
test_servicecheck(GM_ENCODE_ONLY, "./t/both");
//diag_queues();
wait_for_empty_queue("eventhandler", 20);
wait_for_empty_queue("service", 5);
//diag_queues();
do_result_work(1);
//diag_queues();
wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);
like(last_result, "stdout output", "stdout output from ./t/both");
like(last_result, "stderr output", "stderr output from ./t/both");
/* try to send some data with base64 only */
//diag_queues();
test_eventhandler(GM_ENCODE_ONLY);
//diag_queues();
test_servicecheck(GM_ENCODE_ONLY, NULL);
//diag_queues();
wait_for_empty_queue("eventhandler", 20);
wait_for_empty_queue("service", 5);
//diag_queues();
do_result_work(1);
//diag_queues();
wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);
sleep(1);
kill(worker_pid, SIGTERM);
waitpid(worker_pid, &status, 0);
ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status));
status = 0;
check_no_worker_running(worker_logfile);
check_logfile(worker_logfile, 0);
char * test_keys[] = {
"12345",
"test",
"test key 123",
"me make you loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong key"
};
/* ignore some signals for now */
signal(SIGTERM, SIG_IGN);
int i;
for(i=0;i<4;i++) {
mod_gm_opt->transportmode = GM_ENCODE_AND_ENCRYPT;
start_worker((void *)test_keys[i]);
mod_gm_crypt_init( test_keys[i] );
ok(1, "initialized with key: %s", test_keys[i]);
test_eventhandler(GM_ENCODE_AND_ENCRYPT);
test_servicecheck(GM_ENCODE_AND_ENCRYPT, NULL);
wait_for_empty_queue("eventhandler", 20);
wait_for_empty_queue("service", 5);
do_result_work(1);
wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);
sleep(1);
kill(worker_pid, SIGTERM);
waitpid(worker_pid, &status, 0);
ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status));
status = 0;
check_no_worker_running(worker_logfile);
check_logfile(worker_logfile, 0);
}
/*****************************************
* send_gearman
*/
snprintf(cmd, 150, "./send_gearman --server=127.0.0.1:%d --key=testtest --host=test --service=test --message=test --returncode=0", GEARMAND_TEST_PORT);
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "^\\s*$", "output from ./send_gearman");
free(result);
free(error);
/*****************************************
* send_multi
*/
snprintf(cmd, 150, "./send_multi --server=127.0.0.1:%d --host=blah < t/data/send_multi.txt", GEARMAND_TEST_PORT);
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "send_multi OK: 2 check_multi child checks submitted", "output from ./send_multi");
free(result);
free(error);
/*****************************************
* check_gearman
*/
snprintf(cmd, 150, "./check_gearman -H 127.0.0.1:%d -s check -a -q worker_test", GEARMAND_TEST_PORT);
rrc = real_exit_code(run_check(cmd, &result, &error));
cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);
like(result, "check_gearman OK - sending background job succeded", "output from ./check_gearman");
/* cleanup */
free(result);
free(error);
free_client(&client);
free_worker(&worker);
/* shutdown gearmand */
rc = send2gearmandadmin("shutdown\n", "127.0.0.1", GEARMAND_TEST_PORT, &output, &message);
ok(rc == 0, "rc of send2gearmandadmin %d", rc);
like(output, "OK", "output contains OK");
free(message);
free(output);
/* wait 5 seconds to shutdown */
for(i=0;i<=5;i++) {
waitpid(gearmand_pid, &status, WNOHANG);
if(pid_alive(gearmand_pid) == FALSE) {
todo();
ok(status == 0, "gearmand (%d) exited with: %d", gearmand_pid, real_exit_code(status));
endtodo;
break;
}
sleep(1);
}
if(pid_alive(gearmand_pid) == TRUE) {
/* kill it the hard way */
kill(gearmand_pid, SIGTERM);
waitpid(gearmand_pid, &status, 0);
ok(status == 0, "gearmand (%d) exited with exit code %d", gearmand_pid, real_exit_code(status));
status = 0;
ok(false, "gearmand had to be killed!");
}
todo();
check_logfile("/tmp/gearmand.log", status != 0 ? 2 : 0);
endtodo;
status = 0;
kill(worker_pid, SIGTERM);
waitpid(worker_pid, &status, 0);
ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status));
check_no_worker_running(worker_logfile);
status = 0;
#ifdef EMBEDDEDPERL
deinit_embedded_perl(0);
#endif
free(last_result);
free(worker_logfile);
endskip;
mod_gm_free_opt(mod_gm_opt);
return exit_status();
}
int main (int argc, char **argv, char **env) {
struct stat stat_buf;
#else
int main (int argc, char **argv) {
#endif
int sid, x;
#ifdef EMBEDDEDPERL
start_env=env;
#endif
last_time_increased = 0;
/* store the original command line for later reloads */
store_original_comandline(argc, argv);
/*
* allocate options structure
* and parse command line
*/
mod_gm_opt = gm_malloc(sizeof(mod_gm_opt_t));
set_default_options(mod_gm_opt);
if(parse_arguments(argc, argv) != GM_OK) {
exit( EXIT_FAILURE );
}
#ifdef EMBEDDEDPERL
/* make sure the P1 file exists... */
if(p1_file==NULL){
gm_log(GM_LOG_ERROR,"Error: p1.pl file required for embedded Perl interpreter is not set!\n");
exit( EXIT_FAILURE );
}
if(stat(p1_file,&stat_buf)!=0){
gm_log(GM_LOG_ERROR,"Error: p1.pl file required for embedded Perl interpreter is missing!\n");
perror("stat");
exit( EXIT_FAILURE );
}
#endif
/* fork into daemon mode? */
if(mod_gm_opt->daemon_mode == GM_ENABLED) {
pid_t pid = fork();
/* an error occurred while trying to fork */
if(pid == -1) {
perror("fork");
exit( EXIT_FAILURE );
}
/* we are the child process */
else if(pid == 0) {
gm_log( GM_LOG_INFO, "mod_gearman worker daemon started with pid %d\n", getpid());
/* Create a new SID for the child process */
sid = setsid();
if ( sid < 0 ) {
mod_gm_free_opt(mod_gm_opt);
exit( EXIT_FAILURE );
}
/* Close out the standard file descriptors */
if(mod_gm_opt->debug_level <= 1) {
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
}
}
/* we are the parent. So forking into daemon mode worked */
else {
mod_gm_free_opt(mod_gm_opt);
exit( EXIT_SUCCESS );
}
} else {
gm_log( GM_LOG_INFO, "mod_gearman worker started with pid %d\n", getpid());
}
/* print some version information */
gm_log( GM_LOG_DEBUG, "Version %s\n", GM_VERSION );
gm_log( GM_LOG_DEBUG, "running on libgearman %s\n", gearman_version() );
/* set signal handlers for a clean exit */
signal(SIGINT, clean_exit);
signal(SIGTERM,clean_exit);
signal(SIGHUP, reload_config);
signal(SIGPIPE, SIG_IGN);
/* check and write pid file */
if(write_pid_file() != GM_OK) {
exit(EXIT_FAILURE);
}
/* init crypto functions */
if(mod_gm_opt->encryption == GM_ENABLED) {
mod_gm_crypt_init(mod_gm_opt->crypt_key);
} else {
mod_gm_opt->transportmode = GM_ENCODE_ONLY;
}
gm_log( GM_LOG_DEBUG, "main process started\n");
/* start a single non forked standalone worker */
if(mod_gm_opt->debug_level >= 10) {
gm_log( GM_LOG_TRACE, "starting standalone worker\n");
#ifdef EMBEDDEDPERL
worker_client(GM_WORKER_STANDALONE, 1, shmid, start_env);
#else
worker_client(GM_WORKER_STANDALONE, 1, shmid);
#endif
exit(EXIT_SUCCESS);
}
/* setup shared memory */
setup_child_communicator();
/* start status worker */
make_new_child(GM_WORKER_STATUS);
/* setup children */
for(x=0; x < mod_gm_opt->min_worker; x++) {
make_new_child(GM_WORKER_MULTI);
}
/* maintain worker population */
monitor_loop();
gm_log( GM_LOG_ERROR, "worker exited from main loop\n");
clean_exit(15);
exit( EXIT_SUCCESS );
}
/* parse command line arguments */
int parse_arguments(int argc, char **argv) {
int i;
int errors = 0;
int verify;
mod_gm_opt_t * mod_gm_new_opt;
mod_gm_new_opt = gm_malloc(sizeof(mod_gm_opt_t));
set_default_options(mod_gm_new_opt);
for(i=1;i<argc;i++) {
char * arg = gm_strdup( argv[i] );
char * arg_c = arg;
if ( !strcmp( arg, "version" ) || !strcmp( arg, "--version" ) || !strcmp( arg, "-V" ) ) {
print_version();
}
if ( !strcmp( arg, "help" ) || !strcmp( arg, "--help" ) || !strcmp( arg, "-h" ) ) {
print_usage();
}
if(parse_args_line(mod_gm_new_opt, arg, 0) != GM_OK) {
errors++;
free(arg_c);
break;
}
free(arg_c);
}
/* set identifier to hostname unless specified */
if(mod_gm_new_opt->identifier == NULL) {
gethostname(hostname, GM_BUFFERSIZE-1);
mod_gm_new_opt->identifier = gm_strdup(hostname);
}
/* close old logfile */
if(mod_gm_opt->logfile_fp != NULL) {
fclose(mod_gm_opt->logfile_fp);
mod_gm_opt->logfile_fp = NULL;
}
/* verify options */
verify = verify_options(mod_gm_new_opt);
/* set new options */
if(errors == 0 && verify == GM_OK) {
mod_gm_free_opt(mod_gm_opt);
mod_gm_opt = mod_gm_new_opt;
}
/* open new logfile */
if ( mod_gm_new_opt->logmode == GM_LOG_MODE_AUTO && mod_gm_new_opt->logfile ) {
mod_gm_opt->logmode = GM_LOG_MODE_FILE;
}
if(mod_gm_new_opt->logmode == GM_LOG_MODE_FILE && mod_gm_opt->logfile && mod_gm_opt->debug_level < GM_LOG_STDOUT) {
mod_gm_opt->logfile_fp = fopen(mod_gm_opt->logfile, "a+");
if(mod_gm_opt->logfile_fp == NULL) {
perror(mod_gm_opt->logfile);
errors++;
}
}
/* read keyfile */
if(mod_gm_opt->keyfile != NULL && read_keyfile(mod_gm_opt) != GM_OK) {
errors++;
}
if(verify != GM_OK || errors > 0 || mod_gm_new_opt->debug_level >= GM_LOG_DEBUG) {
int old_debug = mod_gm_opt->debug_level;
mod_gm_opt->debug_level = GM_LOG_DEBUG;
dumpconfig(mod_gm_new_opt, GM_WORKER_MODE);
mod_gm_opt->debug_level = old_debug;
}
if(errors > 0 || verify != GM_OK) {
mod_gm_free_opt(mod_gm_new_opt);
return(GM_ERROR);
}
return(GM_OK);
}
