← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/memcached_stats/stats_table.cc

  • Committer: Stewart Smith
  • Date: 2010-02-15 01:56:32 UTC
  • mto: (1273.13.96 build)
  • mto: This revision was merged to the branch mainline in revision 1308.
  • Revision ID: stewart@flamingspork.com-20100215015632-pm7lnxfq5j5uh8kj
move DATABASE() to function plugin. modify parser so that it looks for a function named 'database' when DATABASE() is called. Special case still needed in parser due to hilarity of not-really-reserved words.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/memcached_stats/stats_table.cc
1
 
/*
 
1
/* 
2
2
 * Copyright (c) 2009, Padraig O'Sullivan
3
3
 * All rights reserved.
4
4
 *
28
28
 */
29
29
 
30
30
#include "config.h"
 
31
#include "drizzled/session.h"
 
32
#include "drizzled/show.h"
 
33
#include "drizzled/error.h"
31
34
 
32
35
#include "stats_table.h"
33
36
#include "sysvar_holder.h"
34
37
 
35
 
#include "drizzled/error.h"
 
38
#include <libmemcached/memcached.h>
 
39
 
 
40
#include <string>
 
41
#include <vector>
36
42
 
37
43
using namespace std;
38
44
using namespace drizzled;
46
52
                                  memcached_server_st *server,
47
53
                                  void *context);
48
54
 
49
 
 
50
55
struct server_function_context
51
56
{
52
 
  StatsTableTool::Generator* generator; 
53
 
  server_function_context(StatsTableTool::Generator *generator_arg)
54
 
    : generator(generator_arg)
 
57
  Table* table;
 
58
  plugin::InfoSchemaTable *schema_table;
 
59
  server_function_context(Table *table_arg,
 
60
                          plugin::InfoSchemaTable *schema_table_arg)
 
61
    : table(table_arg), schema_table(schema_table_arg)
55
62
  {}
56
63
};
57
64
 
58
 
 
59
65
extern "C"
60
 
memcached_return  server_function(const memcached_st *memc,
 
66
memcached_return  server_function(const memcached_st *const_memc,
61
67
                                  memcached_server_st *server,
62
68
                                  void *context)
63
69
{
64
70
  server_function_context *ctx= static_cast<server_function_context *>(context);
65
 
 
 
71
  const CHARSET_INFO * const scs= system_charset_info;
 
72
  memcached_st memc_stack;
 
73
  memcached_st *memc;
 
74
 
 
75
  memc= memcached_clone(&memc_stack, const_memc);
 
76
 
 
77
  if (not memc)
 
78
  {
 
79
    my_printf_error(ER_UNKNOWN_ERROR, _("Unable to allocate memory for memcached_clone()."), MYF(0));
 
80
    return MEMCACHED_FAILURE;
 
81
  }
 
82
    
66
83
  char *server_name= memcached_server_name(memc, *server);
67
84
  in_port_t server_port= memcached_server_port(memc, *server);
68
85
 
69
86
  memcached_stat_st stats;
70
87
  memcached_return ret= memcached_stat_servername(&stats, NULL,
71
88
                                                  server_name, server_port);
72
 
 
73
89
  if (ret != MEMCACHED_SUCCESS)
74
90
  {
75
91
    my_printf_error(ER_UNKNOWN_ERROR, _("Unable get stats from memcached server %s.  Got error from memcached_stat_servername()."), MYF(0), server_name);
 
92
    memcached_free(memc);
76
93
    return ret;
77
94
  }
78
95
 
79
 
  char **list= memcached_stat_get_keys((memcached_st *)memc, &stats, &ret);
 
96
  char **list= memcached_stat_get_keys(memc, &stats, &ret);
80
97
  char **ptr= NULL;
81
 
 
82
 
  ctx->generator->push(server_name);
83
 
  ctx->generator->push(static_cast<uint64_t>(server_port));
84
 
 
 
98
 
 
99
  ctx->table->setWriteSet(0);
 
100
  ctx->table->setWriteSet(1);
 
101
 
 
102
  ctx->table->field[0]->store(server_name, strlen(server_name), scs);
 
103
  ctx->table->field[1]->store(server_port);
 
104
 
 
105
  uint32_t col= 2;
85
106
  for (ptr= list; *ptr; ptr++)
86
107
  {
87
 
    char *value= memcached_stat_get_value((memcached_st *)memc, &stats, *ptr, &ret);
88
 
    ctx->generator->push(value);
 
108
    char *value= memcached_stat_get_value(memc, &stats, *ptr, &ret);
 
109
 
 
110
    ctx->table->setWriteSet(col);
 
111
    ctx->table->field[col]->store(value,
 
112
                                  strlen(value),
 
113
                                  scs);
 
114
    col++;
89
115
    free(value);
90
116
  }
91
117
  free(list);
 
118
  /* store the actual record now */
 
119
  ctx->schema_table->addRow(ctx->table->record[0], ctx->table->s->reclength);
 
120
  memcached_free(memc);
92
121
 
93
122
  return MEMCACHED_SUCCESS;
94
123
}
95
124
 
96
 
 
97
 
StatsTableTool::StatsTableTool() :
98
 
  plugin::TableFunction("DATA_DICTIONARY", "MEMCACHED_STATS")
99
 
{
100
 
  add_field("NAME");
101
 
  add_field("PORT_NUMBER", plugin::TableFunction::NUMBER);
102
 
  add_field("PROCESS_ID", plugin::TableFunction::NUMBER);
103
 
  add_field("UPTIME", plugin::TableFunction::NUMBER);
104
 
  add_field("TIME", plugin::TableFunction::NUMBER);
105
 
  add_field("VERSION");
106
 
  add_field("POINTER_SIZE", plugin::TableFunction::NUMBER);
107
 
  add_field("RUSAGE_USER", plugin::TableFunction::NUMBER);
108
 
  add_field("RUSAGE_SYSTEM", plugin::TableFunction::NUMBER);
109
 
  add_field("CURRENT_ITEMS", plugin::TableFunction::NUMBER);
110
 
  add_field("TOTAL_ITEMS", plugin::TableFunction::NUMBER);
111
 
  add_field("BYTES",  plugin::TableFunction::NUMBER);
112
 
  add_field("CURRENT_CONNECTIONS", plugin::TableFunction::NUMBER);
113
 
  add_field("TOTAL_CONNECTIONS", plugin::TableFunction::NUMBER);
114
 
  add_field("CONNECTION_STRUCTURES", plugin::TableFunction::NUMBER);
115
 
  add_field("GETS", plugin::TableFunction::NUMBER);
116
 
  add_field("SETS", plugin::TableFunction::NUMBER);
117
 
  add_field("HITS", plugin::TableFunction::NUMBER);
118
 
  add_field("MISSES", plugin::TableFunction::NUMBER); 
119
 
  add_field("EVICTIONS", plugin::TableFunction::NUMBER);
120
 
  add_field("BYTES_READ", plugin::TableFunction::NUMBER);
121
 
  add_field("BYTES_WRITTEN", plugin::TableFunction::NUMBER);
122
 
  add_field("LIMIT_MAXBYTES", plugin::TableFunction::NUMBER);
123
 
  add_field("THREADS", plugin::TableFunction::NUMBER);
124
 
}
125
 
 
126
 
 
127
 
StatsTableTool::Generator::Generator(Field **arg) :
128
 
  plugin::TableFunction::Generator(arg)
129
 
{
130
 
  /* This will be set to the real number if we initialize properly below */
131
 
  number_of_hosts= 0;
132
 
  
133
 
  host_number= 0;
134
 
 
135
 
  /* set to NULL if we are not able to init we dont want to call delete on this */
136
 
  memc= NULL;
137
 
 
 
125
int MemcachedStatsISMethods::fillTable(Session *,
 
126
                                       Table *table,
 
127
                                       plugin::InfoSchemaTable *schema_table)
 
128
{
138
129
  SysvarHolder &sysvar_holder= SysvarHolder::singleton();
139
130
  const string servers_string= sysvar_holder.getServersString();
140
131
 
 
132
  table->restoreRecordAsDefault();
141
133
  if (servers_string.empty())
142
134
  {
143
135
    my_printf_error(ER_UNKNOWN_ERROR, _("No value in MEMCACHED_STATS_SERVERS variable."), MYF(0));
144
 
    return; 
145
 
  }
 
136
    return 1;
 
137
  } 
 
138
 
146
139
 
147
 
  memc= memcached_create(NULL);
 
140
  memcached_st *memc= memcached_create(NULL);
148
141
  if (memc == NULL)
149
142
  {
150
143
    my_printf_error(ER_UNKNOWN_ERROR, _("Unable to create memcached struct.  Got error from memcached_create()."), MYF(0));
151
 
    return;
 
144
    return 1;
152
145
  }
153
146
 
154
147
  memcached_server_st *tmp_serv=
156
149
  if (tmp_serv == NULL)
157
150
  {
158
151
    my_printf_error(ER_UNKNOWN_ERROR, _("Unable to create memcached server list.  Got error from memcached_servers_parse(%s)."), MYF(0), servers_string.c_str());
159
 
    return;
 
152
    memcached_free(memc);
 
153
    return 1; 
160
154
  }
161
155
 
162
156
  memcached_server_push(memc, tmp_serv);
163
157
  memcached_server_list_free(tmp_serv);
164
158
 
165
 
  number_of_hosts= memc->number_of_hosts;  
166
 
}
167
 
 
168
 
 
169
 
StatsTableTool::Generator::~Generator()
170
 
{
171
 
  if (memc != NULL)
172
 
  {
173
 
    memcached_free(memc);
174
 
  }
175
 
}
176
 
 
177
 
 
178
 
bool StatsTableTool::Generator::populate()
179
 
{
180
 
  if (host_number == number_of_hosts)
181
 
  {
182
 
    return false;
183
 
  }
184
 
 
185
 
  server_function_context context(this);
186
 
 
187
159
  memcached_server_fn callbacks[1];
 
160
 
188
161
  callbacks[0]= server_function;
189
 
 
190
 
  unsigned int iferror; 
191
 
  iferror= (*callbacks[0])(memc, &memc->servers[host_number], (void *)&context); 
192
 
 
193
 
  if (iferror)
194
 
  {
195
 
    return false;
196
 
  }
197
 
 
198
 
  host_number++;
199
 
 
200
 
  return true;
 
162
  server_function_context context(table, schema_table);
 
163
 
 
164
  memcached_server_cursor(memc, callbacks, &context, 1);
 
165
 
 
166
  memcached_free(memc);
 
167
 
 
168
  return 0;
 
169
}
 
170
 
 
171
bool createMemcachedStatsColumns(vector<const plugin::ColumnInfo *> &cols)
 
172
{
 
173
  /*
 
174
   * Create each column for the memcached stats table.
 
175
   */
 
176
  const plugin::ColumnInfo *name_col= new(std::nothrow) plugin::ColumnInfo("NAME",
 
177
                                                           32,
 
178
                                                           DRIZZLE_TYPE_VARCHAR,
 
179
                                                           0,
 
180
                                                           0,
 
181
                                                           "Name");
 
182
  if (! name_col)
 
183
  {
 
184
    return true;
 
185
  }
 
186
 
 
187
  const plugin::ColumnInfo *port= new(std::nothrow) plugin::ColumnInfo("PORT_NUMBER",
 
188
                                                       4,
 
189
                                                       DRIZZLE_TYPE_LONGLONG,
 
190
                                                       0,
 
191
                                                       0, 
 
192
                                                       "Port Number");
 
193
  if (! port)
 
194
  {
 
195
    return true;
 
196
  }
 
197
 
 
198
  const plugin::ColumnInfo *pid= new(std::nothrow) plugin::ColumnInfo("PROCESS_ID",
 
199
                                                      4,
 
200
                                                      DRIZZLE_TYPE_LONGLONG,
 
201
                                                      0,
 
202
                                                      0, 
 
203
                                                      "Process ID");
 
204
  if (! pid)
 
205
  {
 
206
    return true;
 
207
  }
 
208
 
 
209
  const plugin::ColumnInfo *uptime= new(std::nothrow) plugin::ColumnInfo("UPTIME",
 
210
                                                         4,
 
211
                                                         DRIZZLE_TYPE_LONGLONG,
 
212
                                                         0,
 
213
                                                         0, 
 
214
                                                         "Uptime");
 
215
  if (! uptime)
 
216
  {
 
217
    return true;
 
218
  }
 
219
 
 
220
  const plugin::ColumnInfo *time= new(std::nothrow) plugin::ColumnInfo("TIME",
 
221
                                                       4,
 
222
                                                       DRIZZLE_TYPE_LONGLONG,
 
223
                                                       0,
 
224
                                                       0, 
 
225
                                                       "Time");
 
226
  if (! time)
 
227
  {
 
228
    return true;
 
229
  }
 
230
 
 
231
  const plugin::ColumnInfo *version= new(std::nothrow) plugin::ColumnInfo("VERSION",
 
232
                                                          8,
 
233
                                                          DRIZZLE_TYPE_VARCHAR,
 
234
                                                          0,
 
235
                                                          0,
 
236
                                                          "Version");
 
237
  if (! version)
 
238
  {
 
239
    return true;
 
240
  }
 
241
 
 
242
  const plugin::ColumnInfo *ptr_size= new(std::nothrow) plugin::ColumnInfo("POINTER_SIZE",
 
243
                                                           4,
 
244
                                                           DRIZZLE_TYPE_LONGLONG,
 
245
                                                           0,
 
246
                                                           0, 
 
247
                                                           "Pointer Size");
 
248
  if (! ptr_size)
 
249
  {
 
250
    return true;
 
251
  }
 
252
 
 
253
  const plugin::ColumnInfo *r_user= new(std::nothrow) plugin::ColumnInfo("RUSAGE_USER",
 
254
                                                         4,
 
255
                                                         DRIZZLE_TYPE_LONGLONG,
 
256
                                                         0,
 
257
                                                         0, 
 
258
                                                         "rusage user");
 
259
  if (! r_user)
 
260
  {
 
261
    return true;
 
262
  }
 
263
 
 
264
  const plugin::ColumnInfo *r_sys= new(std::nothrow) plugin::ColumnInfo("RUSAGE_SYSTEM",
 
265
                                                        4,
 
266
                                                        DRIZZLE_TYPE_LONGLONG,
 
267
                                                        0,
 
268
                                                        0, 
 
269
                                                        "rusage system");
 
270
  if (! r_sys)
 
271
  {
 
272
    return true;
 
273
  }
 
274
  const plugin::ColumnInfo *curr_items= new(std::nothrow) plugin::ColumnInfo("CURRENT_ITEMS",
 
275
                                                             4,
 
276
                                                             DRIZZLE_TYPE_LONGLONG,
 
277
                                                             0,
 
278
                                                             0, 
 
279
                                                             "Current Items");
 
280
  if (! curr_items)
 
281
  {
 
282
    return true;
 
283
  }
 
284
 
 
285
  const plugin::ColumnInfo *total_items= new(std::nothrow) plugin::ColumnInfo("TOTAL_ITEMS",
 
286
                                                              4,
 
287
                                                              DRIZZLE_TYPE_LONGLONG,
 
288
                                                              0,
 
289
                                                              0,
 
290
                                                              "Total Items");
 
291
  if (! total_items)
 
292
  {
 
293
    return true;
 
294
  }
 
295
 
 
296
  const plugin::ColumnInfo *bytes= new(std::nothrow) plugin::ColumnInfo("BYTES",
 
297
                                                        4,
 
298
                                                        DRIZZLE_TYPE_LONGLONG,
 
299
                                                        0,
 
300
                                                        0,
 
301
                                                        "Bytes");
 
302
  if (! bytes)
 
303
  {
 
304
    return true;
 
305
  }
 
306
 
 
307
  const plugin::ColumnInfo *curr_cons= new(std::nothrow) plugin::ColumnInfo("CURRENT_CONNECTIONS",
 
308
                                                            4,
 
309
                                                            DRIZZLE_TYPE_LONGLONG,
 
310
                                                            0,
 
311
                                                            0,
 
312
                                                            "Current Connections");
 
313
  if (! curr_cons)
 
314
  {
 
315
    return true;
 
316
  }
 
317
 
 
318
  const plugin::ColumnInfo *total_cons= new(std::nothrow) plugin::ColumnInfo("TOTAL_CONNECTIONS",
 
319
                                                             4,
 
320
                                                             DRIZZLE_TYPE_LONGLONG,
 
321
                                                             0,
 
322
                                                             0,
 
323
                                                             "Total Connections");
 
324
  if (! total_cons)
 
325
  {
 
326
    return true;
 
327
  }
 
328
 
 
329
  const plugin::ColumnInfo *con_structs= new(std::nothrow) plugin::ColumnInfo("CONNECTION_STRUCTURES",
 
330
                                                              4,
 
331
                                                              DRIZZLE_TYPE_LONGLONG,
 
332
                                                              0,
 
333
                                                              0,
 
334
                                                              "Connection Structures");
 
335
  if (! con_structs)
 
336
  {
 
337
    return true;
 
338
  }
 
339
 
 
340
  const plugin::ColumnInfo *cmd_gets= new(std::nothrow) plugin::ColumnInfo("GETS",
 
341
                                                           4,
 
342
                                                           DRIZZLE_TYPE_LONGLONG,
 
343
                                                           0,
 
344
                                                           0,
 
345
                                                           "Gets");
 
346
  if (! cmd_gets)
 
347
  {
 
348
    return true;
 
349
  }
 
350
 
 
351
  const plugin::ColumnInfo *cmd_sets= new(std::nothrow) plugin::ColumnInfo("SETS",
 
352
                                                           4,
 
353
                                                           DRIZZLE_TYPE_LONGLONG,
 
354
                                                           0,
 
355
                                                           0,
 
356
                                                           "Sets");
 
357
  if (! cmd_sets)
 
358
  {
 
359
    return true;
 
360
  }
 
361
 
 
362
  const plugin::ColumnInfo *hits= new(std::nothrow) plugin::ColumnInfo("HITS",
 
363
                                                       4,
 
364
                                                       DRIZZLE_TYPE_LONGLONG,
 
365
                                                       0,
 
366
                                                       0,
 
367
                                                       "Hits");
 
368
  if (! hits)
 
369
  {
 
370
    return true;
 
371
  }
 
372
 
 
373
  const plugin::ColumnInfo *misses= new(std::nothrow) plugin::ColumnInfo("MISSES",
 
374
                                                         4,
 
375
                                                         DRIZZLE_TYPE_LONGLONG,
 
376
                                                         0,
 
377
                                                         0,
 
378
                                                         "Misses");
 
379
  if (! misses)
 
380
  {
 
381
    return true;
 
382
  }
 
383
 
 
384
  const plugin::ColumnInfo *evicts= new(std::nothrow) plugin::ColumnInfo("EVICTIONS",
 
385
                                                         4,
 
386
                                                         DRIZZLE_TYPE_LONGLONG,
 
387
                                                         0,
 
388
                                                         0,
 
389
                                                         "Evictions");
 
390
  if (! evicts)
 
391
  {
 
392
    return true;
 
393
  }
 
394
 
 
395
  const plugin::ColumnInfo *bytes_read= new(std::nothrow) plugin::ColumnInfo("BYTES_READ",
 
396
                                                             4,
 
397
                                                             DRIZZLE_TYPE_LONGLONG,
 
398
                                                             0,
 
399
                                                             0,
 
400
                                                             "bytes read");
 
401
  if (! bytes_read)
 
402
  {
 
403
    return true;
 
404
  }
 
405
 
 
406
  const plugin::ColumnInfo *bytes_written= new(std::nothrow) plugin::ColumnInfo("BYTES_WRITTEN",
 
407
                                                                4,
 
408
                                                                DRIZZLE_TYPE_LONGLONG,
 
409
                                                                0,
 
410
                                                                0,
 
411
                                                                "bytes written");
 
412
  if (! bytes_written)
 
413
  {
 
414
    return true;
 
415
  }
 
416
 
 
417
  const plugin::ColumnInfo *lim_max_bytes= new(std::nothrow) plugin::ColumnInfo("LIMIT_MAXBYTES",
 
418
                                                                4,
 
419
                                                                DRIZZLE_TYPE_LONGLONG,
 
420
                                                                0,
 
421
                                                                0,
 
422
                                                                "limit maxbytes");
 
423
  if (! lim_max_bytes)
 
424
  {
 
425
    return true;
 
426
  }
 
427
 
 
428
  const plugin::ColumnInfo *threads= new(std::nothrow) plugin::ColumnInfo("THREADS",
 
429
                                                          4,
 
430
                                                          DRIZZLE_TYPE_LONGLONG,
 
431
                                                          0,
 
432
                                                          0,
 
433
                                                          "Threads");
 
434
  if (! threads)
 
435
  {
 
436
    return true;
 
437
  }
 
438
 
 
439
  cols.push_back(name_col);
 
440
  cols.push_back(port);
 
441
  cols.push_back(pid);
 
442
  cols.push_back(uptime);
 
443
  cols.push_back(time);
 
444
  cols.push_back(version);
 
445
  cols.push_back(ptr_size);
 
446
  cols.push_back(r_user);
 
447
  cols.push_back(r_sys);
 
448
  cols.push_back(curr_items);
 
449
  cols.push_back(total_items);
 
450
  cols.push_back(bytes);
 
451
  cols.push_back(curr_cons);
 
452
  cols.push_back(total_cons);
 
453
  cols.push_back(con_structs);
 
454
  cols.push_back(cmd_gets);
 
455
  cols.push_back(cmd_sets);
 
456
  cols.push_back(hits);
 
457
  cols.push_back(misses);
 
458
  cols.push_back(evicts);
 
459
  cols.push_back(bytes_read);
 
460
  cols.push_back(bytes_written);
 
461
  cols.push_back(lim_max_bytes);
 
462
  cols.push_back(threads);
 
463
 
 
464
  return false;
 
465
}
 
466
 
 
467
class DeleteMemcachedCols
 
468
{
 
469
public:
 
470
  template<typename T>
 
471
  inline void operator()(const T *ptr) const
 
472
  {
 
473
    delete ptr;
 
474
  }
 
475
};
 
476
 
 
477
void clearMemcachedColumns(vector<const plugin::ColumnInfo *> &cols)
 
478
{
 
479
  for_each(cols.begin(), cols.end(), DeleteMemcachedCols());
 
480
  cols.clear();
201
481
}