Gearman Public API Documentation

libgearman/client.h
Go to the documentation of this file.
00001 /* Gearman server and library
00002  * Copyright (C) 2008 Brian Aker, Eric Day
00003  * All rights reserved.
00004  *
00005  * Use and distribution licensed under the BSD license.  See
00006  * the COPYING file in the parent directory for full text.
00007  */
00008 
00014 #ifndef __GEARMAN_CLIENT_H__
00015 #define __GEARMAN_CLIENT_H__
00016 
00017 #ifdef __cplusplus
00018 extern "C" {
00019 #endif
00020 
00035 struct gearman_client_st
00036 {
00037   struct {
00038     bool allocated LIBGEARMAN_BITFIELD;
00039     bool non_blocking LIBGEARMAN_BITFIELD;
00040     bool task_in_use LIBGEARMAN_BITFIELD;
00041     bool unbuffered_result LIBGEARMAN_BITFIELD;
00042     bool no_new LIBGEARMAN_BITFIELD;
00043     bool free_tasks LIBGEARMAN_BITFIELD;
00044   } options;
00045   enum {
00046     GEARMAN_CLIENT_STATE_IDLE,
00047     GEARMAN_CLIENT_STATE_NEW,
00048     GEARMAN_CLIENT_STATE_SUBMIT,
00049     GEARMAN_CLIENT_STATE_PACKET
00050   } state;
00051   gearman_return_t do_ret;
00052   uint32_t new_tasks;
00053   uint32_t running_tasks;
00054   uint32_t task_count;
00055   size_t do_data_size;
00056   void *context;
00057   gearman_connection_st *con;
00058   gearman_task_st *task;
00059   gearman_task_st *task_list;
00060   gearman_task_context_free_fn *task_context_free_fn;
00061   void *do_data;
00062   gearman_workload_fn *workload_fn;
00063   gearman_created_fn *created_fn;
00064   gearman_data_fn *data_fn;
00065   gearman_warning_fn *warning_fn;
00066   gearman_universal_status_fn *status_fn;
00067   gearman_complete_fn *complete_fn;
00068   gearman_exception_fn *exception_fn;
00069   gearman_fail_fn *fail_fn;
00070   gearman_universal_st universal;
00071   gearman_task_st do_task;
00072 };
00073 
00083 GEARMAN_API
00084 gearman_client_st *gearman_client_create(gearman_client_st *client);
00085 
00093 GEARMAN_API
00094 gearman_client_st *gearman_client_clone(gearman_client_st *client,
00095                                         const gearman_client_st *from);
00096 
00103 GEARMAN_API
00104 void gearman_client_free(gearman_client_st *client);
00105 
00109 GEARMAN_API
00110 const char *gearman_client_error(const gearman_client_st *client);
00111 
00115 GEARMAN_API
00116 int gearman_client_errno(const gearman_client_st *client);
00117 
00125 GEARMAN_API
00126 gearman_client_options_t gearman_client_options(const gearman_client_st *client);
00127 
00135 GEARMAN_API
00136 void gearman_client_set_options(gearman_client_st *client,
00137                                 gearman_client_options_t options);
00138 
00146 GEARMAN_API
00147 void gearman_client_add_options(gearman_client_st *client,
00148                                 gearman_client_options_t options);
00149 
00157 GEARMAN_API
00158 void gearman_client_remove_options(gearman_client_st *client,
00159                                    gearman_client_options_t options);
00160 
00164 GEARMAN_API
00165 int gearman_client_timeout(gearman_client_st *client);
00166 
00170 GEARMAN_API
00171 void gearman_client_set_timeout(gearman_client_st *client, int timeout);
00172 
00180 GEARMAN_API
00181 void *gearman_client_context(const gearman_client_st *client);
00182 
00190 GEARMAN_API
00191 void gearman_client_set_context(gearman_client_st *client, void *context);
00192 
00196 GEARMAN_API
00197 void gearman_client_set_log_fn(gearman_client_st *client,
00198                                gearman_log_fn *function, void *context,
00199                                gearman_verbose_t verbose);
00200 
00204 GEARMAN_API
00205 void gearman_client_set_workload_malloc_fn(gearman_client_st *client,
00206                                            gearman_malloc_fn *function,
00207                                            void *context);
00208 
00212 GEARMAN_API
00213 void gearman_client_set_workload_free_fn(gearman_client_st *client,
00214                                          gearman_free_fn *function,
00215                                          void *context);
00216 
00227 GEARMAN_API
00228 gearman_return_t gearman_client_add_server(gearman_client_st *client,
00229                                            const char *host, in_port_t port);
00230 
00243 GEARMAN_API
00244 gearman_return_t gearman_client_add_servers(gearman_client_st *client,
00245                                             const char *servers);
00246 
00253 GEARMAN_API
00254 void gearman_client_remove_servers(gearman_client_st *client);
00255 
00263 GEARMAN_API
00264 gearman_return_t gearman_client_wait(gearman_client_st *client);
00265 
00299 GEARMAN_API
00300 void *gearman_client_do(gearman_client_st *client, const char *function_name,
00301                         const char *unique, const void *workload,
00302                         size_t workload_size, size_t *result_size,
00303                         gearman_return_t *ret_ptr);
00304 
00309 GEARMAN_API
00310 void *gearman_client_do_high(gearman_client_st *client,
00311                              const char *function_name, const char *unique,
00312                              const void *workload, size_t workload_size,
00313                              size_t *result_size, gearman_return_t *ret_ptr);
00314 
00319 GEARMAN_API
00320 void *gearman_client_do_low(gearman_client_st *client,
00321                             const char *function_name, const char *unique,
00322                             const void *workload, size_t workload_size,
00323                             size_t *result_size, gearman_return_t *ret_ptr);
00324 
00334 GEARMAN_API
00335 const char *gearman_client_do_job_handle(const gearman_client_st *client);
00336 
00346 GEARMAN_API
00347 void gearman_client_do_status(gearman_client_st *client, uint32_t *numerator,
00348                               uint32_t *denominator);
00349 
00363 GEARMAN_API
00364 gearman_return_t gearman_client_do_background(gearman_client_st *client,
00365                                               const char *function_name,
00366                                               const char *unique,
00367                                               const void *workload,
00368                                               size_t workload_size,
00369                                               char *job_handle);
00370 
00375 GEARMAN_API
00376 gearman_return_t gearman_client_do_high_background(gearman_client_st *client,
00377                                                    const char *function_name,
00378                                                    const char *unique,
00379                                                    const void *workload,
00380                                                    size_t workload_size,
00381                                                    char *job_handle);
00382 
00387 GEARMAN_API
00388 gearman_return_t gearman_client_do_low_background(gearman_client_st *client,
00389                                                   const char *function_name,
00390                                                   const char *unique,
00391                                                   const void *workload,
00392                                                   size_t workload_size,
00393                                                   char *job_handle);
00394 
00407 GEARMAN_API
00408 gearman_return_t gearman_client_job_status(gearman_client_st *client,
00409                                            const char *job_handle,
00410                                            bool *is_known, bool *is_running,
00411                                            uint32_t *numerator,
00412                                            uint32_t *denominator);
00413 
00424 GEARMAN_API
00425 gearman_return_t gearman_client_echo(gearman_client_st *client,
00426                                      const void *workload,
00427                                      size_t workload_size);
00428 
00446 GEARMAN_API
00447 void gearman_client_task_free_all(gearman_client_st *client);
00448 
00457 GEARMAN_API
00458 void gearman_client_set_task_context_free_fn(gearman_client_st *client,
00459                                              gearman_task_context_free_fn *function);
00460 
00476 GEARMAN_API
00477 gearman_task_st *gearman_client_add_task(gearman_client_st *client,
00478                                          gearman_task_st *task,
00479                                          void *context,
00480                                          const char *function_name,
00481                                          const char *unique,
00482                                          const void *workload,
00483                                          size_t workload_size,
00484                                          gearman_return_t *ret_ptr);
00485 
00490 GEARMAN_API
00491 gearman_task_st *gearman_client_add_task_high(gearman_client_st *client,
00492                                               gearman_task_st *task,
00493                                               void *context,
00494                                               const char *function_name,
00495                                               const char *unique,
00496                                               const void *workload,
00497                                               size_t workload_size,
00498                                               gearman_return_t *ret_ptr);
00499 
00504 GEARMAN_API
00505 gearman_task_st *gearman_client_add_task_low(gearman_client_st *client,
00506                                              gearman_task_st *task,
00507                                              void *context,
00508                                              const char *function_name,
00509                                              const char *unique,
00510                                              const void *workload,
00511                                              size_t workload_size,
00512                                              gearman_return_t *ret_ptr);
00513 
00518 GEARMAN_API
00519 gearman_task_st *gearman_client_add_task_background(gearman_client_st *client,
00520                                                     gearman_task_st *task,
00521                                                     void *context,
00522                                                     const char *function_name,
00523                                                     const char *unique,
00524                                                     const void *workload,
00525                                                     size_t workload_size,
00526                                                     gearman_return_t *ret_ptr);
00527 
00532 GEARMAN_API
00533 gearman_task_st *
00534 gearman_client_add_task_high_background(gearman_client_st *client,
00535                                         gearman_task_st *task,
00536                                         void *context,
00537                                         const char *function_name,
00538                                         const char *unique,
00539                                         const void *workload,
00540                                         size_t workload_size,
00541                                         gearman_return_t *ret_ptr);
00542 
00547 GEARMAN_API
00548 gearman_task_st *
00549 gearman_client_add_task_low_background(gearman_client_st *client,
00550                                        gearman_task_st *task,
00551                                        void *context,
00552                                        const char *function_name,
00553                                        const char *unique,
00554                                        const void *workload,
00555                                        size_t workload_size,
00556                                        gearman_return_t *ret_ptr);
00557 
00570 GEARMAN_API
00571 gearman_task_st *gearman_client_add_task_status(gearman_client_st *client,
00572                                                 gearman_task_st *task,
00573                                                 void *context,
00574                                                 const char *job_handle,
00575                                                 gearman_return_t *ret_ptr);
00576 
00584 GEARMAN_API
00585 void gearman_client_set_workload_fn(gearman_client_st *client,
00586                                     gearman_workload_fn *function);
00587 
00595 GEARMAN_API
00596 void gearman_client_set_created_fn(gearman_client_st *client,
00597                                    gearman_created_fn *function);
00598 
00606 GEARMAN_API
00607 void gearman_client_set_data_fn(gearman_client_st *client,
00608                                 gearman_data_fn *function);
00609 
00617 GEARMAN_API
00618 void gearman_client_set_warning_fn(gearman_client_st *client,
00619                                    gearman_warning_fn *function);
00620 
00628 GEARMAN_API
00629 void gearman_client_set_status_fn(gearman_client_st *client,
00630                                   gearman_universal_status_fn *function);
00631 
00639 GEARMAN_API
00640 void gearman_client_set_complete_fn(gearman_client_st *client,
00641                                     gearman_complete_fn *function);
00642 
00650 GEARMAN_API
00651 void gearman_client_set_exception_fn(gearman_client_st *client,
00652                                      gearman_exception_fn *function);
00653 
00661 GEARMAN_API
00662 void gearman_client_set_fail_fn(gearman_client_st *client,
00663                                 gearman_fail_fn *function);
00664 
00671 GEARMAN_API
00672 void gearman_client_clear_fn(gearman_client_st *client);
00673 
00681 GEARMAN_API
00682 gearman_return_t gearman_client_run_tasks(gearman_client_st *client);
00683 
00686 #ifdef __cplusplus
00687 }
00688 #endif
00689 
00690 #endif /* __GEARMAN_CLIENT_H__ */