← Back to branch summary

~yshurik/libmemcached/libmemcached-win

« back to all changes in this revision

Viewing changes to libmemcached/instance.cc

  • Committer: Continuous Integration
  • Date: 2013-04-03 13:16:24 UTC
  • mfrom: (1100.1.1 libmemcached-1.2)
  • Revision ID: ci@tangent.org-20130403131624-j59dhv5z5l0lsdld
Merge lp:~tangent-org/libmemcached/1.2-build/ Build: jenkins-Libmemcached-250

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmemcached/instance.cc
37
37
 
38
38
#include <libmemcached/common.h>
39
39
 
40
 
static inline void _server_init(org::libmemcached::Instance* self, Memcached *root,
 
40
static inline void _server_init(memcached_instance_st* self, Memcached *root,
41
41
                                const memcached_string_t& hostname,
42
42
                                in_port_t port,
43
43
                                uint32_t weight, memcached_connection_t type)
87
87
  self->hostname(hostname);
88
88
}
89
89
 
90
 
static org::libmemcached::Instance* _server_create(org::libmemcached::Instance* self, const memcached_st *memc)
 
90
static memcached_instance_st* _server_create(memcached_instance_st* self, const memcached_st *memc)
91
91
{
92
92
  if (self == NULL)
93
93
  {
94
 
   self= libmemcached_xmalloc(memc, org::libmemcached::Instance);
 
94
   self= libmemcached_xmalloc(memc, memcached_instance_st);
95
95
 
96
96
    if (self == NULL)
97
97
    {
110
110
  return self;
111
111
}
112
112
 
113
 
void org::libmemcached::Instance::events(short arg)
 
113
void memcached_instance_st::events(short arg)
114
114
{
115
115
  if ((_events | arg) == _events)
116
116
  {
120
120
  _events|= arg;
121
121
}
122
122
 
123
 
void org::libmemcached::Instance::revents(short arg)
 
123
void memcached_instance_st::revents(short arg)
124
124
{
125
125
  if (arg)
126
126
  {
131
131
  _events&= short(~arg);
132
132
}
133
133
 
134
 
org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
135
 
                                                    org::libmemcached::Instance* self,
 
134
memcached_instance_st* __instance_create_with(memcached_st *memc,
 
135
                                                    memcached_instance_st* self,
136
136
                                                    const memcached_string_t& hostname,
137
137
                                                    const in_port_t port,
138
138
                                                    uint32_t weight, 
162
162
  return self;
163
163
}
164
164
 
165
 
void __instance_free(org::libmemcached::Instance* self)
 
165
void __instance_free(memcached_instance_st* self)
166
166
{
167
167
  memcached_quit_server(self, false);
168
168
 
181
181
  }
182
182
}
183
183
 
184
 
void memcached_instance_free(org::libmemcached::Instance* self)
 
184
void memcached_instance_free(memcached_instance_st* self)
185
185
{
186
186
  if (self)
187
187
  {
204
204
  size_t errors= 0;
205
205
  for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++)
206
206
  {
207
 
    org::libmemcached::Instance* instance= memcached_instance_by_position(memc, x);
 
207
    memcached_instance_st* instance= memcached_instance_by_position(memc, x);
208
208
 
209
209
    for (uint32_t y= 0; y < number_of_callbacks; y++)
210
210
    {
233
233
  bool some_errors= false;;
234
234
  for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++)
235
235
  {
236
 
    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
 
236
    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
237
237
 
238
238
    memcached_return_t rc= (*callback)(memc, instance, context);
239
239
    if (rc == MEMCACHED_INVALID_ARGUMENTS)
250
250
  return MEMCACHED_SUCCESS;
251
251
}
252
252
 
253
 
memcached_server_instance_st memcached_server_by_key(memcached_st *shell,
 
253
const memcached_instance_st * memcached_server_by_key(memcached_st *shell,
254
254
                                                     const char *key,
255
255
                                                     size_t key_length,
256
256
                                                     memcached_return_t *error)
283
283
/*
284
284
  If we do not have a valid object to clone from, we toss an error.
285
285
*/
286
 
static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached::Instance* source)
 
286
static memcached_instance_st* memcached_instance_clone(memcached_instance_st* source)
287
287
{
288
288
  /* We just do a normal create if source is missing */
289
289
  if (source == NULL)
299
299
                                source->type);
300
300
}
301
301
 
302
 
void set_last_disconnected_host(org::libmemcached::Instance* self)
 
302
void set_last_disconnected_host(memcached_instance_st* self)
303
303
{
304
304
  assert(self->root);
305
305
  if (self->root)
313
313
    // const_cast
314
314
    memcached_st *root= (memcached_st *)self->root;
315
315
 
316
 
    memcached_instance_free((org::libmemcached::Instance*)(root->last_disconnected_server));
 
316
    memcached_instance_free((memcached_instance_st*)(root->last_disconnected_server));
317
317
 
318
318
    // We set is_parsing so that no lookup happens
319
319
    root->state.is_parsing= true;
320
320
    root->last_disconnected_server= memcached_instance_clone(self);
321
321
    root->state.is_parsing= false;
322
322
 
323
 
    ((org::libmemcached::Instance*)memcached_server_get_last_disconnect(root))->version= self->version;
 
323
    ((memcached_instance_st*)memcached_server_get_last_disconnect(root))->version= self->version;
324
324
  }
325
325
}
326
326
 
327
 
memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *shell)
 
327
const memcached_instance_st * memcached_server_get_last_disconnect(const memcached_st *shell)
328
328
{
329
329
  const Memcached* self= memcached2Memcached(shell);
330
330
  if (self)
331
331
  {
332
 
    return (memcached_server_instance_st)self->last_disconnected_server;
 
332
    return (const memcached_instance_st *)self->last_disconnected_server;
333
333
  }
334
334
 
335
335
  return 0;
336
336
}
337
337
 
338
 
void memcached_instance_next_retry(memcached_server_instance_st self, const time_t absolute_time)
 
338
void memcached_instance_next_retry(const memcached_instance_st * self, const time_t absolute_time)
339
339
{
340
340
  WATCHPOINT_ASSERT(self);
341
341
  if (self)
342
342
  {
343
 
    ((org::libmemcached::Instance*)self)->next_retry= absolute_time;
344
 
  }
345
 
}
346
 
 
347
 
namespace org {
348
 
namespace libmemcached {
349
 
 
350
 
  bool Instance::valid() const
351
 
  {
352
 
    if (fd == INVALID_SOCKET)
353
 
    {
354
 
      return false;
355
 
    }
356
 
 
357
 
    return true;
358
 
  }
359
 
 
360
 
  bool Instance::is_shutting_down() const
361
 
  {
362
 
    return options.is_shutting_down;
363
 
  }
364
 
 
365
 
} // namespace libmemcached
366
 
} // namespace org
 
343
    ((memcached_instance_st*)self)->next_retry= absolute_time;
 
344
  }
 
345
}
 
346
 
 
347
bool memcached_instance_st::valid() const
 
348
{
 
349
  if (fd == INVALID_SOCKET)
 
350
  {
 
351
    return false;
 
352
  }
 
353
 
 
354
  return true;
 
355
}
 
356
 
 
357
bool memcached_instance_st::is_shutting_down() const
 
358
{
 
359
  return options.is_shutting_down;
 
360
}