← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libgearman/gearman.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/gearman.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 Gearman core definitions
 
12
 */
 
13
 
 
14
#include "common.h"
 
15
 
 
16
/*
 
17
 * Private declarations
 
18
 */
 
19
 
 
20
/**
 
21
 * @addtogroup gearman_private Private Functions
 
22
 * @ingroup gearman
 
23
 * @{
 
24
 */
 
25
 
 
26
/**
 
27
 * Names of the verbose levels provided.
 
28
 */
 
29
static const char *_verbose_name[GEARMAN_VERBOSE_MAX]=
 
30
{
 
31
  "FATAL",
 
32
  "ERROR",
 
33
  "INFO",
 
34
  "DEBUG",
 
35
  "CRAZY"
 
36
};
 
37
 
 
38
/** @} */
 
39
 
 
40
/*
 
41
 * Public definitions
 
42
 */
 
43
 
 
44
const char *gearman_version(void)
 
45
{
 
46
    return PACKAGE_VERSION;
 
47
}
 
48
 
 
49
const char *gearman_bugreport(void)
 
50
{
 
51
    return PACKAGE_BUGREPORT;
 
52
}
 
53
 
 
54
const char *gearman_verbose_name(gearman_verbose_t verbose)
 
55
{
 
56
  if (verbose >= GEARMAN_VERBOSE_MAX)
 
57
    return "UNKNOWN";
 
58
 
 
59
  return _verbose_name[verbose];
 
60
}
 
61
 
 
62
gearman_st *gearman_create(gearman_st *gearman)
 
63
{
 
64
  if (gearman == NULL)
 
65
  {
 
66
    gearman= malloc(sizeof(gearman_st));
 
67
    if (gearman == NULL)
 
68
      return NULL;
 
69
 
 
70
    gearman->options= GEARMAN_ALLOCATED;
 
71
  }
 
72
  else
 
73
    gearman->options= 0;
 
74
 
 
75
  gearman->verbose= 0;
 
76
  gearman->con_count= 0;
 
77
  gearman->job_count= 0;
 
78
  gearman->task_count= 0;
 
79
  gearman->packet_count= 0;
 
80
  gearman->pfds_size= 0;
 
81
  gearman->sending= 0;
 
82
  gearman->last_errno= 0;
 
83
  gearman->con_list= NULL;
 
84
  gearman->job_list= NULL;
 
85
  gearman->task_list= NULL;
 
86
  gearman->packet_list= NULL;
 
87
  gearman->pfds= NULL;
 
88
  gearman->log_fn= NULL;
 
89
  gearman->log_fn_arg= NULL;
 
90
  gearman->event_watch= NULL;
 
91
  gearman->event_watch_arg= NULL;
 
92
  gearman->workload_malloc= NULL;
 
93
  gearman->workload_malloc_arg= NULL;
 
94
  gearman->workload_free= NULL;
 
95
  gearman->workload_free_arg= NULL;
 
96
  gearman->task_fn_arg_free_fn= NULL;
 
97
  gearman->queue_fn_arg= NULL;
 
98
  gearman->queue_add_fn= NULL;
 
99
  gearman->queue_flush_fn= NULL;
 
100
  gearman->queue_done_fn= NULL;
 
101
  gearman->queue_replay_fn= NULL;
 
102
  gearman->last_error[0]= 0;
 
103
 
 
104
  return gearman;
 
105
}
 
106
 
 
107
gearman_st *gearman_clone(gearman_st *gearman, gearman_st *from)
 
108
{
 
109
  gearman_con_st *con;
 
110
 
 
111
  gearman= gearman_create(gearman);
 
112
  if (gearman == NULL)
 
113
    return NULL;
 
114
 
 
115
  gearman->options|= (from->options & (gearman_options_t)~GEARMAN_ALLOCATED);
 
116
 
 
117
  for (con= from->con_list; con != NULL; con= con->next)
 
118
  {
 
119
    if (gearman_con_clone(gearman, NULL, con) == NULL)
 
120
    {
 
121
      gearman_free(gearman);
 
122
      return NULL;
 
123
    }
 
124
  }
 
125
 
 
126
  /* Don't clone job or packet information, this is state information for
 
127
     old and active jobs/connections. */
 
128
 
 
129
  return gearman;
 
130
}
 
131
 
 
132
void gearman_free(gearman_st *gearman)
 
133
{
 
134
  gearman_con_st *con;
 
135
  gearman_job_st *job;
 
136
  gearman_task_st *task;
 
137
  gearman_packet_st *packet;
 
138
 
 
139
  for (con= gearman->con_list; con != NULL; con= gearman->con_list)
 
140
    gearman_con_free(con);
 
141
 
 
142
  for (job= gearman->job_list; job != NULL; job= gearman->job_list)
 
143
    gearman_job_free(job);
 
144
 
 
145
  for (task= gearman->task_list; task != NULL; task= gearman->task_list)
 
146
    gearman_task_free(task);
 
147
 
 
148
  for (packet= gearman->packet_list; packet != NULL;
 
149
       packet= gearman->packet_list)
 
150
  {
 
151
    gearman_packet_free(packet);
 
152
  }
 
153
 
 
154
  if (gearman->pfds != NULL)
 
155
    free(gearman->pfds);
 
156
 
 
157
  if (gearman->options & GEARMAN_ALLOCATED)
 
158
    free(gearman);
 
159
}
 
160
 
 
161
const char *gearman_error(gearman_st *gearman)
 
162
{
 
163
  return (const char *)(gearman->last_error);
 
164
}
 
165
 
 
166
int gearman_errno(gearman_st *gearman)
 
167
{
 
168
  return gearman->last_errno;
 
169
}
 
170
 
 
171
void gearman_set_options(gearman_st *gearman, gearman_options_t options,
 
172
                         uint32_t data)
 
173
{
 
174
  if (data)
 
175
    gearman->options |= options;
 
176
  else
 
177
    gearman->options &= ~options;
 
178
}
 
179
 
 
180
void gearman_set_log(gearman_st *gearman, gearman_log_fn log_fn,
 
181
                     void *log_fn_arg, gearman_verbose_t verbose)
 
182
{
 
183
  gearman->log_fn= log_fn;
 
184
  gearman->log_fn_arg= log_fn_arg;
 
185
  gearman->verbose= verbose;
 
186
}
 
187
 
 
188
void gearman_set_event_watch(gearman_st *gearman,
 
189
                             gearman_event_watch_fn *event_watch,
 
190
                             void *event_watch_arg)
 
191
{
 
192
  gearman->event_watch= event_watch;
 
193
  gearman->event_watch_arg= event_watch_arg;
 
194
}
 
195
 
 
196
void gearman_set_workload_malloc(gearman_st *gearman,
 
197
                                 gearman_malloc_fn *workload_malloc,
 
198
                                 const void *workload_malloc_arg)
 
199
{
 
200
  gearman->workload_malloc= workload_malloc;
 
201
  gearman->workload_malloc_arg= workload_malloc_arg;
 
202
}
 
203
 
 
204
void gearman_set_workload_free(gearman_st *gearman,
 
205
                               gearman_free_fn *workload_free,
 
206
                               const void *workload_free_arg)
 
207
{
 
208
  gearman->workload_free= workload_free;
 
209
  gearman->workload_free_arg= workload_free_arg;
 
210
}
 
211
 
 
212
void gearman_set_task_fn_arg_free(gearman_st *gearman, 
 
213
                                  gearman_task_fn_arg_free_fn *free_fn)
 
214
{
 
215
  gearman->task_fn_arg_free_fn= free_fn;
 
216
}
 
217
 
 
218
void *gearman_queue_fn_arg(gearman_st *gearman)
 
219
{
 
220
  return (void *)gearman->queue_fn_arg;
 
221
}
 
222
 
 
223
void gearman_set_queue_fn_arg(gearman_st *gearman, const void *fn_arg)
 
224
{
 
225
  gearman->queue_fn_arg= fn_arg;
 
226
}
 
227
 
 
228
void gearman_set_queue_add(gearman_st *gearman, gearman_queue_add_fn *add_fn)
 
229
{
 
230
  gearman->queue_add_fn= add_fn;
 
231
}
 
232
 
 
233
void gearman_set_queue_flush(gearman_st *gearman,
 
234
                             gearman_queue_flush_fn *flush_fn)
 
235
{
 
236
  gearman->queue_flush_fn= flush_fn;
 
237
}
 
238
 
 
239
void gearman_set_queue_done(gearman_st *gearman,
 
240
                            gearman_queue_done_fn *done_fn)
 
241
{
 
242
  gearman->queue_done_fn= done_fn;
 
243
}
 
244
 
 
245
void gearman_set_queue_replay(gearman_st *gearman,
 
246
                              gearman_queue_replay_fn *replay_fn)
 
247
{
 
248
  gearman->queue_replay_fn= replay_fn;
 
249
}
 
250
 
 
251
gearman_return_t gearman_parse_servers(const char *servers, void *data,
 
252
                                       gearman_parse_server_fn *server_fn)
 
253
{ 
 
254
  const char *ptr= servers;
 
255
  size_t x;
 
256
  char host[NI_MAXHOST];
 
257
  char port[NI_MAXSERV];
 
258
  gearman_return_t ret;
 
259
 
 
260
  if (ptr == NULL)
 
261
    return (*server_fn)(NULL, 0, data);
 
262
 
 
263
  while (1)
 
264
  { 
 
265
    x= 0;
 
266
 
 
267
    while (*ptr != 0 && *ptr != ',' && *ptr != ':')
 
268
    { 
 
269
      if (x < (NI_MAXHOST - 1))
 
270
        host[x++]= *ptr;
 
271
 
 
272
      ptr++;
 
273
    }
 
274
 
 
275
    host[x]= 0;
 
276
 
 
277
    if (*ptr == ':')
 
278
    { 
 
279
      ptr++;
 
280
      x= 0;
 
281
 
 
282
      while (*ptr != 0 && *ptr != ',')
 
283
      { 
 
284
        if (x < (NI_MAXSERV - 1))
 
285
          port[x++]= *ptr;
 
286
 
 
287
        ptr++;
 
288
      }
 
289
 
 
290
      port[x]= 0;
 
291
    }
 
292
    else
 
293
      port[0]= 0;
 
294
 
 
295
    ret= (*server_fn)(host, (in_port_t)atoi(port), data);
 
296
    if (ret != GEARMAN_SUCCESS)
 
297
      return ret;
 
298
 
 
299
    if (*ptr == 0)
 
300
      break;
 
301
 
 
302
    ptr++;
 
303
  }
 
304
 
 
305
  return GEARMAN_SUCCESS;
 
306
}