00001
00002
00003
00004
00005
00006
00007
00008
00014 #include "common.h"
00015
00016
00017
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 }