← 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-10-08 07:48:37 UTC
  • Revision ID: brian@tangent.org-20081008074837-fl4pbrupvvtolezn
Wrote out master.info (more of it). Add to this more private'izing of
Master_Info object.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/rpl_mi.cc
35
35
  host[0] = 0; user[0] = 0; password[0] = 0;
36
36
  io_thd= NULL;
37
37
  port= DRIZZLE_PORT;
38
 
  fd= -1,
39
38
 
40
 
  memset(&file, 0, sizeof(file));
41
39
  pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
42
40
  pthread_mutex_init(&data_lock, MY_MUTEX_INIT_FAST);
43
41
  pthread_cond_init(&data_cond, NULL);
108
106
  return true;
109
107
}
110
108
 
 
109
void Master_info::incrementLogPosition(off_t position)
 
110
{
 
111
  master_log_pos+= position;
 
112
}
 
113
 
111
114
const char *Master_info::getLogName()
112
115
{
113
116
  return master_log_name.c_str();
145
148
                                  bool abort_if_no_master_info_file __attribute__((unused)),
146
149
                                  int thread_mask)
147
150
{
148
 
  int fd,error;
149
 
  char fname[FN_REFLEN+128];
 
151
  int error;
150
152
 
151
153
  if (inited)
152
154
  {
171
173
 
172
174
  drizzle= 0;
173
175
  file_id= 1;
174
 
  fn_format(fname, master_info_fname, mysql_data_home, "", 4+32);
 
176
  {
 
177
    char fname[FN_REFLEN+128];
 
178
 
 
179
    fn_format(fname, master_info_fname, mysql_data_home, "", 4+32);
 
180
    master_info_filename.assign(fname);
 
181
  }
175
182
 
176
183
  /*
177
184
    We need a mutex while we are changing master info parameters to
179
186
  */
180
187
 
181
188
  pthread_mutex_lock(&data_lock);
182
 
  fd= -1;
183
189
 
184
190
  /* does master.info exist ? */
185
191
 
186
 
  if (access(fname,F_OK))
 
192
  if (access(master_info_filename.c_str(), F_OK))
187
193
  {
188
194
    drizzle::MasterList_Record *record;
189
195
 
190
196
    if (abort_if_no_master_info_file)
191
197
    {
192
 
      pthread_mutex_unlock(&mi->data_lock);
 
198
      pthread_mutex_unlock(&data_lock);
193
199
      return 0;
194
200
    }
195
201
 
196
202
    reset();
197
203
 
198
 
    /* Write new Master info file here (from fname) */
 
204
    /* Write new Master info file here (from master_info_filename) */
199
205
    record= list.add_record();
200
206
    record->set_hostname(host);
201
207
    record->set_username(user);
205
211
    record->set_log_name(master_log_name);
206
212
    record->set_log_position(master_log_pos);
207
213
 
208
 
    fstream output(fname, ios::out | ios::trunc | ios::binary);
 
214
    fstream output(master_info_filename.c_str(), ios::out | ios::trunc | ios::binary);
209
215
    if (!list.SerializeToOstream(&output)) 
210
216
    { 
211
217
      assert(0);
214
220
  }
215
221
  else // file exists
216
222
  {
217
 
    /* Read Master info file here (from fname) */
218
 
    fstream input(fname, ios::in | ios::binary);
 
223
    /* Read Master info file here (from master_info_filename) */
 
224
    fstream input(master_info_filename.c_str(), ios::in | ios::binary);
219
225
    if (!list.ParseFromIstream(&input)) 
220
226
    {
221
227
      assert(0);
245
251
    goto err;
246
252
 
247
253
  inited= 1;
248
 
  // now change cache READ -> WRITE - must do this before flush_master_info
249
 
  reinit_io_cache(&file, WRITE_CACHE, 0L, 0, 1);
250
 
  if ((error= test(flush_master_info(1))))
 
254
  if ((error= test(flush())))
251
255
    sql_print_error(_("Failed to flush master info file"));
252
256
  pthread_mutex_unlock(&data_lock);
253
257
  return(error);
254
258
 
255
259
err:
256
 
  if (fd >= 0)
257
 
  {
258
 
    my_close(fd, MYF(0));
259
 
    end_io_cache(&file);
260
 
  }
261
 
  fd= -1;
262
260
  pthread_mutex_unlock(&data_lock);
263
 
  return(1);
 
261
  return 1;
264
262
}
265
263
 
266
264
 
270
268
     1 - flush master info failed
271
269
     0 - all ok
272
270
*/
273
 
int Master_info::flush_master_info(bool flush_relay_log_cache __attribute__((unused)))
 
271
int Master_info::flush()
274
272
{
275
273
  /*
276
274
    Flush the relay log to disk. If we don't do it, then the relay log while
285
283
    the caller is responsible for setting 'flush_relay_log_cache' accordingly.
286
284
  */
287
285
 
 
286
  /* Write Master info file here (from master_info_filename) */
 
287
  assert(master_info_filename.length());
 
288
  assert(list.record_size() == 1);
 
289
  drizzle::MasterList_Record *record= list.mutable_record(0);
 
290
 
 
291
  record->set_hostname(host);
 
292
  record->set_username(user);
 
293
  record->set_password(password);
 
294
  record->set_port(port);
 
295
  record->set_connect_retry(connect_retry);
 
296
  record->set_log_name(master_log_name);
 
297
  record->set_log_position(master_log_pos);
 
298
 
 
299
  fstream output(master_info_filename.c_str(), ios::out | ios::trunc | ios::binary);
 
300
  if (!list.SerializeToOstream(&output)) 
 
301
  { 
 
302
    assert(0);
 
303
    return 1;
 
304
  }
 
305
 
288
306
  return 0;
289
307
}
290
308
 
294
312
  if (!inited)
295
313
    return;
296
314
  end_relay_log_info(&rli);
297
 
  if (fd >= 0)
298
 
  {
299
 
    end_io_cache(&file);
300
 
    (void)my_close(fd, MYF(MY_WME));
301
 
    fd = -1;
302
 
  }
303
315
  inited = 0;
304
316
 
305
317
  return;