← 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: Brian Aker
  • Date: 2010-05-27 01:25:56 UTC
  • mfrom: (1567.1.4 new-staging)
  • Revision ID: brian@gaz-20100527012556-5zgkirkl7swbigd6
Merge of Brian, Paul. PBXT compile issue, and test framework cleanup. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/memcached_stats/stats_table.cc
 
1
/*
 
2
 * Copyright (c) 2009, Padraig O'Sullivan
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions are met:
 
7
 *
 
8
 *   * Redistributions of source code must retain the above copyright notice,
 
9
 *     this list of conditions and the following disclaimer.
 
10
 *   * Redistributions in binary form must reproduce the above copyright notice,
 
11
 *     this list of conditions and the following disclaimer in the documentation
 
12
 *     and/or other materials provided with the distribution.
 
13
 *   * Neither the name of Padraig O'Sullivan nor the names of its contributors
 
14
 *     may be used to endorse or promote products derived from this software
 
15
 *     without specific prior written permission.
 
16
 *
 
17
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 
18
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
20
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 
21
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 
22
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 
23
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 
24
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 
25
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
26
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 
27
 * THE POSSIBILITY OF SUCH DAMAGE.
 
28
 */
 
29
 
 
30
#include "config.h"
 
31
 
 
32
#include "stats_table.h"
 
33
#include "sysvar_holder.h"
 
34
 
 
35
#include "drizzled/error.h"
 
36
#include <libmemcached/server.h>
 
37
 
 
38
using namespace std;
 
39
using namespace drizzled;
 
40
 
 
41
#if !defined(HAVE_MEMCACHED_SERVER_FN)
 
42
typedef memcached_server_function memcached_server_fn;
 
43
#endif
 
44
 
 
45
extern "C"
 
46
memcached_return  server_function(const memcached_st *ptr,
 
47
                                  memcached_server_st *server,
 
48
                                  void *context);
 
49
 
 
50
 
 
51
struct server_function_context
 
52
{
 
53
  StatsTableTool::Generator* generator; 
 
54
  server_function_context(StatsTableTool::Generator *generator_arg)
 
55
    : generator(generator_arg)
 
56
  {}
 
57
};
 
58
 
 
59
 
 
60
extern "C"
 
61
memcached_return  server_function(const memcached_st *memc,
 
62
                                  memcached_server_st *server,
 
63
                                  void *context)
 
64
{
 
65
  server_function_context *ctx= static_cast<server_function_context *>(context);
 
66
 
 
67
  const char *server_name= memcached_server_name(*memc, *server);
 
68
  in_port_t server_port= memcached_server_port(*memc, *server);
 
69
 
 
70
  memcached_stat_st stats;
 
71
  memcached_return ret= memcached_stat_servername(&stats, NULL,
 
72
                                                  server_name, server_port);
 
73
 
 
74
  if (ret != MEMCACHED_SUCCESS)
 
75
  {
 
76
    my_printf_error(ER_UNKNOWN_ERROR, _("Unable get stats from memcached server %s.  Got error from memcached_stat_servername()."), MYF(0), server_name);
 
77
    return ret;
 
78
  }
 
79
 
 
80
  char **list= memcached_stat_get_keys((memcached_st *)memc, &stats, &ret);
 
81
  char **ptr= NULL;
 
82
 
 
83
  ctx->generator->push(server_name);
 
84
  ctx->generator->push(static_cast<uint64_t>(server_port));
 
85
 
 
86
  for (ptr= list; *ptr; ptr++)
 
87
  {
 
88
    char *value= memcached_stat_get_value((memcached_st *)memc, &stats, *ptr, &ret);
 
89
    ctx->generator->push(value);
 
90
    free(value);
 
91
  }
 
92
  free(list);
 
93
 
 
94
  return MEMCACHED_SUCCESS;
 
95
}
 
96
 
 
97
 
 
98
StatsTableTool::StatsTableTool() :
 
99
  plugin::TableFunction("DATA_DICTIONARY", "MEMCACHED_STATS")
 
100
{
 
101
  add_field("NAME");
 
102
  add_field("PORT_NUMBER", plugin::TableFunction::NUMBER);
 
103
  add_field("PROCESS_ID", plugin::TableFunction::NUMBER);
 
104
  add_field("UPTIME", plugin::TableFunction::NUMBER);
 
105
  add_field("TIME", plugin::TableFunction::NUMBER);
 
106
  add_field("VERSION");
 
107
  add_field("POINTER_SIZE", plugin::TableFunction::NUMBER);
 
108
  add_field("RUSAGE_USER", plugin::TableFunction::NUMBER);
 
109
  add_field("RUSAGE_SYSTEM", plugin::TableFunction::NUMBER);
 
110
  add_field("CURRENT_ITEMS", plugin::TableFunction::NUMBER);
 
111
  add_field("TOTAL_ITEMS", plugin::TableFunction::NUMBER);
 
112
  add_field("BYTES",  plugin::TableFunction::NUMBER);
 
113
  add_field("CURRENT_CONNECTIONS", plugin::TableFunction::NUMBER);
 
114
  add_field("TOTAL_CONNECTIONS", plugin::TableFunction::NUMBER);
 
115
  add_field("CONNECTION_STRUCTURES", plugin::TableFunction::NUMBER);
 
116
  add_field("GETS", plugin::TableFunction::NUMBER);
 
117
  add_field("SETS", plugin::TableFunction::NUMBER);
 
118
  add_field("HITS", plugin::TableFunction::NUMBER);
 
119
  add_field("MISSES", plugin::TableFunction::NUMBER); 
 
120
  add_field("EVICTIONS", plugin::TableFunction::NUMBER);
 
121
  add_field("BYTES_READ", plugin::TableFunction::NUMBER);
 
122
  add_field("BYTES_WRITTEN", plugin::TableFunction::NUMBER);
 
123
  add_field("LIMIT_MAXBYTES", plugin::TableFunction::NUMBER);
 
124
  add_field("THREADS", plugin::TableFunction::NUMBER);
 
125
}
 
126
 
 
127
 
 
128
StatsTableTool::Generator::Generator(Field **arg) :
 
129
  plugin::TableFunction::Generator(arg)
 
130
{
 
131
  /* This will be set to the real number if we initialize properly below */
 
132
  number_of_hosts= 0;
 
133
  
 
134
  host_number= 0;
 
135
 
 
136
  /* set to NULL if we are not able to init we dont want to call delete on this */
 
137
  memc= NULL;
 
138
 
 
139
  SysvarHolder &sysvar_holder= SysvarHolder::singleton();
 
140
  const string servers_string= sysvar_holder.getServersString();
 
141
 
 
142
  if (servers_string.empty())
 
143
  {
 
144
    my_printf_error(ER_UNKNOWN_ERROR, _("No value in MEMCACHED_STATS_SERVERS variable."), MYF(0));
 
145
    return; 
 
146
  }
 
147
 
 
148
  memc= memcached_create(NULL);
 
149
  if (memc == NULL)
 
150
  {
 
151
    my_printf_error(ER_UNKNOWN_ERROR, _("Unable to create memcached struct.  Got error from memcached_create()."), MYF(0));
 
152
    return;
 
153
  }
 
154
 
 
155
  memcached_server_st *tmp_serv=
 
156
    memcached_servers_parse(servers_string.c_str());
 
157
  if (tmp_serv == NULL)
 
158
  {
 
159
    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());
 
160
    return;
 
161
  }
 
162
 
 
163
  memcached_server_push(memc, tmp_serv);
 
164
  memcached_server_list_free(tmp_serv);
 
165
 
 
166
  number_of_hosts= memc->number_of_hosts;  
 
167
}
 
168
 
 
169
 
 
170
StatsTableTool::Generator::~Generator()
 
171
{
 
172
  if (memc != NULL)
 
173
  {
 
174
    memcached_free(memc);
 
175
  }
 
176
}
 
177
 
 
178
 
 
179
bool StatsTableTool::Generator::populate()
 
180
{
 
181
  if (host_number == number_of_hosts)
 
182
  {
 
183
    return false;
 
184
  }
 
185
 
 
186
  server_function_context context(this);
 
187
 
 
188
  memcached_server_function callbacks[1];
 
189
  callbacks[0]= server_function;
 
190
 
 
191
  unsigned int iferror; 
 
192
  iferror= (*callbacks[0])(memc, &memc->servers[host_number], (void *)&context); 
 
193
 
 
194
  if (iferror)
 
195
  {
 
196
    return false;
 
197
  }
 
198
 
 
199
  host_number++;
 
200
 
 
201
  return true;
 
202
}