← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/rpl_mi.cc

  • Committer: Brian Aker
  • Date: 2008-11-04 15:39:09 UTC
  • mfrom: (575.1.2 devel)
  • Revision ID: brian@tangent.org-20081104153909-c72hn65udxs1ccal
Merge of Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/rpl_mi.cc
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
#include <drizzled/server_includes.h>
17
 
#include "rpl_mi.h"
18
 
 
19
 
#ifdef HAVE_REPLICATION
 
17
#include <drizzled/rpl_mi.h>
 
18
#include <drizzled/gettext.h>
 
19
#include <drizzled/slave.h>
 
20
#include <drizzled/data_home.h>
 
21
 
 
22
#include <iostream>
 
23
#include <fstream>
 
24
 
 
25
using namespace std;
20
26
 
21
27
#define DEFAULT_CONNECT_RETRY 60
22
28
 
23
29
// Defined in slave.cc
24
30
int init_intvar_from_file(int* var, IO_CACHE* f, int default_val);
25
31
int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,
26
 
                          const char *default_val);
 
32
                          const char *default_val);
27
33
int init_floatvar_from_file(float* var, IO_CACHE* f, float default_val);
28
34
 
29
35
Master_info::Master_info()
30
36
  :Slave_reporting_capability("I/O"),
31
 
   ssl(0), ssl_verify_server_cert(0), fd(-1),  io_thd(0), port(DRIZZLE_PORT),
32
37
   connect_retry(DEFAULT_CONNECT_RETRY), heartbeat_period(0),
33
38
   received_heartbeats(0), inited(0),
34
39
   abort_slave(0), slave_running(0), slave_run_id(0)
35
40
{
36
41
  host[0] = 0; user[0] = 0; password[0] = 0;
37
 
  ssl_ca[0]= 0; ssl_capath[0]= 0; ssl_cert[0]= 0;
38
 
  ssl_cipher[0]= 0; ssl_key[0]= 0;
 
42
  io_session= NULL;
 
43
  port= DRIZZLE_PORT;
39
44
 
40
 
  memset(&file, 0, sizeof(file));
41
45
  pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
42
46
  pthread_mutex_init(&data_lock, MY_MUTEX_INIT_FAST);
43
47
  pthread_cond_init(&data_cond, NULL);
54
58
  pthread_cond_destroy(&stop_cond);
55
59
}
56
60
 
57
 
 
58
 
void init_master_log_pos(Master_info* mi)
59
 
{
60
 
  mi->master_log_name[0] = 0;
61
 
  mi->master_log_pos = BIN_LOG_HEADER_SIZE;             // skip magic number
62
 
  /* 
63
 
    always request heartbeat unless master_heartbeat_period is set
64
 
    explicitly zero.  Here is the default value for heartbeat period
65
 
    if CHANGE MASTER did not specify it.  (no data loss in conversion
66
 
    as hb period has a max)
67
 
  */
68
 
  mi->heartbeat_period= (float) min((double)SLAVE_MAX_HEARTBEAT_PERIOD,
69
 
                                    (slave_net_timeout/2.0));
70
 
  assert(mi->heartbeat_period > (float) 0.001
71
 
              || mi->heartbeat_period == 0);
72
 
  return;
73
 
}
74
 
 
75
 
 
76
 
enum {
77
 
  LINES_IN_MASTER_INFO_WITH_SSL= 14,
78
 
 
79
 
  /* 5.1.16 added value of master_ssl_verify_server_cert */
80
 
  LINE_FOR_MASTER_SSL_VERIFY_SERVER_CERT= 15,
81
 
 
82
 
  /* 6.0 added value of master_heartbeat_period */
83
 
  LINE_FOR_MASTER_HEARTBEAT_PERIOD= 16,
84
 
 
85
 
  /* Number of lines currently used when saving master info file */
86
 
  LINES_IN_MASTER_INFO= LINE_FOR_MASTER_HEARTBEAT_PERIOD
87
 
};
88
 
 
89
 
 
90
 
int init_master_info(Master_info* mi, const char* master_info_fname,
91
 
                     const char* slave_info_fname,
92
 
                     bool abort_if_no_master_info_file,
93
 
                     int thread_mask)
94
 
{
95
 
  int fd,error;
96
 
  char fname[FN_REFLEN+128];
97
 
 
98
 
  if (mi->inited)
 
61
bool Master_info::setPassword(const char *pword)
 
62
{
 
63
  password.assign(pword);
 
64
 
 
65
  return true;
 
66
}
 
67
 
 
68
const char *Master_info::getPassword()
 
69
{
 
70
  return password.c_str();
 
71
}
 
72
 
 
73
bool Master_info::setUsername(const char *username)
 
74
{
 
75
  user.assign(username);
 
76
 
 
77
  return true;
 
78
}
 
79
 
 
80
const char *Master_info::getUsername()
 
81
{
 
82
  return user.c_str();
 
83
}
 
84
 
 
85
bool Master_info::setHost(const char *hostname, uint16_t new_port)
 
86
{
 
87
  host.assign(hostname);
 
88
  port= new_port;
 
89
 
 
90
  return true;
 
91
}
 
92
 
 
93
const char *Master_info::getHostname()
 
94
{
 
95
  return host.c_str();
 
96
}
 
97
 
 
98
uint16_t Master_info::getPort()
 
99
{
 
100
  return port;
 
101
}
 
102
 
 
103
off_t Master_info::getLogPosition()
 
104
{
 
105
  return log_pos;
 
106
}
 
107
 
 
108
bool Master_info::setLogPosition(off_t position)
 
109
{
 
110
  log_pos= position;
 
111
 
 
112
  return true;
 
113
}
 
114
 
 
115
void Master_info::incrementLogPosition(off_t position)
 
116
{
 
117
  log_pos+= position;
 
118
}
 
119
 
 
120
const char *Master_info::getLogName()
 
121
{
 
122
  return log_name.c_str();
 
123
}
 
124
 
 
125
bool Master_info::setLogName(const char *name)
 
126
{
 
127
 log_name.assign(name);
 
128
 
 
129
  return true;
 
130
}
 
131
 
 
132
uint32_t Master_info::getConnectionRetry()
 
133
{
 
134
  return connect_retry;
 
135
}
 
136
 
 
137
bool Master_info::setConnectionRetry(uint32_t retry)
 
138
{
 
139
  connect_retry= retry;
 
140
 
 
141
  return true;
 
142
}
 
143
 
 
144
 
 
145
void Master_info::reset()
 
146
{
 
147
  log_name.clear();
 
148
  log_pos= 0; 
 
149
}
 
150
 
 
151
 
 
152
int Master_info::init_master_info(const char* master_info_fname,
 
153
                                  const char* slave_info_fname,
 
154
                                  int thread_mask)
 
155
{
 
156
  int error;
 
157
 
 
158
  if (inited)
99
159
  {
100
160
    /*
101
161
      We have to reset read position of relay-log-bin as we may have
111
171
    */
112
172
    if (thread_mask & SLAVE_SQL)
113
173
    {
114
 
      my_b_seek(mi->rli.cur_log, (my_off_t) 0);
 
174
      my_b_seek(rli.cur_log, (my_off_t) 0);
115
175
    }
116
176
    return(0);
117
177
  }
118
178
 
119
 
  mi->drizzle=0;
120
 
  mi->file_id=1;
121
 
  fn_format(fname, master_info_fname, mysql_data_home, "", 4+32);
 
179
  drizzle= 0;
 
180
  file_id= 1;
 
181
  {
 
182
    char fname[FN_REFLEN+128];
 
183
 
 
184
    fn_format(fname, master_info_fname, mysql_data_home, "", 4+32);
 
185
    info_filename.assign(fname);
 
186
  }
122
187
 
123
188
  /*
124
189
    We need a mutex while we are changing master info parameters to
125
190
    keep other threads from reading bogus info
126
191
  */
127
192
 
128
 
  pthread_mutex_lock(&mi->data_lock);
129
 
  fd = mi->fd;
 
193
  pthread_mutex_lock(&data_lock);
130
194
 
131
195
  /* does master.info exist ? */
132
196
 
133
 
  if (access(fname,F_OK))
 
197
  if (access(info_filename.c_str(), F_OK))
134
198
  {
135
 
    if (abort_if_no_master_info_file)
136
 
    {
137
 
      pthread_mutex_unlock(&mi->data_lock);
138
 
      return(0);
139
 
    }
140
 
    /*
141
 
      if someone removed the file from underneath our feet, just close
142
 
      the old descriptor and re-create the old file
143
 
    */
144
 
    if (fd >= 0)
145
 
      my_close(fd, MYF(MY_WME));
146
 
    if ((fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
147
 
    {
148
 
      sql_print_error(_("Failed to create a new master info file (file '%s', errno %d)"), fname, my_errno);
149
 
      goto err;
150
 
    }
151
 
    if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
152
 
                      MYF(MY_WME)))
153
 
    {
154
 
      sql_print_error(_("Failed to create a cache on master info file (file '%s')"), fname);
155
 
      goto err;
156
 
    }
157
 
 
158
 
    mi->fd = fd;
159
 
    init_master_log_pos(mi);
160
 
 
 
199
    drizzle::MasterList_Record *record;
 
200
 
 
201
    reset();
 
202
 
 
203
    /* Write new Master info file here (from info_filename) */
 
204
    record= list.add_record();
 
205
    record->set_hostname(host);
 
206
    record->set_username(user);
 
207
    record->set_password(password);
 
208
    record->set_port(port);
 
209
    record->set_connect_retry(connect_retry);
 
210
    record->set_log_name(log_name);
 
211
    record->set_log_position(log_pos);
 
212
 
 
213
    fstream output(info_filename.c_str(), ios::out | ios::trunc | ios::binary);
 
214
    if (!list.SerializeToOstream(&output)) 
 
215
    { 
 
216
      assert(0);
 
217
      return -1;
 
218
    }
161
219
  }
162
220
  else // file exists
163
221
  {
164
 
    if (fd >= 0)
165
 
      reinit_io_cache(&mi->file, READ_CACHE, 0L,0,0);
166
 
    else
167
 
    {
168
 
      if ((fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
169
 
      {
170
 
        sql_print_error(_("Failed to open the existing master info file (file '%s', errno %d)"), fname, my_errno);
171
 
        goto err;
172
 
      }
173
 
      if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,
174
 
                        0, MYF(MY_WME)))
175
 
      {
176
 
        sql_print_error(_("Failed to create a cache on master info file (file '%s')"), fname);
177
 
        goto err;
178
 
      }
179
 
    }
180
 
 
181
 
    mi->fd = fd;
182
 
    int port, connect_retry, master_log_pos, lines;
183
 
    int ssl= 0, ssl_verify_server_cert= 0;
184
 
    float master_heartbeat_period= 0.0;
185
 
    char *first_non_digit;
186
 
 
187
 
    /*
188
 
       Starting from 4.1.x master.info has new format. Now its
189
 
       first line contains number of lines in file. By reading this
190
 
       number we will be always distinguish to which version our
191
 
       master.info corresponds to. We can't simply count lines in
192
 
       file since versions before 4.1.x could generate files with more
193
 
       lines than needed.
194
 
       If first line doesn't contain a number or contain number less than
195
 
       LINES_IN_MASTER_INFO_WITH_SSL then such file is treated like file
196
 
       from pre 4.1.1 version.
197
 
       There is no ambiguity when reading an old master.info, as before
198
 
       4.1.1, the first line contained the binlog's name, which is either
199
 
       empty or has an extension (contains a '.'), so can't be confused
200
 
       with an integer.
201
 
 
202
 
       So we're just reading first line and trying to figure which version
203
 
       is this.
204
 
    */
205
 
 
206
 
    /*
207
 
       The first row is temporarily stored in mi->master_log_name,
208
 
       if it is line count and not binlog name (new format) it will be
209
 
       overwritten by the second row later.
210
 
    */
211
 
    if (init_strvar_from_file(mi->master_log_name,
212
 
                              sizeof(mi->master_log_name), &mi->file,
213
 
                              ""))
214
 
      goto errwithmsg;
215
 
 
216
 
    lines= strtoul(mi->master_log_name, &first_non_digit, 10);
217
 
 
218
 
    if (mi->master_log_name[0]!='\0' &&
219
 
        *first_non_digit=='\0' && lines >= LINES_IN_MASTER_INFO_WITH_SSL)
220
 
    {
221
 
      /* Seems to be new format => read master log name from next line */
222
 
      if (init_strvar_from_file(mi->master_log_name,
223
 
            sizeof(mi->master_log_name), &mi->file, ""))
224
 
        goto errwithmsg;
225
 
    }
226
 
    else
227
 
      lines= 7;
228
 
 
229
 
    if (init_intvar_from_file(&master_log_pos, &mi->file, 4) ||
230
 
        init_strvar_from_file(mi->host, sizeof(mi->host), &mi->file, 0) ||
231
 
        init_strvar_from_file(mi->user, sizeof(mi->user), &mi->file, "test") ||
232
 
        init_strvar_from_file(mi->password, SCRAMBLED_PASSWORD_CHAR_LENGTH+1,
233
 
                              &mi->file, 0 ) ||
234
 
        init_intvar_from_file(&port, &mi->file, DRIZZLE_PORT) ||
235
 
        init_intvar_from_file(&connect_retry, &mi->file, DEFAULT_CONNECT_RETRY))
236
 
      goto errwithmsg;
237
 
 
238
 
    /*
239
 
      If file has ssl part use it even if we have server without
240
 
      SSL support. But these option will be ignored later when
241
 
      slave will try connect to master, so in this case warning
242
 
      is printed.
243
 
    */
244
 
    if (lines >= LINES_IN_MASTER_INFO_WITH_SSL)
245
 
    {
246
 
      if (init_intvar_from_file(&ssl, &mi->file, 0) ||
247
 
          init_strvar_from_file(mi->ssl_ca, sizeof(mi->ssl_ca),
248
 
                                &mi->file, 0) ||
249
 
          init_strvar_from_file(mi->ssl_capath, sizeof(mi->ssl_capath),
250
 
                                &mi->file, 0) ||
251
 
          init_strvar_from_file(mi->ssl_cert, sizeof(mi->ssl_cert),
252
 
                                &mi->file, 0) ||
253
 
          init_strvar_from_file(mi->ssl_cipher, sizeof(mi->ssl_cipher),
254
 
                                &mi->file, 0) ||
255
 
          init_strvar_from_file(mi->ssl_key, sizeof(mi->ssl_key),
256
 
                               &mi->file, 0))
257
 
      goto errwithmsg;
258
 
 
259
 
      /*
260
 
        Starting from 5.1.16 ssl_verify_server_cert might be
261
 
        in the file
262
 
      */
263
 
      if (lines >= LINE_FOR_MASTER_SSL_VERIFY_SERVER_CERT &&
264
 
          init_intvar_from_file(&ssl_verify_server_cert, &mi->file, 0))
265
 
        goto errwithmsg;
266
 
      /*
267
 
        Starting from 6.0 master_heartbeat_period might be
268
 
        in the file
269
 
      */
270
 
      if (lines >= LINE_FOR_MASTER_HEARTBEAT_PERIOD &&
271
 
          init_floatvar_from_file(&master_heartbeat_period, &mi->file, 0.0))
272
 
        goto errwithmsg;
273
 
    }
274
 
 
275
 
    if (ssl)
276
 
      sql_print_warning(_("SSL information in the master info file "
277
 
                          "('%s') are ignored because this MySQL slave was "
278
 
                          "compiled without SSL support."), fname);
279
 
 
280
 
    /*
281
 
      This has to be handled here as init_intvar_from_file can't handle
282
 
      my_off_t types
283
 
    */
284
 
    mi->master_log_pos= (my_off_t) master_log_pos;
285
 
    mi->port= (uint) port;
286
 
    mi->connect_retry= (uint) connect_retry;
287
 
    mi->ssl= (bool) ssl;
288
 
    mi->ssl_verify_server_cert= ssl_verify_server_cert;
289
 
    mi->heartbeat_period= master_heartbeat_period;
 
222
    /* Read Master info file here (from info_filename) */
 
223
    fstream input(info_filename.c_str(), ios::in | ios::binary);
 
224
    if (!list.ParseFromIstream(&input)) 
 
225
    {
 
226
      assert(0);
 
227
      return -1;
 
228
    }
 
229
 
 
230
    /* We do not support multi-master just yet */
 
231
    assert(list.record_size() == 1);
 
232
    const drizzle::MasterList_Record record= list.record(0);
 
233
 
 
234
    if (record.has_username())
 
235
      user= record.username();
 
236
    if (record.has_password())
 
237
      password= record.password();
 
238
    if (record.has_port())
 
239
      port= record.port();
 
240
    if (record.has_connect_retry())
 
241
      connect_retry= record.connect_retry();
 
242
    if (record.has_log_name())
 
243
      log_name= record.log_name();
 
244
    if (record.has_log_position())
 
245
      log_pos= record.log_position();
290
246
  }
291
247
 
292
 
  mi->rli.mi = mi;
293
 
  if (init_relay_log_info(&mi->rli, slave_info_fname))
 
248
  rli.mi = this;
 
249
  if (init_relay_log_info(&rli, slave_info_fname))
294
250
    goto err;
295
251
 
296
 
  mi->inited = 1;
297
 
  // now change cache READ -> WRITE - must do this before flush_master_info
298
 
  reinit_io_cache(&mi->file, WRITE_CACHE, 0L, 0, 1);
299
 
  if ((error=test(flush_master_info(mi, 1))))
 
252
  inited= 1;
 
253
  if ((error= test(flush())))
300
254
    sql_print_error(_("Failed to flush master info file"));
301
 
  pthread_mutex_unlock(&mi->data_lock);
 
255
  pthread_mutex_unlock(&data_lock);
302
256
  return(error);
303
257
 
304
 
errwithmsg:
305
 
  sql_print_error(_("Error reading master configuration"));
306
 
 
307
258
err:
308
 
  if (fd >= 0)
309
 
  {
310
 
    my_close(fd, MYF(0));
311
 
    end_io_cache(&mi->file);
312
 
  }
313
 
  mi->fd= -1;
314
 
  pthread_mutex_unlock(&mi->data_lock);
315
 
  return(1);
 
259
  pthread_mutex_unlock(&data_lock);
 
260
  return 1;
316
261
}
317
262
 
318
263
 
322
267
     1 - flush master info failed
323
268
     0 - all ok
324
269
*/
325
 
int flush_master_info(Master_info* mi, bool flush_relay_log_cache)
 
270
int Master_info::flush()
326
271
{
327
 
  IO_CACHE* file = &mi->file;
328
 
  char lbuf[22];
329
 
 
330
272
  /*
331
273
    Flush the relay log to disk. If we don't do it, then the relay log while
332
274
    have some part (its last kilobytes) in memory only, so if the slave server
339
281
    When we come to this place in code, relay log may or not be initialized;
340
282
    the caller is responsible for setting 'flush_relay_log_cache' accordingly.
341
283
  */
342
 
  if (flush_relay_log_cache &&
343
 
      flush_io_cache(mi->rli.relay_log.get_log_file()))
344
 
    return(2);
345
 
 
346
 
  /*
347
 
    We flushed the relay log BEFORE the master.info file, because if we crash
348
 
    now, we will get a duplicate event in the relay log at restart. If we
349
 
    flushed in the other order, we would get a hole in the relay log.
350
 
    And duplicate is better than hole (with a duplicate, in later versions we
351
 
    can add detection and scrap one event; with a hole there's nothing we can
352
 
    do).
353
 
  */
354
 
 
355
 
  /*
356
 
     In certain cases this code may create master.info files that seems
357
 
     corrupted, because of extra lines filled with garbage in the end
358
 
     file (this happens if new contents take less space than previous
359
 
     contents of file). But because of number of lines in the first line
360
 
     of file we don't care about this garbage.
361
 
  */
362
 
  char heartbeat_buf[sizeof(mi->heartbeat_period) * 4]; // buffer to suffice always
363
 
  sprintf(heartbeat_buf, "%.3f", mi->heartbeat_period);
364
 
  my_b_seek(file, 0L);
365
 
  my_b_printf(file,
366
 
              "%u\n%s\n%s\n%s\n%s\n%s\n%d\n%d\n%d\n%s\n%s\n%s\n%s\n%s\n%d\n%s\n",
367
 
              LINES_IN_MASTER_INFO,
368
 
              mi->master_log_name, llstr(mi->master_log_pos, lbuf),
369
 
              mi->host, mi->user,
370
 
              mi->password, mi->port, mi->connect_retry,
371
 
              (int)(mi->ssl), mi->ssl_ca, mi->ssl_capath, mi->ssl_cert,
372
 
              mi->ssl_cipher, mi->ssl_key, mi->ssl_verify_server_cert,
373
 
              heartbeat_buf);
374
 
  return(-flush_io_cache(file));
 
284
 
 
285
  /* Write Master info file here (from info_filename) */
 
286
  assert(info_filename.length());
 
287
  assert(list.record_size() == 1);
 
288
  drizzle::MasterList_Record *record= list.mutable_record(0);
 
289
 
 
290
  record->set_hostname(host);
 
291
  record->set_username(user);
 
292
  record->set_password(password);
 
293
  record->set_port(port);
 
294
  record->set_connect_retry(connect_retry);
 
295
  record->set_log_name(log_name);
 
296
  record->set_log_position(log_pos);
 
297
 
 
298
  fstream output(info_filename.c_str(), ios::out | ios::trunc | ios::binary);
 
299
  if (!list.SerializeToOstream(&output)) 
 
300
  { 
 
301
    assert(0);
 
302
    return 1;
 
303
  }
 
304
 
 
305
  return 0;
375
306
}
376
307
 
377
308
 
378
 
void end_master_info(Master_info* mi)
 
309
void Master_info::end_master_info()
379
310
{
380
 
  if (!mi->inited)
 
311
  if (!inited)
381
312
    return;
382
 
  end_relay_log_info(&mi->rli);
383
 
  if (mi->fd >= 0)
384
 
  {
385
 
    end_io_cache(&mi->file);
386
 
    (void)my_close(mi->fd, MYF(MY_WME));
387
 
    mi->fd = -1;
388
 
  }
389
 
  mi->inited = 0;
 
313
  end_relay_log_info(&rli);
 
314
  inited = 0;
390
315
 
391
316
  return;
392
317
}
393
 
 
394
 
 
395
 
#endif /* HAVE_REPLICATION */