← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/console/console.cc

  • Committer: Monty Taylor
  • Date: 2008-08-02 00:06:32 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080802000632-jsse0zdd9r6ic5ku
Actually turn gettext on...

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/console/console.cc
1
 
/* Copyright (C) 2009 Sun Microsystems
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
#include "config.h"
17
 
#include <drizzled/gettext.h>
18
 
#include <drizzled/plugin/listen_tcp.h>
19
 
#include <drizzled/plugin/client.h>
20
 
#include <drizzled/session.h>
21
 
#include <drizzled/module/option_map.h>
22
 
 
23
 
#include <iostream>
24
 
 
25
 
#include <boost/program_options.hpp>
26
 
 
27
 
using namespace std;
28
 
using namespace drizzled;
29
 
 
30
 
namespace po= boost::program_options;
31
 
 
32
 
static bool enabled= false;
33
 
static bool debug_enabled= false;
34
 
static char* username= NULL;
35
 
static char* password= NULL;
36
 
static char* db= NULL;
37
 
 
38
 
 
39
 
class ClientConsole: public plugin::Client
40
 
{
41
 
  bool is_dead;
42
 
  uint32_t column;
43
 
  uint32_t max_column;
44
 
 
45
 
public:
46
 
  ClientConsole():
47
 
    is_dead(false),
48
 
    column(0),
49
 
    max_column(0)
50
 
  {}
51
 
 
52
 
  virtual void printDebug(const char *message)
53
 
  {
54
 
    if (debug_enabled)
55
 
      cout << "CONSOLE: " << message << endl;
56
 
  }
57
 
 
58
 
  virtual int getFileDescriptor(void)
59
 
  {
60
 
    printDebug("getFileDescriptor");
61
 
    return 0;
62
 
  }
63
 
 
64
 
  virtual bool isConnected(void)
65
 
  {
66
 
    printDebug("isConnected");
67
 
    return true;
68
 
  }
69
 
 
70
 
  virtual bool isReading(void)
71
 
  {
72
 
    printDebug("isReading");
73
 
    return false;
74
 
  }
75
 
 
76
 
  virtual bool isWriting(void)
77
 
  {
78
 
    printDebug("isWriting");
79
 
    return false;
80
 
  }
81
 
 
82
 
  virtual bool flush(void)
83
 
  {
84
 
    printDebug("flush");
85
 
    return false;
86
 
  }
87
 
 
88
 
  virtual void close(void)
89
 
  {
90
 
    printDebug("close");
91
 
    is_dead= true;
92
 
  }
93
 
 
94
 
  virtual bool authenticate(void)
95
 
  {
96
 
    printDebug("authenticate");
97
 
    session->getSecurityContext().setUser(username);
98
 
    return session->checkUser(password, strlen(password), db);
99
 
  }
100
 
 
101
 
  virtual bool readCommand(char **packet, uint32_t *packet_length)
102
 
  {
103
 
    uint32_t length;
104
 
 
105
 
    if (is_dead)
106
 
      return false;
107
 
 
108
 
    cout << "drizzled> ";
109
 
 
110
 
    length= 1024;
111
 
    *packet= NULL;
112
 
 
113
 
    /* Start with 1 byte offset so we can set command. */
114
 
    *packet_length= 1;
115
 
 
116
 
    do
117
 
    {
118
 
      *packet= (char *)realloc(*packet, length);
119
 
      if (*packet == NULL)
120
 
        return false;
121
 
 
122
 
      cin.clear();
123
 
      cin.getline(*packet + *packet_length, length - *packet_length, ';');
124
 
      *packet_length+= cin.gcount();
125
 
      length*= 2;
126
 
    }
127
 
    while (cin.eof() == false && cin.fail() == true);
128
 
 
129
 
    if ((*packet_length == 1 && cin.eof() == true) ||
130
 
        !strncasecmp(*packet + 1, "quit", 4) ||
131
 
        !strncasecmp(*packet + 1, "exit", 4))
132
 
    {
133
 
      is_dead= true;
134
 
      *packet_length= 1;
135
 
      (*packet)[0]= COM_SHUTDOWN;
136
 
      return true;
137
 
    }
138
 
 
139
 
    /* Skip \r and \n for next time. */
140
 
    cin.ignore(2, '\n');
141
 
 
142
 
    (*packet)[0]= COM_QUERY;
143
 
    return true;
144
 
  }
145
 
 
146
 
  virtual void sendOK(void)
147
 
  {
148
 
    cout << "OK" << endl;
149
 
  }
150
 
 
151
 
  virtual void sendEOF(void)
152
 
  {
153
 
    printDebug("sendEOF");
154
 
  }
155
 
 
156
 
  virtual void sendError(uint32_t sql_errno, const char *err)
157
 
  {
158
 
    cout << "Error: " << sql_errno << " " << err << endl;
159
 
  }
160
 
 
161
 
  virtual bool sendFields(List<Item> *list)
162
 
  {
163
 
    List_iterator_fast<Item> it(*list);
164
 
    Item *item;
165
 
 
166
 
    column= 0;
167
 
    max_column= 0;
168
 
 
169
 
    while ((item=it++))
170
 
    {
171
 
      SendField field;
172
 
      item->make_field(&field);
173
 
      cout << field.col_name << "\t";
174
 
      max_column++;
175
 
    }
176
 
 
177
 
    cout << endl;
178
 
 
179
 
    return false;
180
 
  }
181
 
 
182
 
  virtual void checkRowEnd(void)
183
 
  {
184
 
    if (++column % max_column == 0)
185
 
      cout << endl;
186
 
  }
187
 
 
188
 
  using Client::store;
189
 
 
190
 
  virtual bool store(Field *from)
191
 
  {
192
 
    if (from->is_null())
193
 
      return store();
194
 
 
195
 
    char buff[MAX_FIELD_WIDTH];
196
 
    String str(buff, sizeof(buff), &my_charset_bin);
197
 
    from->val_str(&str);
198
 
    return store(str.ptr(), str.length());
199
 
  }
200
 
 
201
 
  virtual bool store(void)
202
 
  {
203
 
    cout << "NULL" << "\t";
204
 
    checkRowEnd();
205
 
    return false;
206
 
  }
207
 
 
208
 
  virtual bool store(int32_t from)
209
 
  {
210
 
    cout << from << "\t";
211
 
    checkRowEnd();
212
 
    return false;
213
 
  }
214
 
 
215
 
  virtual bool store(uint32_t from)
216
 
  {
217
 
    cout << from << "\t";
218
 
    checkRowEnd();
219
 
    return false;
220
 
  }
221
 
 
222
 
  virtual bool store(int64_t from)
223
 
  {
224
 
    cout << from << "\t";
225
 
    checkRowEnd();
226
 
    return false;
227
 
  }
228
 
 
229
 
  virtual bool store(uint64_t from)
230
 
  {
231
 
    cout << from << "\t";
232
 
    checkRowEnd();
233
 
    return false;
234
 
  }
235
 
 
236
 
  virtual bool store(double from, uint32_t decimals, String *buffer)
237
 
  {
238
 
    buffer->set_real(from, decimals, &my_charset_bin);
239
 
    return store(buffer->ptr(), buffer->length());
240
 
  }
241
 
 
242
 
  virtual bool store(const char *from, size_t length)
243
 
  {
244
 
    cout.write(from, length);
245
 
    cout << "\t";
246
 
    checkRowEnd();
247
 
    return false;
248
 
  }
249
 
 
250
 
  virtual bool haveMoreData(void)
251
 
  {
252
 
    printDebug("haveMoreData");
253
 
    return false;
254
 
  }
255
 
 
256
 
  virtual bool haveError(void)
257
 
  {
258
 
    printDebug("haveError");
259
 
    return false;
260
 
  }
261
 
 
262
 
  virtual bool wasAborted(void)
263
 
  {
264
 
    printDebug("wasAborted");
265
 
    return false;
266
 
  }
267
 
};
268
 
 
269
 
class ListenConsole: public plugin::Listen
270
 
{
271
 
  int pipe_fds[2];
272
 
 
273
 
public:
274
 
  ListenConsole(const std::string &name_arg) :
275
 
    plugin::Listen(name_arg)
276
 
  {
277
 
    pipe_fds[0]= -1;
278
 
  }
279
 
 
280
 
  virtual ~ListenConsole()
281
 
  {
282
 
    if (pipe_fds[0] != -1)
283
 
    {
284
 
      close(pipe_fds[0]);
285
 
      close(pipe_fds[1]);
286
 
    }
287
 
 
288
 
    /* Cleanup from the module strdup'ing these below */
289
 
    free(username);
290
 
    free(password);
291
 
    free(db);
292
 
  }
293
 
 
294
 
  virtual bool getFileDescriptors(std::vector<int> &fds)
295
 
  {
296
 
    if (debug_enabled)
297
 
      enabled= true;
298
 
 
299
 
    if (enabled == false)
300
 
      return false;
301
 
 
302
 
    if (pipe(pipe_fds) == -1)
303
 
    {
304
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("pipe() failed with errno %d"), errno);
305
 
      return true;
306
 
    }
307
 
 
308
 
    fds.push_back(pipe_fds[0]);
309
 
    assert(write(pipe_fds[1], "\0", 1) == 1);
310
 
    return false;
311
 
  }
312
 
 
313
 
  virtual drizzled::plugin::Client *getClient(int fd)
314
 
  {
315
 
    char buffer[1];
316
 
    assert(read(fd, buffer, 1) == 1);
317
 
    return new ClientConsole;
318
 
  }
319
 
};
320
 
 
321
 
static int init(drizzled::module::Context &context)
322
 
{
323
 
  const module::option_map &vm= context.getOptions();
324
 
  /* duplicating these here means they need to be freed. They're global, so
325
 
     we'll just have the ListenConsole object do it in its destructor */
326
 
  if (vm.count("username"))
327
 
    username= strdup(vm["username"].as<string>().c_str());
328
 
  else
329
 
    username= strdup("");
330
 
 
331
 
  if (vm.count("password"))
332
 
    password= strdup(vm["password"].as<string>().c_str());
333
 
  else
334
 
    password= strdup("");
335
 
 
336
 
  if (vm.count("db"))
337
 
    db= strdup(vm["db"].as<string>().c_str());
338
 
  else
339
 
    db= strdup("");
340
 
 
341
 
  context.add(new ListenConsole("console"));
342
 
  return 0;
343
 
}
344
 
 
345
 
static DRIZZLE_SYSVAR_BOOL(enable, enabled, PLUGIN_VAR_NOCMDARG,
346
 
                           N_("Enable the console."), NULL, NULL, false);
347
 
static DRIZZLE_SYSVAR_BOOL(debug, debug_enabled, PLUGIN_VAR_NOCMDARG,
348
 
                           N_("Turn on extra debugging."), NULL, NULL, false);
349
 
 
350
 
static DRIZZLE_SYSVAR_STR(username, username, PLUGIN_VAR_READONLY,
351
 
                          N_("User to use for auth."), NULL, NULL, NULL);
352
 
static DRIZZLE_SYSVAR_STR(password, password, PLUGIN_VAR_READONLY,
353
 
                          N_("Password to use for auth."), NULL, NULL, NULL);
354
 
static DRIZZLE_SYSVAR_STR(db, db, PLUGIN_VAR_READONLY,
355
 
                          N_("Default database to use."), NULL, NULL, NULL);
356
 
 
357
 
static void init_options(drizzled::module::option_context &context)
358
 
{
359
 
  context("enable",
360
 
          po::value<bool>(&enabled)->default_value(false)->zero_tokens(),
361
 
          N_("Enable the console."));
362
 
  context("debug",
363
 
          po::value<bool>(&debug_enabled)->default_value(false)->zero_tokens(),
364
 
          N_("Turn on extra debugging."));
365
 
  context("username",
366
 
          po::value<string>(),
367
 
          N_("User to use for auth."));
368
 
  context("password",
369
 
          po::value<string>(),
370
 
          N_("Password to use for auth."));
371
 
  context("db",
372
 
          po::value<string>(),
373
 
          N_("Default database to use."));
374
 
}
375
 
 
376
 
static drizzle_sys_var* vars[]= {
377
 
  DRIZZLE_SYSVAR(enable),
378
 
  DRIZZLE_SYSVAR(debug),
379
 
  DRIZZLE_SYSVAR(username),
380
 
  DRIZZLE_SYSVAR(password),
381
 
  DRIZZLE_SYSVAR(db),
382
 
  NULL
383
 
};
384
 
 
385
 
DRIZZLE_DECLARE_PLUGIN
386
 
{
387
 
  DRIZZLE_VERSION_ID,
388
 
  "console",
389
 
  "0.1",
390
 
  "Eric Day",
391
 
  "Console Client",
392
 
  PLUGIN_LICENSE_BSD,
393
 
  init,   /* Plugin Init */
394
 
  vars,   /* system variables */
395
 
  init_options    /* config options */
396
 
}
397
 
DRIZZLE_DECLARE_PLUGIN_END;