Gearman Developer Documentation

libgearman/universal.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_UNIVERSAL_H__
00015 #define __GEARMAN_UNIVERSAL_H__
00016 
00017 #ifdef __cplusplus
00018 extern "C" {
00019 #endif
00020 
00024 struct gearman_universal_st
00025 {
00026   struct {
00027     bool allocated LIBGEARMAN_BITFIELD; // Not Used (will remove later)
00028     bool dont_track_packets LIBGEARMAN_BITFIELD;
00029     bool non_blocking LIBGEARMAN_BITFIELD;
00030     bool stored_non_blocking LIBGEARMAN_BITFIELD;
00031   } options;
00032   gearman_verbose_t verbose;
00033   uint32_t con_count;
00034   uint32_t packet_count;
00035   uint32_t pfds_size;
00036   uint32_t sending;
00037   int last_errno;
00038   int timeout; // Used by poll()
00039   gearman_connection_st *con_list;
00040   gearman_packet_st *packet_list;
00041   struct pollfd *pfds;
00042   gearman_log_fn *log_fn;
00043   void *log_context;
00044   gearman_event_watch_fn *event_watch_fn;
00045   void *event_watch_context;
00046   gearman_malloc_fn *workload_malloc_fn;
00047   void *workload_malloc_context;
00048   gearman_free_fn *workload_free_fn;
00049   void *workload_free_context;
00050   char last_error[GEARMAN_MAX_ERROR_SIZE];
00051 };
00052 
00053 #ifdef GEARMAN_CORE
00054 
00055 
00081 GEARMAN_INTERNAL_API
00082 gearman_universal_st *gearman_universal_create(gearman_universal_st *source, const gearman_universal_options_t *options);
00083 
00091 GEARMAN_INTERNAL_API
00092 gearman_universal_st *gearman_universal_clone(gearman_universal_st *destination, const gearman_universal_st *source);
00093 
00100 GEARMAN_INTERNAL_API
00101 void gearman_universal_free(gearman_universal_st *gearman);
00102 
00111 GEARMAN_INTERNAL_API
00112 void gearman_universal_set_error(gearman_universal_st *gearman, const char *function,
00113                                  const char *format, ...);
00114 
00122 static inline const char *gearman_universal_error(const gearman_universal_st *gearman)
00123 {
00124   if (gearman->last_error[0] == 0)
00125       return NULL;
00126   return (const char *)(gearman->last_error);
00127 }
00128 
00136 static inline int gearman_universal_errno(const gearman_universal_st *gearman)
00137 {
00138   return gearman->last_errno;
00139 }
00140 
00148 GEARMAN_INTERNAL_API
00149 gearman_return_t gearman_universal_set_option(gearman_universal_st *gearman, gearman_universal_options_t option, bool value);
00150 
00151 static inline void gearman_universal_add_options(gearman_universal_st *gearman, gearman_universal_options_t options)
00152 {
00153   (void)gearman_universal_set_option(gearman, options, true);
00154 }
00155 
00156 static inline void gearman_universal_remove_options(gearman_universal_st *gearman, gearman_universal_options_t options)
00157 {
00158   (void)gearman_universal_set_option(gearman, options, false);
00159 }
00160 
00161 static inline bool gearman_universal_is_non_blocking(gearman_universal_st *gearman)
00162 {
00163   return gearman->options.non_blocking;
00164 }
00165 
00174 GEARMAN_INTERNAL_API
00175 int gearman_universal_timeout(gearman_universal_st *gearman);
00176 
00185 GEARMAN_INTERNAL_API
00186 void gearman_universal_set_timeout(gearman_universal_st *gearman, int timeout);
00187 
00198 GEARMAN_INTERNAL_API
00199 void gearman_set_log_fn(gearman_universal_st *gearman, gearman_log_fn *function,
00200                         void *context, gearman_verbose_t verbose);
00201 
00210 GEARMAN_INTERNAL_API
00211 void gearman_set_event_watch_fn(gearman_universal_st *gearman,
00212                                 gearman_event_watch_fn *function,
00213                                 void *context);
00214 
00225 GEARMAN_INTERNAL_API
00226 void gearman_set_workload_malloc_fn(gearman_universal_st *gearman,
00227                                     gearman_malloc_fn *function,
00228                                     void *context);
00229 
00240 GEARMAN_INTERNAL_API
00241 void gearman_set_workload_free_fn(gearman_universal_st *gearman,
00242                                   gearman_free_fn *function,
00243                                   void *context);
00244 
00251 GEARMAN_INTERNAL_API
00252 void gearman_free_all_cons(gearman_universal_st *gearman);
00253 
00261 GEARMAN_INTERNAL_API
00262 gearman_return_t gearman_flush_all(gearman_universal_st *gearman);
00263 
00271 GEARMAN_INTERNAL_API
00272 gearman_return_t gearman_wait(gearman_universal_st *gearman);
00273 
00281 GEARMAN_INTERNAL_API
00282 gearman_connection_st *gearman_ready(gearman_universal_st *gearman);
00283 
00293 GEARMAN_INTERNAL_API
00294 gearman_return_t gearman_echo(gearman_universal_st *gearman, const void *workload,
00295                               size_t workload_size);
00296 
00303 GEARMAN_INTERNAL_API
00304 void gearman_free_all_packets(gearman_universal_st *gearman);
00305 
00306 #endif /* GEARMAN_CORE */
00307 
00310 #ifdef __cplusplus
00311 }
00312 #endif
00313 
00314 #endif /* __GEARMAN_UNIVERSAL_H__ */