int main(void){
gearman_worker_st worker;
//Create the worker
gearman_worker_create(&worker);
//Connect the worker to the server and chech it worked
gearman_return_t ret= gearman_worker_add_server(&worker, "localhost", 4730);
if (gearman_failed(ret)){
return EXIT_FAILURE;
}
//register function, (worker, job_queue_name, timeout, function_to_do_work, context)
ret = gearman_worker_add_function(&worker,"image",0,doing_work,NULL);
if(gearman_failed(ret)){
return EXIT_FAILURE;
}
//Infinite loop to keep watching
while(1){
//Does the work
ret = gearman_worker_work(&worker);
if ( ret != GEARMAN_SUCCESS ) {
fprintf(stderr,"worker error: %s\n", gearman_worker_error( &worker ) );
gearman_job_free_all( &worker );
gearman_worker_free( &worker );
/* sleep on error to avoid cpu intensive infinite loops */
sleep(5);
}
}
return EXIT_SUCCESS;
}
//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;
}
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;
}
//#include <boost/program_options.hpp>
static gearman_return_t worker_function(gearman_job_st *job, void *context)
{
const char *workload= (const char *)gearman_job_workload(job);
const size_t workload_size= gearman_job_workload_size(job);
std::cout << "Recieved " << workload_size << " bytes" << std::endl;
////
char *result=new char[workload_size];
memcpy(result,workload,workload_size);
/*
*if (gearman_failed(gearman_job_send_data(job, &result[y], 1)))
{
return GEARMAN_ERROR;
}
if (gearman_failed(gearman_job_send_status(job, (uint32_t)y, (uint32_t)workload_size)))
{
return GEARMAN_ERROR;
}
// Notice that we send based on y divided by zero.
if (gearman_failed(gearman_job_send_status(job, (uint32_t)workload_size, (uint32_t)workload_size)))
{
return GEARMAN_ERROR;
}
*/
if (gearman_failed(gearman_job_send_data(job, &result[0], workload_size)))
{
return GEARMAN_ERROR;
}
}
SEXP failed(SEXP Sclient){
rgearman_client_t *client = (rgearman_client_t *)R_ExternalPtrAddr(Sclient);
SEXP ret = PROTECT(allocVector(LGLSXP,1));
LOGICAL(ret)[0] = (gearman_failed(client->lastretcode))? TRUE : FALSE;
UNPROTECT(1);
return ret;
}
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;
}
int main()
{
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
{
std::cerr << "signal:" << strerror(errno) << std::endl;
return EXIT_FAILURE;
}
gearman_worker_st *worker;
if ((worker= gearman_worker_create(NULL)) == NULL)
{
std::cerr << "Memory allocation failure on worker creation." << std::endl;
return EXIT_FAILURE;
}
//if (unique)
//{
gearman_worker_add_options(worker, GEARMAN_WORKER_GRAB_UNIQ);
//}
int timeout=-1;
//
if (timeout >= 0)
{
gearman_worker_set_timeout(worker, timeout);
}
if (gearman_failed(gearman_worker_add_server(worker, "localhost", GEARMAN_DEFAULT_TCP_PORT)))
{
std::cerr << gearman_worker_error(worker) << std::endl;
return EXIT_FAILURE;
}
if (gearman_failed(gearman_worker_set_identifier(worker, "worker1", strlen("worker1"))))
{
std::cerr << gearman_worker_error(worker) << std::endl;
return EXIT_FAILURE;
}
gearman_function_t worker_fn= gearman_function_create(worker_function);
if (gearman_failed(gearman_worker_define_function(worker,
gearman_literal_param("make_call"),
worker_fn,
0,
NULL/*&options*/)))
{
std::cerr << gearman_worker_error(worker) << std::endl;
return EXIT_FAILURE;
}
int limit=0;
// Add one if count is not zero
if (limit != 0)
{
limit++;
}
while (--limit)
{
if (gearman_failed(gearman_worker_work(worker)))
{
std::cerr << gearman_worker_error(worker) << std::endl;
break;
}
}
gearman_worker_free(worker);
return EXIT_SUCCESS;
}
