← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/console/console.cc

Renamed namespace slot to namespace service.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/console/console.cc
1
 
/* Copyright (C) 2009 Sun Microsystems, Inc.
 
1
/* Copyright (C) 2009 Sun Microsystems
2
2
 
3
3
   This program is free software; you can redistribute it and/or modify
4
4
   it under the terms of the GNU General Public License as published by
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
 
#include <config.h>
 
16
#include <drizzled/server_includes.h>
17
17
#include <drizzled/gettext.h>
18
18
#include <drizzled/plugin/listen_tcp.h>
19
19
#include <drizzled/plugin/client.h>
20
 
#include <drizzled/session.h>
21
 
#include <drizzled/module/option_map.h>
22
 
 
23
 
#include <drizzled/plugin/catalog.h>
24
20
 
25
21
#include <iostream>
26
22
 
27
 
#include <boost/program_options.hpp>
28
 
 
29
23
using namespace std;
30
24
using namespace drizzled;
31
25
 
32
 
namespace po= boost::program_options;
33
 
 
34
 
static bool enabled= false;
35
 
static bool debug_enabled= false;
36
 
 
 
26
static bool enable= false;
 
27
static bool debug= false;
37
28
 
38
29
class ClientConsole: public plugin::Client
39
30
{
40
31
  bool is_dead;
41
32
  uint32_t column;
42
33
  uint32_t max_column;
43
 
  const std::string &username;
44
 
  const std::string &password;
45
 
  const std::string &schema;
46
 
  const std::string &_catalog;
47
34
 
48
35
public:
49
 
  ClientConsole(const std::string &username_arg,
50
 
                const std::string &password_arg,
51
 
                const std::string &schema_arg,
52
 
                const std::string &catalog_arg) :
 
36
  ClientConsole():
53
37
    is_dead(false),
54
38
    column(0),
55
 
    max_column(0),
56
 
    username(username_arg),
57
 
    password(password_arg),
58
 
    schema(schema_arg),
59
 
    _catalog(catalog_arg)
 
39
    max_column(0)
60
40
  {}
61
41
 
62
42
  virtual void printDebug(const char *message)
63
43
  {
64
 
    if (debug_enabled)
 
44
    if (debug)
65
45
      cout << "CONSOLE: " << message << endl;
66
46
  }
67
47
 
68
 
  catalog::Instance::shared_ptr catalog()
69
 
  {
70
 
    identifier::Catalog identifier(_catalog);
71
 
    catalog::Instance::shared_ptr tmp= plugin::Catalog::getInstance(identifier);
72
 
    if (not tmp)
73
 
    {
74
 
      std::cerr << "Invalid catalog '" << identifier << "', resorting to 'local' catalog" << std::endl;
75
 
    }
76
 
    return tmp;
77
 
  }
78
 
 
79
48
  virtual int getFileDescriptor(void)
80
49
  {
81
50
    printDebug("getFileDescriptor");
115
84
  virtual bool authenticate(void)
116
85
  {
117
86
    printDebug("authenticate");
118
 
    identifier::User::shared_ptr user= identifier::User::make_shared();
119
 
    user->setUser(username);
120
 
    session->setUser(user);
121
 
 
122
 
    return session->checkUser(password, schema);
 
87
    return true;
123
88
  }
124
89
 
125
90
  virtual bool readCommand(char **packet, uint32_t *packet_length)
126
91
  {
127
 
    uint32_t length;
 
92
    char buffer[8192];
 
93
    printf("drizzled> ");
 
94
    fflush(stdout);
128
95
 
129
96
    if (is_dead)
130
97
      return false;
131
98
 
132
 
    cout << "drizzled> ";
133
 
 
134
 
    length= 1024;
135
 
    *packet= NULL;
136
 
 
137
 
    /* Start with 1 byte offset so we can set command. */
138
 
    *packet_length= 1;
139
 
 
140
 
    do
141
 
    {
142
 
      *packet= (char *)realloc(*packet, length);
143
 
      if (*packet == NULL)
144
 
        return false;
145
 
 
146
 
      cin.clear();
147
 
      cin.getline(*packet + *packet_length, length - *packet_length, ';');
148
 
      *packet_length+= cin.gcount();
149
 
      length*= 2;
150
 
    }
151
 
    while (cin.eof() == false && cin.fail() == true);
152
 
 
153
 
    if ((*packet_length == 1 && cin.eof() == true) or
154
 
        not strncasecmp(*packet + 1, "quit", 4) or
155
 
        not strncasecmp(*packet + 1, "exit", 4) or
156
 
        not strncasecmp(*packet + 1, "shutdown", sizeof("shutdown") -1))
 
99
    if (fgets(buffer, 8192, stdin) == NULL ||!strcasecmp(buffer, "quit\n") ||
 
100
        !strcasecmp(buffer, "exit\n"))
157
101
    {
158
102
      is_dead= true;
159
103
      *packet_length= 1;
 
104
      *packet= (char *)malloc(*packet_length);
160
105
      (*packet)[0]= COM_SHUTDOWN;
161
 
 
162
106
      return true;
163
107
    }
164
108
 
165
 
    /* Skip \r and \n for next time. */
166
 
    cin.ignore(2, '\n');
167
 
 
 
109
    *packet_length= strlen(buffer);
 
110
    *packet= (char *)malloc(*packet_length);
168
111
    (*packet)[0]= COM_QUERY;
 
112
    memcpy(*packet + 1, buffer, *packet_length - 1);
169
113
 
170
114
    return true;
171
115
  }
180
124
    printDebug("sendEOF");
181
125
  }
182
126
 
183
 
  virtual void sendError(const drizzled::error_t sql_errno, const char *err)
 
127
  virtual void sendError(uint32_t sql_errno, const char *err)
184
128
  {
185
 
    cout << "Error: " << static_cast<long>(sql_errno) << " " << err << endl;
 
129
    cout << "Error: " << sql_errno << " " << err << endl;
186
130
  }
187
131
 
188
132
  virtual bool sendFields(List<Item> *list)
189
133
  {
190
 
    List<Item>::iterator it(list->begin());
 
134
    List_iterator_fast<Item> it(*list);
191
135
    Item *item;
192
136
 
193
137
    column= 0;
221
165
 
222
166
    char buff[MAX_FIELD_WIDTH];
223
167
    String str(buff, sizeof(buff), &my_charset_bin);
224
 
    from->val_str_internal(&str);
 
168
    from->val_str(&str);
225
169
    return store(str.ptr(), str.length());
226
170
  }
227
171
 
266
210
    return store(buffer->ptr(), buffer->length());
267
211
  }
268
212
 
 
213
  virtual bool store(const DRIZZLE_TIME *tm)
 
214
  {
 
215
    char buff[40];
 
216
    uint32_t length;
 
217
    uint32_t day;
 
218
 
 
219
    switch (tm->time_type)
 
220
    {
 
221
    case DRIZZLE_TIMESTAMP_DATETIME:
 
222
      length= sprintf(buff, "%04d-%02d-%02d %02d:%02d:%02d",
 
223
                      (int) tm->year,
 
224
                      (int) tm->month,
 
225
                      (int) tm->day,
 
226
                      (int) tm->hour,
 
227
                      (int) tm->minute,
 
228
                      (int) tm->second);
 
229
      if (tm->second_part)
 
230
        length+= sprintf(buff+length, ".%06d", (int)tm->second_part);
 
231
      break;
 
232
 
 
233
    case DRIZZLE_TIMESTAMP_DATE:
 
234
      length= sprintf(buff, "%04d-%02d-%02d",
 
235
                      (int) tm->year,
 
236
                      (int) tm->month,
 
237
                      (int) tm->day);
 
238
      break;
 
239
 
 
240
    case DRIZZLE_TIMESTAMP_TIME:
 
241
      day= (tm->year || tm->month) ? 0 : tm->day;
 
242
      length= sprintf(buff, "%s%02ld:%02d:%02d", tm->neg ? "-" : "",
 
243
                      (long) day*24L+(long) tm->hour, (int) tm->minute,
 
244
                      (int) tm->second);
 
245
      if (tm->second_part)
 
246
        length+= sprintf(buff+length, ".%06d", (int)tm->second_part);
 
247
      break;
 
248
 
 
249
    case DRIZZLE_TIMESTAMP_NONE:
 
250
    case DRIZZLE_TIMESTAMP_ERROR:
 
251
    default:
 
252
      assert(0);
 
253
      return false;
 
254
    }
 
255
 
 
256
    return store(buff);
 
257
  }
 
258
 
269
259
  virtual bool store(const char *from, size_t length)
270
260
  {
271
 
    cout.write(from, length);
272
 
    cout << "\t";
 
261
    printf("%.*s\t", (uint32_t)length, from);
273
262
    checkRowEnd();
274
263
    return false;
275
264
  }
291
280
    printDebug("wasAborted");
292
281
    return false;
293
282
  }
294
 
 
295
 
  bool isConsole()
296
 
  {
297
 
    return true;
298
 
  }
299
283
};
300
284
 
301
285
class ListenConsole: public plugin::Listen
302
286
{
303
287
  int pipe_fds[2];
304
 
  const std::string username;
305
 
  const std::string password;
306
 
  const std::string schema;
307
 
  const std::string _catalog;
308
288
 
309
289
public:
310
 
  ListenConsole(const std::string &name_arg,
311
 
                const std::string &username_arg,
312
 
                const std::string &password_arg,
313
 
                const std::string &schema_arg,
314
 
                const std::string &catalog_arg) :
315
 
    plugin::Listen(name_arg),
316
 
    username(username_arg),
317
 
    password(password_arg),
318
 
    schema(schema_arg),
319
 
    _catalog(catalog_arg)
 
290
  ListenConsole()
320
291
  {
321
292
    pipe_fds[0]= -1;
322
293
  }
332
303
 
333
304
  virtual bool getFileDescriptors(std::vector<int> &fds)
334
305
  {
335
 
    if (debug_enabled)
336
 
      enabled= true;
 
306
    if (debug)
 
307
      enable= true;
337
308
 
338
 
    if (not enabled)
 
309
    if (!enable)
339
310
      return false;
340
311
 
341
312
    if (pipe(pipe_fds) == -1)
342
313
    {
343
 
      errmsg_printf(error::ERROR, _("pipe() failed with errno %d"), errno);
 
314
      errmsg_printf(ERRMSG_LVL_ERROR, _("pipe() failed with errno %d"), errno);
344
315
      return true;
345
316
    }
346
317
 
353
324
  {
354
325
    char buffer[1];
355
326
    assert(read(fd, buffer, 1) == 1);
356
 
 
357
 
    return new ClientConsole(username, password, schema, _catalog);
 
327
    return new ClientConsole;
358
328
  }
359
329
};
360
330
 
361
 
static int init(drizzled::module::Context &context)
362
 
{
363
 
  const module::option_map &vm= context.getOptions();
364
 
  const string username(vm.count("username") ? vm["username"].as<string>() : "");
365
 
  const string password(vm.count("password") ? vm["password"].as<string>() : "");
366
 
  const string schema(vm.count("schema") ? vm["schema"].as<string>() : "");
367
 
 
368
 
  const std::string catalog(vm.count("catalog") ? vm["catalog"].as<string>() : "LOCAL");
369
 
 
370
 
  context.add(new ListenConsole("console", username, password, schema, catalog));
371
 
 
372
 
  return 0;
373
 
}
374
 
 
375
 
static void init_options(drizzled::module::option_context &context)
376
 
{
377
 
  context("enable",
378
 
          po::value<bool>(&enabled)->default_value(false)->zero_tokens(),
379
 
          N_("Enable the console."));
380
 
  context("debug",
381
 
          po::value<bool>(&debug_enabled)->default_value(false)->zero_tokens(),
382
 
          N_("Turn on extra debugging."));
383
 
  context("username",
384
 
          po::value<string>(),
385
 
          N_("User to use for auth."));
386
 
  context("password",
387
 
          po::value<string>(),
388
 
          N_("Password to use for auth."));
389
 
  context("catalog",
390
 
          po::value<string>(),
391
 
          N_("Default catalog to use."));
392
 
  context("schema",
393
 
          po::value<string>(),
394
 
          N_("Default schema to use."));
395
 
}
396
 
 
397
 
DRIZZLE_DECLARE_PLUGIN
398
 
{
399
 
  DRIZZLE_VERSION_ID,
 
331
static ListenConsole listen_obj;
 
332
 
 
333
static int init(drizzled::plugin::Registry &registry)
 
334
{
 
335
  registry.add(listen_obj);
 
336
  return 0;
 
337
}
 
338
 
 
339
static int deinit(drizzled::plugin::Registry &registry)
 
340
{
 
341
  registry.remove(listen_obj);
 
342
  return 0;
 
343
}
 
344
 
 
345
static DRIZZLE_SYSVAR_BOOL(enable, enable, PLUGIN_VAR_NOCMDARG,
 
346
                           N_("Enable the console."), NULL, NULL, false);
 
347
 
 
348
static DRIZZLE_SYSVAR_BOOL(debug, debug, PLUGIN_VAR_NOCMDARG,
 
349
                           N_("Turn on extra debugging."), NULL, NULL, false);
 
350
 
 
351
static struct st_mysql_sys_var* vars[]= {
 
352
  DRIZZLE_SYSVAR(enable),
 
353
  DRIZZLE_SYSVAR(debug),
 
354
  NULL
 
355
};
 
356
 
 
357
drizzle_declare_plugin(console)
 
358
{
400
359
  "console",
401
 
  "0.2",
 
360
  "0.1",
402
361
  "Eric Day",
403
362
  "Console Client",
404
363
  PLUGIN_LICENSE_BSD,
405
364
  init,   /* Plugin Init */
406
 
  NULL,   /* depends */
407
 
  init_options    /* config options */
 
365
  deinit, /* Plugin Deinit */
 
366
  NULL,   /* status variables */
 
367
  vars,   /* system variables */
 
368
  NULL    /* config options */
408
369
}
409
 
DRIZZLE_DECLARE_PLUGIN_END;
 
370
drizzle_declare_plugin_end;