gearman_execute - Gearmand Documentation, http://gearman.info/

       Data Differential http://www.datadifferential.com/

       2011-2014, Data Differential, http://www.datadifferential.com/

1.1.20+ds                                         Mar 19, 2025                                GEARMAN_EXECUTE(3)

gearman_execute()  is  used to create a new gearman_task_st that is executed against the function that is
       found via the function_name argument.

       gearman_work_t  can  be  used  to  describe  the  work  that  will  be  executed,  it   is   built   with
       gearman_argument_make().  The argument unique_str is optional, but if supplied it is used for coalescence
       by gearmand.

       gearman_argument_t is the work that the client will send the to the server

       If  gearman_execute()  is  given  a  gearman_work_t  that  has  been  built  with a reducer, it takes the
       gearman_argument_t and executes it against a function as it normally would, but it tells the function  to
       then process the results through a reducer function that the gearman_work_t was created with.

       What is happening is that the function is mappping/splitting work up into units, and then sending each of
       them to the reducer function. Once all work is completed, the mapper function will aggregate the work via
       an aggregator function, gearman_aggregator_fn, and return a result.

       If  any  of  the  units of work error, the job will be aborted. The resulting value will be stored in the
       gearman_task_st.

       The result can be obtained from the task by calling gearman_task_result() to gain the gearman_result_st.

          /*
            Example code to show how to send a string to a function called "reverse" and print the results.
          */

          /*
          # Gearman server and library
          # Copyright (C) 2012 Data Differential, http://datadifferential.com/
          # All rights reserved.
          #
          # Use and distribution licensed under the BSD license.  See
          # the COPYING file in this directory for full text.
          */

          #include <string.h>
          #include <stdlib.h>
          #include <stdio.h>
          #include <libgearman/gearman.h>

          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_argument_t value= gearman_argument_make(0, 0, "Reverse Me", strlen("Reverse Me"));

            gearman_task_st *task= gearman_execute(client,
                                                   "reverse", strlen("reverse"),  // function
                                                   NULL, 0,  // no unique value provided
                                                   NULL,
                                                   &value, 0);

            if (task == NULL) // If gearman_execute() can return NULL on error
            {
              fprintf(stderr, "Error: %s\n", gearman_client_error(client));
              gearman_client_free(client);
              return EXIT_FAILURE;
            }

            // Make sure the task was run successfully
            if (gearman_success(gearman_task_return(task)))
            {
              // Make use of value
              gearman_result_st *result= gearman_task_result(task);
              printf("%.*s\n", (int)gearman_result_size(result), gearman_result_value(result));
            }

            gearman_client_free(client);

            return EXIT_SUCCESS;
          }

       To find out more information please check: http://gearman.info/

       gearman_execute - Gearmand Documentation, http://gearman.info/

gearman_execute() returns a c:type:gearman_task_st.

gearmand(8)libgearman(3)

       #include <libgearman/gearman.h>

       gearman_task_st*gearman_execute(gearman_client_st*client,constchar*function_name,size_tfunction_name_length,constchar*unique,size_tunique_length,gearman_work_t*workload,gearman_argument_t*arguments,void*context)gearman_task_st*gearman_execute_by_partition(gearman_client_st*client,constchar*partition_function,constsize_tpartition_function_length,constchar*function_name,constsize_tfunction_name_length,constchar*unique_str,constsize_tunique_length,gearman_work_t*workload,gearman_argument_t*arguments,void*context)

       Link with -lgearman