Gearman Developer Documentation

libgearman/task.c
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 #include "common.h"
00015 
00016 /*
00017  * Public Definitions
00018  */
00019 
00020 gearman_task_st *gearman_task_create(gearman_client_st *client, gearman_task_st *task)
00021 {
00022   if (task == NULL)
00023   {
00024     task= malloc(sizeof(gearman_task_st));
00025     if (task == NULL)
00026     {
00027       gearman_universal_set_error(&client->universal, "_task_create", "malloc");
00028       return NULL;
00029     }
00030 
00031     task->options.allocated= true;
00032   }
00033   else
00034   {
00035     task->options.allocated= false;
00036   }
00037 
00038   task->options.send_in_use= false;
00039   task->options.is_known= false;
00040   task->options.is_running= false;
00041 
00042   task->state= 0;
00043   task->created_id= 0;
00044   task->numerator= 0;
00045   task->denominator= 0;
00046   task->client= client;
00047 
00048   if (client->task_list != NULL)
00049     client->task_list->prev= task;
00050   task->next= client->task_list;
00051   task->prev= NULL;
00052   client->task_list= task;
00053   client->task_count++;
00054 
00055   task->context= NULL;
00056   task->con= NULL;
00057   task->recv= NULL;
00058   task->job_handle[0]= 0;
00059 
00060   return task;
00061 }
00062 
00063 
00064 void gearman_task_free(gearman_task_st *task)
00065 {
00066   if (task->options.send_in_use)
00067     gearman_packet_free(&(task->send));
00068 
00069   if (task != &(task->client->do_task) && task->context != NULL &&
00070       task->client->task_context_free_fn != NULL)
00071   {
00072     task->client->task_context_free_fn(task, (void *)task->context);
00073   }
00074 
00075   if (task->client->task_list == task)
00076     task->client->task_list= task->next;
00077   if (task->prev != NULL)
00078     task->prev->next= task->next;
00079   if (task->next != NULL)
00080     task->next->prev= task->prev;
00081   task->client->task_count--;
00082 
00083   if (task->options.allocated)
00084     free(task);
00085 }
00086 
00087 const void *gearman_task_context(const gearman_task_st *task)
00088 {
00089   return task->context;
00090 }
00091 
00092 void gearman_task_set_context(gearman_task_st *task, void *context)
00093 {
00094   task->context= context;
00095 }
00096 
00097 const char *gearman_task_function_name(const gearman_task_st *task)
00098 {
00099   return task->send.arg[0];
00100 }
00101 
00102 const char *gearman_task_unique(const gearman_task_st *task)
00103 {
00104   return task->send.arg[1];
00105 }
00106 
00107 const char *gearman_task_job_handle(const gearman_task_st *task)
00108 {
00109   return task->job_handle;
00110 }
00111 
00112 bool gearman_task_is_known(const gearman_task_st *task)
00113 {
00114   return task->options.is_known;
00115 }
00116 
00117 bool gearman_task_is_running(const gearman_task_st *task)
00118 {
00119   return task->options.is_running;
00120 }
00121 
00122 uint32_t gearman_task_numerator(const gearman_task_st *task)
00123 {
00124   return task->numerator;
00125 }
00126 
00127 uint32_t gearman_task_denominator(const gearman_task_st *task)
00128 {
00129   return task->denominator;
00130 }
00131 
00132 void gearman_task_give_workload(gearman_task_st *task, const void *workload,
00133                                 size_t workload_size)
00134 {
00135   gearman_packet_give_data(&(task->send), workload, workload_size);
00136 }
00137 
00138 size_t gearman_task_send_workload(gearman_task_st *task, const void *workload,
00139                                   size_t workload_size,
00140                                   gearman_return_t *ret_ptr)
00141 {
00142   return gearman_connection_send_data(task->con, workload, workload_size, ret_ptr);
00143 }
00144 
00145 const void *gearman_task_data(const gearman_task_st *task)
00146 {
00147   return task->recv->data;
00148 }
00149 
00150 size_t gearman_task_data_size(const gearman_task_st *task)
00151 {
00152   return task->recv->data_size;
00153 }
00154 
00155 void *gearman_task_take_data(gearman_task_st *task, size_t *data_size)
00156 {
00157   return gearman_packet_take_data(task->recv, data_size);
00158 }
00159 
00160 size_t gearman_task_recv_data(gearman_task_st *task, void *data,
00161                                   size_t data_size,
00162                                   gearman_return_t *ret_ptr)
00163 {
00164   return gearman_connection_recv_data(task->con, data, data_size, ret_ptr);
00165 }