« back to all changes in this revision
Viewing changes to drizzled/rpl_mi.cc
- browse files at revision 490
- compare with another revision
- compare with revision 81
- download diff
- download tarball
- view history from revision 490
- Committer: Brian Aker
- Date: 2008-10-08 02:16:25 UTC
- Revision ID: brian@tangent.org-20081008021625-3756823nqs1phvsn
More effort around master.info (and relay.info)
added
removed
drizzled/rpl_mi.cc
26
26
27
27
Master_info::Master_info()
28
28
:Slave_reporting_capability("I/O"),
29
fd(-1), io_thd(0), port(DRIZZLE_PORT),
30
29
connect_retry(DEFAULT_CONNECT_RETRY), heartbeat_period(0),
31
30
received_heartbeats(0), inited(0),
32
31
abort_slave(0), slave_running(0), slave_run_id(0)
33
32
{
34
33
host[0] = 0; user[0] = 0; password[0] = 0;
34
io_thd= NULL;
35
port= DRIZZLE_PORT;
36
fd= -1,
35
37
36
38
memset(&file, 0, sizeof(file));
37
39
pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
50
52
pthread_cond_destroy(&stop_cond);
51
53
}
52
54
53
54
void init_master_log_pos(Master_info* mi)
55
{
56
mi->master_log_name[0] = 0;
57
mi->master_log_pos = BIN_LOG_HEADER_SIZE; // skip magic number
55
bool Master_info::setPassword(const char *pword)
56
{
57
password.assign(pword);
58
59
return true;
60
}
61
62
const char *Master_info::getPassword()
63
{
64
return password.c_str();
65
}
66
67
bool Master_info::setUsername(const char *username)
68
{
69
user.assign(username);
70
71
return true;
72
}
73
74
const char *Master_info::getUsername()
75
{
76
return user.c_str();
77
}
78
79
bool Master_info::setHost(const char *hostname, uint16_t new_port)
80
{
81
host.assign(hostname);
82
port= new_port;
83
84
return true;
85
}
86
87
const char *Master_info::getHostname()
88
{
89
return host.c_str();
90
}
91
92
uint16_t Master_info::getPort()
93
{
94
return port;
95
}
96
97
off_t Master_info::getLogPosition()
98
{
99
return master_log_pos;
100
}
101
102
bool Master_info::setLogPosition(off_t position)
103
{
104
master_log_pos= position;
105
106
return true;
107
}
108
109
const char *Master_info::getLogName()
110
{
111
return master_log_name.c_str();
112
}
113
114
bool Master_info::setLogName(const char *name)
115
{
116
master_log_name.assign(name);
117
118
return true;
119
}
120
121
uint32_t Master_info::getConnectionRetry()
122
{
123
return connect_retry;
124
}
125
126
bool Master_info::setConnectionRetry(uint32_t retry)
127
{
128
connect_retry= retry;
129
130
return true;
131
}
132
133
134
void Master_info::init_master_log_pos()
135
{
136
master_log_name.clear();
137
master_log_pos = BIN_LOG_HEADER_SIZE; // skip magic number
58
138
/*
59
139
always request heartbeat unless master_heartbeat_period is set
60
140
explicitly zero. Here is the default value for heartbeat period
61
141
if CHANGE MASTER did not specify it. (no data loss in conversion
62
142
as hb period has a max)
63
143
*/
64
mi->heartbeat_period= (float) cmin((double)SLAVE_MAX_HEARTBEAT_PERIOD,
65
(slave_net_timeout/2.0));
66
assert(mi->heartbeat_period > (float) 0.001
67
|| mi->heartbeat_period == 0);
144
heartbeat_period= (float) cmin((double)SLAVE_MAX_HEARTBEAT_PERIOD,
145
(slave_net_timeout/2.0));
146
assert(heartbeat_period > (float) 0.001
147
|| heartbeat_period == 0);
68
148
return;
69
149
}
70
150
71
151
72
enum {
73
LINES_IN_MASTER_INFO_WITH_SSL= 14,
74
75
/* 5.1.16 added value of master_ssl_verify_server_cert */
76
LINE_FOR_MASTER_SSL_VERIFY_SERVER_CERT= 15,
77
78
/* 6.0 added value of master_heartbeat_period */
79
LINE_FOR_MASTER_HEARTBEAT_PERIOD= 16,
80
81
/* Number of lines currently used when saving master info file */
82
LINES_IN_MASTER_INFO= LINE_FOR_MASTER_HEARTBEAT_PERIOD
83
};
84
85
86
int init_master_info(Master_info* mi, const char* master_info_fname,
87
const char* slave_info_fname,
88
bool abort_if_no_master_info_file,
89
int thread_mask)
152
int Master_info::init_master_info(const char* master_info_fname,
153
const char* slave_info_fname,
154
bool abort_if_no_master_info_file __attribute__((unused)),
155
int thread_mask)
90
156
{
91
157
int fd,error;
92
158
char fname[FN_REFLEN+128];
93
159
94
if (mi->inited)
160
if (inited)
95
161
{
96
162
/*
97
163
We have to reset read position of relay-log-bin as we may have
107
173
*/
108
174
if (thread_mask & SLAVE_SQL)
109
175
{
110
my_b_seek(mi->rli.cur_log, (my_off_t) 0);
176
my_b_seek(rli.cur_log, (my_off_t) 0);
111
177
}
112
178
return(0);
113
179
}
114
180
115
mi->drizzle=0;
116
mi->file_id=1;
181
drizzle= 0;
182
file_id= 1;
117
183
fn_format(fname, master_info_fname, mysql_data_home, "", 4+32);
118
184
119
185
/*
121
187
keep other threads from reading bogus info
122
188
*/
123
189
124
pthread_mutex_lock(&mi->data_lock);
125
fd = mi->fd;
190
pthread_mutex_lock(&data_lock);
191
fd= -1;
126
192
127
193
/* does master.info exist ? */
128
194
129
195
if (access(fname,F_OK))
130
196
{
131
if (abort_if_no_master_info_file)
132
{
133
pthread_mutex_unlock(&mi->data_lock);
134
return(0);
135
}
136
/*
137
if someone removed the file from underneath our feet, just close
138
the old descriptor and re-create the old file
139
*/
140
if (fd >= 0)
141
my_close(fd, MYF(MY_WME));
142
if ((fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
143
{
144
sql_print_error(_("Failed to create a new master info file (file '%s', errno %d)"), fname, my_errno);
145
goto err;
146
}
147
if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
148
MYF(MY_WME)))
149
{
150
sql_print_error(_("Failed to create a cache on master info file (file '%s')"), fname);
151
goto err;
152
}
153
154
mi->fd = fd;
155
init_master_log_pos(mi);
156
197
/* Write new Master info file here (from fname) */
157
198
}
158
199
else // file exists
159
200
{
160
if (fd >= 0)
161
reinit_io_cache(&mi->file, READ_CACHE, 0L,0,0);
162
else
163
{
164
if ((fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
165
{
166
sql_print_error(_("Failed to open the existing master info file (file '%s', errno %d)"), fname, my_errno);
167
goto err;
168
}
169
if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,
170
0, MYF(MY_WME)))
171
{
172
sql_print_error(_("Failed to create a cache on master info file (file '%s')"), fname);
173
goto err;
174
}
175
}
176
177
mi->fd = fd;
178
int port, connect_retry, master_log_pos, lines;
179
float master_heartbeat_period= 0.0;
180
char *first_non_digit;
181
182
/*
183
Starting from 4.1.x master.info has new format. Now its
184
first line contains number of lines in file. By reading this
185
number we will be always distinguish to which version our
186
master.info corresponds to. We can't simply count lines in
187
file since versions before 4.1.x could generate files with more
188
lines than needed.
189
If first line doesn't contain a number or contain number less than
190
LINES_IN_MASTER_INFO_WITH_SSL then such file is treated like file
191
from pre 4.1.1 version.
192
There is no ambiguity when reading an old master.info, as before
193
4.1.1, the first line contained the binlog's name, which is either
194
empty or has an extension (contains a '.'), so can't be confused
195
with an integer.
196
197
So we're just reading first line and trying to figure which version
198
is this.
199
*/
200
201
/*
202
The first row is temporarily stored in mi->master_log_name,
203
if it is line count and not binlog name (new format) it will be
204
overwritten by the second row later.
205
*/
206
if (init_strvar_from_file(mi->master_log_name,
207
sizeof(mi->master_log_name), &mi->file,
208
""))
209
goto errwithmsg;
210
211
lines= strtoul(mi->master_log_name, &first_non_digit, 10);
212
213
if (mi->master_log_name[0]!='\0' &&
214
*first_non_digit=='\0' && lines >= LINES_IN_MASTER_INFO_WITH_SSL)
215
{
216
/* Seems to be new format => read master log name from next line */
217
if (init_strvar_from_file(mi->master_log_name,
218
sizeof(mi->master_log_name), &mi->file, ""))
219
goto errwithmsg;
220
}
221
else
222
lines= 7;
223
224
if (init_intvar_from_file(&master_log_pos, &mi->file, 4) ||
225
init_strvar_from_file(mi->host, sizeof(mi->host), &mi->file, 0) ||
226
init_strvar_from_file(mi->user, sizeof(mi->user), &mi->file, "test") ||
227
init_strvar_from_file(mi->password, SCRAMBLED_PASSWORD_CHAR_LENGTH+1,
228
&mi->file, 0 ) ||
229
init_intvar_from_file(&port, &mi->file, DRIZZLE_PORT) ||
230
init_intvar_from_file(&connect_retry, &mi->file, DEFAULT_CONNECT_RETRY))
231
goto errwithmsg;
232
233
/*
234
If file has ssl part use it even if we have server without
235
SSL support. But these option will be ignored later when
236
slave will try connect to master, so in this case warning
237
is printed.
238
*/
239
if (lines >= LINES_IN_MASTER_INFO_WITH_SSL)
240
{
241
/*
242
Starting from 6.0 master_heartbeat_period might be
243
in the file
244
*/
245
if (lines >= LINE_FOR_MASTER_HEARTBEAT_PERIOD &&
246
init_floatvar_from_file(&master_heartbeat_period, &mi->file, 0.0))
247
goto errwithmsg;
248
}
249
250
/*
251
This has to be handled here as init_intvar_from_file can't handle
252
my_off_t types
253
*/
254
mi->master_log_pos= (my_off_t) master_log_pos;
255
mi->port= (uint) port;
256
mi->connect_retry= (uint) connect_retry;
257
mi->heartbeat_period= master_heartbeat_period;
201
/* Read Master info file here (from fname) */
258
202
}
259
203
260
mi->rli.mi = mi;
261
if (init_relay_log_info(&mi->rli, slave_info_fname))
204
rli.mi = this;
205
if (init_relay_log_info(&rli, slave_info_fname))
262
206
goto err;
263
207
264
mi->inited = 1;
208
inited = 1;
265
209
// now change cache READ -> WRITE - must do this before flush_master_info
266
reinit_io_cache(&mi->file, WRITE_CACHE, 0L, 0, 1);
267
if ((error=test(flush_master_info(mi, 1))))
210
reinit_io_cache(&file, WRITE_CACHE, 0L, 0, 1);
211
if ((error= test(flush_master_info(1))))
268
212
sql_print_error(_("Failed to flush master info file"));
269
pthread_mutex_unlock(&mi->data_lock);
213
pthread_mutex_unlock(&data_lock);
270
214
return(error);
271
215
272
errwithmsg:
273
sql_print_error(_("Error reading master configuration"));
274
275
216
err:
276
217
if (fd >= 0)
277
218
{
278
219
my_close(fd, MYF(0));
279
end_io_cache(&mi->file);
220
end_io_cache(&file);
280
221
}
281
mi->fd= -1;
282
pthread_mutex_unlock(&mi->data_lock);
222
fd= -1;
223
pthread_mutex_unlock(&data_lock);
283
224
return(1);
284
225
}
285
226
290
231
1 - flush master info failed
291
232
0 - all ok
292
233
*/
293
int flush_master_info(Master_info* mi, bool flush_relay_log_cache)
234
int Master_info::flush_master_info(bool flush_relay_log_cache __attribute__((unused)))
294
235
{
295
IO_CACHE* file = &mi->file;
296
char lbuf[22];
297
298
236
/*
299
237
Flush the relay log to disk. If we don't do it, then the relay log while
300
238
have some part (its last kilobytes) in memory only, so if the slave server
307
245
When we come to this place in code, relay log may or not be initialized;
308
246
the caller is responsible for setting 'flush_relay_log_cache' accordingly.
309
247
*/
310
if (flush_relay_log_cache &&
311
flush_io_cache(mi->rli.relay_log.get_log_file()))
312
return(2);
313
314
/*
315
We flushed the relay log BEFORE the master.info file, because if we crash
316
now, we will get a duplicate event in the relay log at restart. If we
317
flushed in the other order, we would get a hole in the relay log.
318
And duplicate is better than hole (with a duplicate, in later versions we
319
can add detection and scrap one event; with a hole there's nothing we can
320
do).
321
*/
322
323
/*
324
In certain cases this code may create master.info files that seems
325
corrupted, because of extra lines filled with garbage in the end
326
file (this happens if new contents take less space than previous
327
contents of file). But because of number of lines in the first line
328
of file we don't care about this garbage.
329
*/
330
char heartbeat_buf[sizeof(mi->heartbeat_period) * 4]; // buffer to suffice always
331
sprintf(heartbeat_buf, "%.3f", mi->heartbeat_period);
332
my_b_seek(file, 0L);
333
my_b_printf(file,
334
"%u\n%s\n%s\n%s\n%s\n%s\n%d\n%d\n%d\n%s\n",
335
LINES_IN_MASTER_INFO,
336
mi->master_log_name, llstr(mi->master_log_pos, lbuf),
337
mi->host, mi->user,
338
mi->password, mi->port, mi->connect_retry,
339
heartbeat_buf);
340
return(-flush_io_cache(file));
248
249
return 0;
341
250
}
342
251
343
252
344
void end_master_info(Master_info* mi)
253
void Master_info::end_master_info()
345
254
{
346
if (!mi->inited)
255
if (!inited)
347
256
return;
348
end_relay_log_info(&mi->rli);
349
if (mi->fd >= 0)
257
end_relay_log_info(&rli);
258
if (fd >= 0)
350
259
{
351
end_io_cache(&mi->file);
352
(void)my_close(mi->fd, MYF(MY_WME));
353
mi->fd = -1;
260
end_io_cache(&file);
261
(void)my_close(fd, MYF(MY_WME));
262
fd = -1;
354
263
}
355
mi->inited = 0;
264
inited = 0;
356
265
357
266
return;
358
267
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1