GEARMAN_EXECUTE(3)

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

SYNOPSIS

#include <libgearman/gearman.h>

    gearman_task_st <#c.gearman_task_st> *gearman_execute(gearman_client_st <#c.gearman_client_st> *client, const char *function_name, size_t <#c.size_t> function_name_length, const char *unique, size_t <#c.size_t> unique_length, gearman_work_t <#c.gearman_work_t> *workload, gearman_argument_t <#c.gearman_argument_t> *arguments, void *context)

    gearman_task_st <#c.gearman_task_st> *gearman_execute_by_partition(gearman_client_st <#c.gearman_client_st> *client, const char *partition_function, const size_t <#c.size_t> partition_function_length, const char *function_name, const size_t <#c.size_t> function_name_length, const char *unique_str, const size_t <#c.size_t> unique_length, gearman_work_t <#c.gearman_work_t> *workload, gearman_argument_t <#c.gearman_argument_t> *arguments, void *context)

Link with -lgearman

DESCRIPTION

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

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

gearman_argument_t <#c.gearman_argument_t> is the work that the client <#term-client> will send the to the server

If gearman_execute() is given a gearman_work_t <#c.gearman_work_t> that has been built with a reducer, it takes the gearman_argument_t <#c.gearman_argument_t> and executes it against a function <#term-function> as it normally would, but it tells the function to then process the results through a reducer <#term-reducer> function that the gearman_work_t <#c.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 <#term-mapper> function will aggregate the work via an aggregator function, gearman_aggregator_fn <#c.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 <#c.gearman_task_st>.

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

RETURN VALUE

gearman_execute() returns a c:type:gearman_task_st.

EXAMPLE

            /*
              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;
            }

HOME

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

SEE ALSO

gearmand(8) libgearman(3)

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

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