← Back to branch summary

~clint-fewbar/ubuntu/precise/gearmand/drop-unneeded-patches

« back to all changes in this revision

Viewing changes to libgearman/job.c

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2009-08-11 10:06:22 UTC
  • mto: (1.2.3 upstream) (6.1.1 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20090811100622-6ig4iknanc73olum
Import upstream version 0.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgearman/job.c
 
1
/* Gearman server and library
 
2
 * Copyright (C) 2008 Brian Aker, Eric Day
 
3
 * All rights reserved.
 
4
 *
 
5
 * Use and distribution licensed under the BSD license.  See
 
6
 * the COPYING file in the parent directory for full text.
 
7
 */
 
8
 
 
9
/**
 
10
 * @file
 
11
 * @brief Job definitions
 
12
 */
 
13
 
 
14
#include "common.h"
 
15
 
 
16
/*
 
17
 * Private declarations
 
18
 */
 
19
 
 
20
/**
 
21
 * @addtogroup gearman_job_private Private Job Functions
 
22
 * @ingroup gearman_job
 
23
 * @{
 
24
 */
 
25
 
 
26
/**
 
27
 * Send a packet for a job.
 
28
 */
 
29
static gearman_return_t _job_send(gearman_job_st *job);
 
30
 
 
31
/** @} */
 
32
 
 
33
/*
 
34
 * Public definitions
 
35
 */
 
36
 
 
37
gearman_job_st *gearman_job_create(gearman_st *gearman, gearman_job_st *job)
 
38
{
 
39
  if (job == NULL)
 
40
  {
 
41
    job= malloc(sizeof(gearman_job_st));
 
42
    if (job == NULL)
 
43
    {
 
44
      GEARMAN_ERROR_SET(gearman, "gearman_job_create", "malloc")
 
45
      return NULL;
 
46
    }
 
47
 
 
48
    job->options= GEARMAN_JOB_ALLOCATED;
 
49
  }
 
50
  else
 
51
    job->options= 0;
 
52
 
 
53
  job->gearman= gearman;
 
54
  GEARMAN_LIST_ADD(gearman->job, job,)
 
55
  job->con= NULL;
 
56
 
 
57
  return job;
 
58
}
 
59
 
 
60
void gearman_job_free(gearman_job_st *job)
 
61
{
 
62
  if (job->options & GEARMAN_JOB_ASSIGNED_IN_USE)
 
63
    gearman_packet_free(&(job->assigned));
 
64
 
 
65
  if (job->options & GEARMAN_JOB_WORK_IN_USE)
 
66
    gearman_packet_free(&(job->work));
 
67
 
 
68
  GEARMAN_LIST_DEL(job->gearman->job, job,)
 
69
 
 
70
  if (job->options & GEARMAN_JOB_ALLOCATED)
 
71
    free(job);
 
72
}
 
73
 
 
74
gearman_return_t gearman_job_data(gearman_job_st *job, void *data,
 
75
                                  size_t data_size)
 
76
{
 
77
  gearman_return_t ret;
 
78
 
 
79
  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
 
80
  {
 
81
    ret= gearman_packet_add(job->gearman, &(job->work), GEARMAN_MAGIC_REQUEST,
 
82
                            GEARMAN_COMMAND_WORK_DATA, job->assigned.arg[0],
 
83
                            job->assigned.arg_size[0], data, data_size, NULL);
 
84
    if (ret != GEARMAN_SUCCESS)
 
85
      return ret;
 
86
 
 
87
    job->options|= GEARMAN_JOB_WORK_IN_USE;
 
88
  }
 
89
 
 
90
  return _job_send(job);
 
91
}
 
92
 
 
93
gearman_return_t gearman_job_warning(gearman_job_st *job, void *warning,
 
94
                                     size_t warning_size)
 
95
{
 
96
  gearman_return_t ret;
 
97
 
 
98
  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
 
99
  {
 
100
    ret= gearman_packet_add(job->gearman, &(job->work), GEARMAN_MAGIC_REQUEST,
 
101
                            GEARMAN_COMMAND_WORK_WARNING, job->assigned.arg[0],
 
102
                            job->assigned.arg_size[0], warning, warning_size,
 
103
                            NULL);
 
104
    if (ret != GEARMAN_SUCCESS)
 
105
      return ret;
 
106
 
 
107
    job->options|= GEARMAN_JOB_WORK_IN_USE;
 
108
  }
 
109
 
 
110
  return _job_send(job);
 
111
}
 
112
 
 
113
gearman_return_t gearman_job_status(gearman_job_st *job, uint32_t numerator,
 
114
                                    uint32_t denominator)
 
115
{
 
116
  gearman_return_t ret;
 
117
  char numerator_string[12];
 
118
  char denominator_string[12];
 
119
 
 
120
  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
 
121
  {
 
122
    snprintf(numerator_string, 12, "%u", numerator);
 
123
    snprintf(denominator_string, 12, "%u", denominator);
 
124
 
 
125
    ret= gearman_packet_add(job->gearman, &(job->work), GEARMAN_MAGIC_REQUEST,
 
126
                            GEARMAN_COMMAND_WORK_STATUS, job->assigned.arg[0],
 
127
                            job->assigned.arg_size[0], numerator_string,
 
128
                            strlen(numerator_string) + 1, denominator_string,
 
129
                            strlen(denominator_string), NULL);
 
130
    if (ret != GEARMAN_SUCCESS)
 
131
      return ret;
 
132
 
 
133
    job->options|= GEARMAN_JOB_WORK_IN_USE;
 
134
  }
 
135
 
 
136
  return _job_send(job);
 
137
}
 
138
 
 
139
gearman_return_t gearman_job_complete(gearman_job_st *job, void *result,
 
140
                                      size_t result_size)
 
141
{
 
142
  gearman_return_t ret;
 
143
 
 
144
  if (job->options & GEARMAN_JOB_FINISHED)
 
145
    return GEARMAN_SUCCESS;
 
146
 
 
147
  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
 
148
  {
 
149
    ret= gearman_packet_add(job->gearman, &(job->work),
 
150
                            GEARMAN_MAGIC_REQUEST,
 
151
                            GEARMAN_COMMAND_WORK_COMPLETE,
 
152
                            job->assigned.arg[0], job->assigned.arg_size[0],
 
153
                            result, result_size, NULL);
 
154
    if (ret != GEARMAN_SUCCESS)
 
155
      return ret;
 
156
 
 
157
    job->options|= GEARMAN_JOB_WORK_IN_USE;
 
158
  }
 
159
 
 
160
  ret= _job_send(job);
 
161
  if (ret != GEARMAN_SUCCESS)
 
162
    return ret;
 
163
 
 
164
  job->options|= GEARMAN_JOB_FINISHED;
 
165
  return GEARMAN_SUCCESS;
 
166
}
 
167
 
 
168
gearman_return_t gearman_job_exception(gearman_job_st *job, void *exception,
 
169
                                       size_t exception_size)
 
170
{
 
171
  gearman_return_t ret;
 
172
 
 
173
  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
 
174
  {
 
175
    ret= gearman_packet_add(job->gearman, &(job->work), GEARMAN_MAGIC_REQUEST,
 
176
                            GEARMAN_COMMAND_WORK_EXCEPTION,
 
177
                            job->assigned.arg[0], job->assigned.arg_size[0],
 
178
                            exception, exception_size, NULL);
 
179
    if (ret != GEARMAN_SUCCESS)
 
180
      return ret;
 
181
 
 
182
    job->options|= GEARMAN_JOB_WORK_IN_USE;
 
183
  }
 
184
 
 
185
  return _job_send(job);
 
186
}
 
187
 
 
188
gearman_return_t gearman_job_fail(gearman_job_st *job)
 
189
{
 
190
  gearman_return_t ret;
 
191
 
 
192
  if (job->options & GEARMAN_JOB_FINISHED)
 
193
    return GEARMAN_SUCCESS;
 
194
 
 
195
  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
 
196
  {
 
197
    ret= gearman_packet_add(job->gearman, &(job->work), GEARMAN_MAGIC_REQUEST,
 
198
                            GEARMAN_COMMAND_WORK_FAIL, job->assigned.arg[0],
 
199
                            job->assigned.arg_size[0] - 1, NULL);
 
200
    if (ret != GEARMAN_SUCCESS)
 
201
      return ret;
 
202
 
 
203
    job->options|= GEARMAN_JOB_WORK_IN_USE;
 
204
  }
 
205
 
 
206
  ret= _job_send(job);
 
207
  if (ret != GEARMAN_SUCCESS)
 
208
    return ret;
 
209
 
 
210
  job->options|= GEARMAN_JOB_FINISHED;
 
211
  return GEARMAN_SUCCESS;
 
212
}
 
213
 
 
214
char *gearman_job_handle(gearman_job_st *job)
 
215
{
 
216
  return (char *)job->assigned.arg[0];
 
217
}
 
218
 
 
219
char *gearman_job_function_name(gearman_job_st *job)
 
220
{
 
221
  return (char *)job->assigned.arg[1];
 
222
}
 
223
 
 
224
const char *gearman_job_unique(gearman_job_st *job)
 
225
{
 
226
  if (job->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN_UNIQ)
 
227
    return (const char *)job->assigned.arg[2];
 
228
  return "";
 
229
}
 
230
 
 
231
const void *gearman_job_workload(gearman_job_st *job)
 
232
{
 
233
  return job->assigned.data;
 
234
}
 
235
 
 
236
size_t gearman_job_workload_size(gearman_job_st *job)
 
237
{
 
238
  return job->assigned.data_size;
 
239
}
 
240
 
 
241
/*
 
242
 * Private definitions
 
243
 */
 
244
 
 
245
static gearman_return_t _job_send(gearman_job_st *job)
 
246
{
 
247
  gearman_return_t ret;
 
248
 
 
249
  ret= gearman_con_send(job->con, &(job->work), true);
 
250
  if (ret != GEARMAN_SUCCESS)
 
251
    return ret;
 
252
 
 
253
  gearman_packet_free(&(job->work));
 
254
  job->options&= (gearman_job_options_t)~GEARMAN_JOB_WORK_IN_USE;
 
255
 
 
256
  return GEARMAN_SUCCESS;
 
257
}