/* 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 );
}
/* 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 );
}
//http://gearman.info/libgearman/gearman_client_do_background.html
//http://gearman.info/libgearman/gearman_client_options.html
int main(void)
{
gearman_client_st *client= gearman_client_create(NULL);
gearman_return_t ret= gearman_client_add_server(client, "localhost", 0);
if (gearman_failed(ret))
{
return EXIT_FAILURE;
}
gearman_job_handle_t job_handle;
gearman_return_t rc= gearman_client_do_background(client,
"echo",
NULL,// unique Optional unique job identifier, or NULL for a new UUID.如果写成唯一值只会提交一个任务（即使重复提交）
"hello-world",
strlen("hello-world"),
job_handle);
if (gearman_success(rc))
{
// Make use of value
printf("return %s\n", job_handle);
}
gearman_client_free(client);
return 0;
}
static void *client_thread(void *object)
{
(void)object;
gearman_return_t rc;
gearman_client_st client;
gearman_client_st *client_ptr;
size_t result_size;
client_ptr= gearman_client_create(&client);
if (client_ptr == NULL)
abort(); // This would be pretty bad.
rc= gearman_client_add_server(&client, NULL, CLIENT_TEST_PORT);
if (rc != GEARMAN_SUCCESS)
pthread_exit(0);
gearman_client_set_timeout(&client, 400);
for (size_t x= 0; x < 5; x++)
{
(void) gearman_client_do(&client, "client_test_temp", NULL, NULL, 0,
&result_size, &rc);
}
gearman_client_free(client_ptr);
pthread_exit(0);
}
int main(void)
{
gearman_client_st *client= gearman_client_create(NULL);
gearman_return_t ret= gearman_client_add_server(client, "localhost", 0);
if (gearman_failed(ret))
{
return EXIT_FAILURE;
}
size_t result_size;
gearman_return_t rc;
void *value= gearman_client_do(client, "reverse_function", "unique_value",
"my string to reverse", strlen("my string to reverse"),
&result_size, &rc);
if (gearman_success(rc))
{
// Make use of value
}
free(value);
gearman_client_free(client);
return 0;
}
int main (int argc, char **argv)
{
(void)argc;
(void)argv;
gearman_client_st client;
gearman_client_create(&client);
gearman_client_free(&client);
exit( 0 );
}
SEXP finalizeclient(SEXP Sclient){
rgearman_client_t *client = (rgearman_client_t *)R_ExternalPtrAddr(Sclient);
if (client){
gearman_client_free(client->client);
R_Free(client);
} else
warning("GearmanClient::finalize called with NULL client");
return R_NilValue;
}
/* 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(void)
{
gearman_client_st *client= gearman_client_create(NULL);
if (client == NULL)
{
return EXIT_FAILURE;
}
gearman_client_free(client);
return EXIT_SUCCESS;
}
/* main loop of jobs */
void worker_loop() {
while ( 1 ) {
gearman_return_t ret;
/* wait for a job, otherwise exit when hit the idle timeout */
if(mod_gm_opt->idle_timeout > 0 && ( worker_run_mode == GM_WORKER_MULTI || worker_run_mode == GM_WORKER_STATUS )) {
signal(SIGALRM, idle_sighandler);
alarm(mod_gm_opt->idle_timeout);
}
signal(SIGPIPE, SIG_IGN);
ret = gearman_worker_work( &worker );
if ( ret != GEARMAN_SUCCESS ) {
gm_log( GM_LOG_ERROR, "worker error: %s\n", gearman_worker_error( &worker ) );
gearman_job_free_all( &worker );
gearman_worker_free( &worker );
gearman_client_free( &client );
if( mod_gm_opt->dupserver_num )
gearman_client_free( &client_dup );
/* sleep on error to avoid cpu intensive infinite loops */
sleep(sleep_time_after_error);
sleep_time_after_error += 3;
if(sleep_time_after_error > 60)
sleep_time_after_error = 60;
/* create new connections */
set_worker( &worker );
create_client( mod_gm_opt->server_list, &client );
if( mod_gm_opt->dupserver_num )
create_client_dup( mod_gm_opt->dupserver_list, &client_dup );
}
}
return;
}
/* send job to worker and check result */
int check_worker(char * queue, char * to_send, char * expect) {
gearman_return_t ret;
char * result;
size_t result_size;
char * job_handle;
const char * unique_job_id;
if (opt_unique_id == NULL) {
unique_job_id = "check";
}
else {
unique_job_id = opt_unique_id;
}
/* create client */
if ( create_client( server_list, &client ) != GM_OK ) {
printf("%s UNKNOWN - cannot create gearman client\n", PLUGIN_NAME);
return( STATE_UNKNOWN );
}
gearman_client_set_timeout(&client, (opt_timeout-1)*1000/server_list_num);
while (1) {
if (send_async) {
result = gm_strdup("sending background job succeded");
job_handle = gm_malloc(GEARMAN_JOB_HANDLE_SIZE * sizeof(char));
ret= gearman_client_do_high_background( &client,
queue,
unique_job_id,
(void *)to_send,
(size_t)strlen(to_send),
job_handle);
free(job_handle);
}
else {
result= (char *)gearman_client_do_high( &client,
queue,
unique_job_id,
(void *)to_send,
(size_t)strlen(to_send),
&result_size,
&ret);
}
if (ret == GEARMAN_WORK_DATA) {
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS) {
continue;
}
else if (ret == GEARMAN_SUCCESS) {
gearman_client_free(&client);
}
else if (ret == GEARMAN_WORK_FAIL) {
printf("%s CRITICAL - Job failed\n", PLUGIN_NAME);
gearman_client_free(&client);
return( STATE_CRITICAL );
}
else {
printf("%s CRITICAL - Job failed: %s\n", PLUGIN_NAME, gearman_client_error(&client));
gearman_client_free(&client);
return( STATE_CRITICAL );
}
break;
}
if( !send_async && expect != NULL && result != NULL ) {
if( strstr(result, expect) != NULL) {
printf("%s OK - send worker '%s' response: '%s'\n", PLUGIN_NAME, to_send, result);
return( STATE_OK );
}
else {
printf("%s CRITICAL - send worker: '%s' response: '%s', expected '%s'\n", PLUGIN_NAME, to_send, result, expect);
return( STATE_CRITICAL );
}
}
printf("%s OK - %s\n", PLUGIN_NAME, result );
return( STATE_OK );
}
/* send job to worker and check result */
int check_worker(char * queue, char * to_send, char * expect) {
gearman_return_t ret;
char * result;
size_t result_size;
char * job_handle;
char unique_name[22];
struct timeval tv;
/* create client */
if ( create_client( server_list, &client ) != GM_OK ) {
printf("%s UNKNOWN - cannot create gearman client\n", PLUGIN_NAME);
return( STATE_UNKNOWN );
}
gearman_client_set_timeout(&client, (opt_timeout-1)*1000/server_list_num);
while (1) {
gettimeofday(&tv, NULL);
sprintf(unique_name, "check_%010lu%06lu", tv.tv_sec, tv.tv_usec);
if (send_async) {
result = "";
job_handle = malloc(GEARMAN_JOB_HANDLE_SIZE * sizeof(char));
ret= gearman_client_do_high_background( &client,
queue,
unique_name,
(void *)to_send,
(size_t)strlen(to_send),
job_handle);
free(job_handle);
}
else {
result= (char *)gearman_client_do_high( &client,
queue,
unique_name,
(void *)to_send,
(size_t)strlen(to_send),
&result_size,
&ret);
}
if (ret == GEARMAN_WORK_DATA) {
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS) {
continue;
}
else if (ret == GEARMAN_SUCCESS) {
gearman_client_free(&client);
}
else if (ret == GEARMAN_WORK_FAIL) {
printf("%s CRITICAL - Job failed\n", PLUGIN_NAME);
gearman_client_free(&client);
return( STATE_CRITICAL );
}
else {
printf("%s CRITICAL - Job failed: %s\n", PLUGIN_NAME, gearman_client_error(&client));
gearman_client_free(&client);
return( STATE_CRITICAL );
}
break;
}
if( !send_async && expect != NULL && result != NULL ) {
if( strstr(result, expect) != NULL) {
printf("%s OK - send worker '%s' response: '%s'\n", PLUGIN_NAME, to_send, result);
return( STATE_OK );
}
else {
printf("%s CRITICAL - send worker: '%s' response: '%s', expected '%s'\n", PLUGIN_NAME, to_send, result, expect);
return( STATE_CRITICAL );
}
}
printf("%s OK - %s\n", PLUGIN_NAME, result );
return( STATE_OK );
}
/* free client structure */
void free_client(gearman_client_st *client) {
gearman_client_free( client );
return;
}
/* create a task and send it */
int add_job_to_queue( gearman_client_st *client, char ** server_list, char * queue, char * uniq, char * data, int priority, int retries, int transport_mode, int send_now ) {
gearman_task_st *task = NULL;
gearman_return_t ret1, ret2;
char * crypted_data;
int size, free_uniq;
struct timeval now;
/* check too long queue names */
if(strlen(queue) > 63) {
gm_log( GM_LOG_ERROR, "queue name too long: '%s'\n", queue );
return GM_ERROR;
}
/* cut off to long uniq ids */
free_uniq = 0;
if(uniq != NULL && strlen(uniq) > 63) {
uniq = strndup(uniq, 63);
free_uniq = 1;
}
signal(SIGPIPE, SIG_IGN);
gm_log( GM_LOG_TRACE, "add_job_to_queue(%s, %s, %d, %d, %d, %d)\n", queue, uniq, priority, retries, transport_mode, send_now );
gm_log( GM_LOG_TRACE, "%d --->%s<---\n", strlen(data), data );
crypted_data = malloc(GM_BUFFERSIZE);
size = mod_gm_encrypt(&crypted_data, data, transport_mode);
gm_log( GM_LOG_TRACE, "%d +++>\n%s\n<+++\n", size, crypted_data );
#ifdef GM_DEBUG
/* verify decrypted string is equal to the original */
char * test;
test = malloc(GM_BUFFERSIZE);
mod_gm_decrypt(&test, crypted_data, transport_mode);
gm_log( GM_LOG_TRACE, "%d ===>\n%s\n<===\n", size, test );
if(strcmp(test, data)) {
gm_log( GM_LOG_ERROR, "%d --->%s<---\n", strlen(data), data );
gm_log( GM_LOG_ERROR, "%d ===>\n%s\n<===\n", size, test );
fprintf(stderr, "encrypted string does not match\n");
exit(EXIT_FAILURE);
}
#endif
if( priority == GM_JOB_PRIO_LOW ) {
task = gearman_client_add_task_low_background( client, NULL, NULL, queue, uniq, ( void * )crypted_data, ( size_t )size, &ret1 );
gearman_task_give_workload(task,crypted_data,size);
}
else if( priority == GM_JOB_PRIO_NORMAL ) {
task = gearman_client_add_task_background( client, NULL, NULL, queue, uniq, ( void * )crypted_data, ( size_t )size, &ret1 );
gearman_task_give_workload(task,crypted_data,size);
}
else if( priority == GM_JOB_PRIO_HIGH ) {
task = gearman_client_add_task_high_background( client, NULL, NULL, queue, uniq, ( void * )crypted_data, ( size_t )size, &ret1 );
gearman_task_give_workload(task,crypted_data,size);
}
else {
gm_log( GM_LOG_ERROR, "add_job_to_queue() wrong priority: %d\n", priority );
}
if(send_now != TRUE)
return GM_OK;
ret2 = gearman_client_run_tasks( client );
gearman_client_task_free_all( client );
if( ret1 != GEARMAN_SUCCESS
|| ret2 != GEARMAN_SUCCESS
|| task == NULL
|| ( gearman_client_error(client) != NULL && atof(gearman_version()) == 0.14 )
) {
/* log the error */
if(retries == 0) {
gettimeofday(&now,NULL);
/* only log the first error, otherwise we would fill the log very quickly */
if( mod_gm_con_errors == 0 ) {
gettimeofday(&mod_gm_error_time,NULL);
gm_log( GM_LOG_ERROR, "sending job to gearmand failed: %s\n", gearman_client_error(client) );
}
/* or every minute to give an update */
else if( now.tv_sec >= mod_gm_error_time.tv_sec + 60) {
gettimeofday(&mod_gm_error_time,NULL);
gm_log( GM_LOG_ERROR, "sending job to gearmand failed: %s (%i lost jobs so far)\n", gearman_client_error(client), mod_gm_con_errors );
}
mod_gm_con_errors++;
}
/* recreate client, otherwise gearman sigsegvs */
gearman_client_free( client );
create_client( server_list, client );
/* retry as long as we have retries */
if(retries > 0) {
retries--;
gm_log( GM_LOG_TRACE, "add_job_to_queue() retrying... %d\n", retries );
return(add_job_to_queue( client, server_list, queue, uniq, data, priority, retries, transport_mode, send_now ));
}
/* no more retries... */
else {
gm_log( GM_LOG_TRACE, "add_job_to_queue() finished with errors: %d %d\n", ret1, ret2 );
return GM_ERROR;
}
}
/* reset error counter */
mod_gm_con_errors = 0;
if(free_uniq)
free(uniq);
gm_log( GM_LOG_TRACE, "add_job_to_queue() finished sucessfully: %d %d\n", ret1, ret2 );
return GM_OK;
}
int main(int argc, char *argv[])
{
int c;
char *host= NULL;
in_port_t port= 0;
gearman_return_t ret;
gearman_client_st client;
char *result;
size_t result_size;
uint32_t numerator;
uint32_t denominator;
while ((c = getopt(argc, argv, "h:p:")) != -1)
{
switch(c)
{
case 'h':
host= optarg;
break;
case 'p':
port= (in_port_t)atoi(optarg);
break;
default:
usage(argv[0]);
exit(1);
}
}
if (argc != (optind + 1))
{
usage(argv[0]);
exit(1);
}
if (gearman_client_create(&client) == NULL)
{
fprintf(stderr, "Memory allocation failure on client creation\n");
exit(1);
}
ret= gearman_client_add_server(&client, host, port);
if (ret != GEARMAN_SUCCESS)
{
fprintf(stderr, "%s\n", gearman_client_error(&client));
exit(1);
}
while (1)
{
result= (char *)gearman_client_do(&client, "reverse", NULL,
(void *)argv[optind],
(size_t)strlen(argv[optind]),
&result_size, &ret);
if (ret == GEARMAN_WORK_DATA)
{
printf("Data=%.*s\n", (int)result_size, result);
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS)
{
gearman_client_do_status(&client, &numerator, &denominator);
printf("Status: %u/%u\n", numerator, denominator);
continue;
}
else if (ret == GEARMAN_SUCCESS)
{
printf("Result=%.*s\n", (int)result_size, result);
free(result);
}
else if (ret == GEARMAN_WORK_FAIL)
fprintf(stderr, "Work failed\n");
else
fprintf(stderr, "%s\n", gearman_client_error(&client));
break;
}
gearman_client_free(&client);
return 0;
}
int main()
{
gearman_client_st client;
if (gearman_client_create(&client) == NULL)
{
std::cerr << "Memory allocation failure on client creation" << std::endl;
return EXIT_FAILURE;
}
//
int timeout=-1;
//
if (timeout >= 0)
{
gearman_client_set_timeout(&client, timeout);
}
gearman_return_t ret= gearman_client_add_server(&client, "localhost", GEARMAN_DEFAULT_TCP_PORT);
if (ret != GEARMAN_SUCCESS)
{
std::cerr<<(gearman_client_error(&client));
return EXIT_FAILURE;
}
if (gearman_failed(gearman_client_set_identifier(&client, "client1", strlen("client1"))))
{
std::cerr<<(gearman_client_error(&client));
return EXIT_FAILURE;
}
int exit_code= EXIT_SUCCESS;
int count=1; //if status is to be returned then don't change count on status receive
do
{
size_t result_size;
char *result;
result= (char *)gearman_client_do(&client, "make_call", NULL,
"scheme-string", strlen("scheme-string"),
&result_size, &ret);
if (ret == GEARMAN_WORK_DATA)
{
std::cout.write(result, result_size);
free(result);
continue;
}
else if (ret == GEARMAN_WORK_STATUS)
{
uint32_t numerator;
uint32_t denominator;
gearman_client_do_status(&client, &numerator, &denominator);
std::clog << "Status: " << numerator << "/" << denominator << std::endl;
continue;
}
else if (ret == GEARMAN_SUCCESS)
{
std::cout.write(result, result_size);
free(result);
}
else if (ret == GEARMAN_WORK_FAIL)
{
std::cerr<<("Work failed");
exit_code= EXIT_FAILURE;
break;
}
else
{
std::cerr<<(gearman_client_error(&client));
exit_code= EXIT_FAILURE;
break;
}
--count;
} while (count);
gearman_client_free(&client);
return exit_code;
}
