← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/replication/rli.h

  • Committer: Brian Aker
  • Date: 2009-01-07 09:27:07 UTC
  • Revision ID: brian@tangent.org-20090107092707-bn67qpdllfcyh3j9
Removing dead field translator code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/replication/rli.h
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#ifndef RPL_RLI_H
 
21
#define RPL_RLI_H
 
22
 
 
23
#include <drizzled/replication/tblmap.h>
 
24
#include <drizzled/replication/reporting.h>
 
25
#include <drizzled/replication/utility.h>
 
26
#include <string>
 
27
 
 
28
struct RPL_TableList;
 
29
class Master_info;
 
30
 
 
31
/****************************************************************************
 
32
 
 
33
  Replication SQL Thread
 
34
 
 
35
  Relay_log_info contains:
 
36
    - the current relay log
 
37
    - the current relay log offset
 
38
    - master log name
 
39
    - master log sequence corresponding to the last update
 
40
    - misc information specific to the SQL thread
 
41
 
 
42
  Relay_log_info is initialized from the slave.info file if such
 
43
  exists.  Otherwise, data members are intialized with defaults. The
 
44
  initialization is done with init_relay_log_info() call.
 
45
 
 
46
  The format of slave.info file:
 
47
 
 
48
  relay_log_name
 
49
  relay_log_pos
 
50
  master_log_name
 
51
  master_log_pos
 
52
 
 
53
  To clean up, call end_relay_log_info()
 
54
 
 
55
*****************************************************************************/
 
56
 
 
57
class Relay_log_info : public Slave_reporting_capability
 
58
{
 
59
public:
 
60
  /**
 
61
     Flags for the state of the replication.
 
62
   */
 
63
  enum enum_state_flag {
 
64
    /** The replication thread is inside a statement */
 
65
    IN_STMT,
 
66
 
 
67
    /** Flag counter.  Should always be last */
 
68
    STATE_FLAGS_COUNT
 
69
  };
 
70
 
 
71
  /*
 
72
    If flag set, then rli does not store its state in any info file.
 
73
    This is the case only when we execute BINLOG SQL commands inside
 
74
    a client, non-replication thread.
 
75
  */
 
76
  bool no_storage;
 
77
 
 
78
  /*
 
79
    If true, events with the same server id should be replicated. This
 
80
    field is set on creation of a relay log info structure by copying
 
81
    the value of ::replicate_same_server_id and can be overridden if
 
82
    necessary. For example of when this is done, check sql_binlog.cc,
 
83
    where the BINLOG statement can be used to execute "raw" events.
 
84
   */
 
85
  bool replicate_same_server_id;
 
86
 
 
87
  /*** The following variables can only be read when protect by data lock ****/
 
88
 
 
89
  /*
 
90
    info_fd - file descriptor of the info file. set only during
 
91
    initialization or clean up - safe to read anytime
 
92
    cur_log_fd - file descriptor of the current read  relay log
 
93
  */
 
94
  File info_fd,cur_log_fd;
 
95
 
 
96
  /*
 
97
    Protected with internal locks.
 
98
    Must get data_lock when resetting the logs.
 
99
  */
 
100
  DRIZZLE_BIN_LOG relay_log;
 
101
  LOG_INFO linfo;
 
102
  IO_CACHE cache_buf,*cur_log;
 
103
 
 
104
  /* The following variables are safe to read any time */
 
105
 
 
106
  /* IO_CACHE of the info file - set only during init or end */
 
107
  IO_CACHE info_file;
 
108
 
 
109
  /*
 
110
    When we restart slave thread we need to have access to the previously
 
111
    created temporary tables. Modified only on init/end and by the SQL
 
112
    thread, read only by SQL thread.
 
113
  */
 
114
  Table *save_temporary_tables;
 
115
 
 
116
  /*
 
117
    standard lock acquistion order to avoid deadlocks:
 
118
    run_lock, data_lock, relay_log.LOCK_log, relay_log.LOCK_index
 
119
  */
 
120
  pthread_mutex_t data_lock,run_lock;
 
121
 
 
122
  /*
 
123
    start_cond is broadcast when SQL thread is started
 
124
    stop_cond - when stopped
 
125
    data_cond - when data protected by data_lock changes
 
126
  */
 
127
  pthread_cond_t start_cond, stop_cond, data_cond;
 
128
 
 
129
  /* parent Master_info structure */
 
130
  Master_info *mi;
 
131
 
 
132
  /*
 
133
    Needed to deal properly with cur_log getting closed and re-opened with
 
134
    a different log under our feet
 
135
  */
 
136
  uint32_t cur_log_old_open_count;
 
137
 
 
138
  /*
 
139
    Let's call a group (of events) :
 
140
      - a transaction
 
141
      or
 
142
      - an autocommiting query + its associated events (INSERT_ID,
 
143
    TIMESTAMP...)
 
144
    We need these rli coordinates :
 
145
    - relay log name and position of the beginning of the group we currently are
 
146
    executing. Needed to know where we have to restart when replication has
 
147
    stopped in the middle of a group (which has been rolled back by the slave).
 
148
    - relay log name and position just after the event we have just
 
149
    executed. This event is part of the current group.
 
150
    Formerly we only had the immediately above coordinates, plus a 'pending'
 
151
    variable, but this dealt wrong with the case of a transaction starting on a
 
152
    relay log and finishing (commiting) on another relay log. Case which can
 
153
    happen when, for example, the relay log gets rotated because of
 
154
    max_binlog_size.
 
155
  */
 
156
  std::string group_relay_log_name;
 
157
  uint64_t group_relay_log_pos;
 
158
  std::string event_relay_log_name;
 
159
  uint64_t event_relay_log_pos;
 
160
  uint64_t future_event_relay_log_pos;
 
161
 
 
162
#ifdef HAVE_purify
 
163
  bool is_fake; /* Mark that this is a fake relay log info structure */
 
164
#endif
 
165
 
 
166
  /*
 
167
     Original log name and position of the group we're currently executing
 
168
     (whose coordinates are group_relay_log_name/pos in the relay log)
 
169
     in the master's binlog. These concern the *group*, because in the master's
 
170
     binlog the log_pos that comes with each event is the position of the
 
171
     beginning of the group.
 
172
  */
 
173
  std::string group_master_log_name;
 
174
  volatile my_off_t group_master_log_pos;
 
175
 
 
176
  /*
 
177
    Handling of the relay_log_space_limit optional constraint.
 
178
    ignore_log_space_limit is used to resolve a deadlock between I/O and SQL
 
179
    threads, the SQL thread sets it to unblock the I/O thread and make it
 
180
    temporarily forget about the constraint.
 
181
  */
 
182
  uint64_t log_space_limit,log_space_total;
 
183
  bool ignore_log_space_limit;
 
184
 
 
185
  /*
 
186
    When it commits, InnoDB internally stores the master log position it has
 
187
    processed so far; the position to store is the one of the end of the
 
188
    committing event (the COMMIT query event, or the event if in autocommit
 
189
    mode).
 
190
  */
 
191
  uint64_t future_group_master_log_pos;
 
192
 
 
193
  time_t last_master_timestamp;
 
194
 
 
195
  void clear_until_condition();
 
196
 
 
197
  /*
 
198
    Needed for problems when slave stops and we want to restart it
 
199
    skipping one or more events in the master log that have caused
 
200
    errors, and have been manually applied by DBA already.
 
201
  */
 
202
  volatile uint32_t slave_skip_counter;
 
203
  volatile uint32_t abort_pos_wait;     /* Incremented on change master */
 
204
  volatile uint32_t slave_run_id;               /* Incremented on slave start */
 
205
  pthread_mutex_t log_space_lock;
 
206
  pthread_cond_t log_space_cond;
 
207
  Session * sql_session;
 
208
  int32_t events_till_abort;
 
209
 
 
210
  /* if not set, the value of other members of the structure are undefined */
 
211
  bool inited;
 
212
  volatile bool abort_slave;
 
213
  volatile uint32_t slave_running;
 
214
 
 
215
  /*
 
216
     Condition and its parameters from START SLAVE UNTIL clause.
 
217
 
 
218
     UNTIL condition is tested with is_until_satisfied() method that is
 
219
     called by exec_relay_log_event(). is_until_satisfied() caches the result
 
220
     of the comparison of log names because log names don't change very often;
 
221
     this cache is invalidated by parts of code which change log names with
 
222
     notify_*_log_name_updated() methods. (They need to be called only if SQL
 
223
     thread is running).
 
224
   */
 
225
 
 
226
  enum {UNTIL_NONE= 0, UNTIL_MASTER_POS, UNTIL_RELAY_POS} until_condition;
 
227
  char until_log_name[FN_REFLEN];
 
228
  uint64_t until_log_pos;
 
229
  /* extension extracted from log_name and converted to int32_t */
 
230
  uint32_t until_log_name_extension;
 
231
  /*
 
232
     Cached result of comparison of until_log_name and current log name
 
233
     -2 means unitialised, -1,0,1 are comarison results
 
234
  */
 
235
  enum
 
236
  {
 
237
    UNTIL_LOG_NAMES_CMP_UNKNOWN= -2, UNTIL_LOG_NAMES_CMP_LESS= -1,
 
238
    UNTIL_LOG_NAMES_CMP_EQUAL= 0, UNTIL_LOG_NAMES_CMP_GREATER= 1
 
239
  } until_log_names_cmp_result;
 
240
 
 
241
  /*
 
242
    trans_retries varies between 0 to slave_transaction_retries and counts how
 
243
    many times the slave has retried the present transaction; gets reset to 0
 
244
    when the transaction finally succeeds. retried_trans is a cumulative
 
245
    counter: how many times the slave has retried a transaction (any) since
 
246
    slave started.
 
247
  */
 
248
  uint32_t trans_retries, retried_trans;
 
249
 
 
250
  /*
 
251
    If the end of the hot relay log is made of master's events ignored by the
 
252
    slave I/O thread, these two keep track of the coords (in the master's
 
253
    binlog) of the last of these events seen by the slave I/O thread. If not,
 
254
    ign_master_log_name_end[0] == 0.
 
255
    As they are like a Rotate event read/written from/to the relay log, they
 
256
    are both protected by rli->relay_log.LOCK_log.
 
257
  */
 
258
  char ign_master_log_name_end[FN_REFLEN];
 
259
  uint64_t ign_master_log_pos_end;
 
260
 
 
261
  Relay_log_info();
 
262
  ~Relay_log_info();
 
263
 
 
264
  /*
 
265
    Invalidate cached until_log_name and group_relay_log_name comparison
 
266
    result. Should be called after any update of group_realy_log_name if
 
267
    there chances that sql_thread is running.
 
268
  */
 
269
  inline void notify_group_relay_log_name_update()
 
270
  {
 
271
    if (until_condition==UNTIL_RELAY_POS)
 
272
      until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
 
273
  }
 
274
 
 
275
  /*
 
276
    The same as previous but for group_master_log_name.
 
277
  */
 
278
  inline void notify_group_master_log_name_update()
 
279
  {
 
280
    if (until_condition==UNTIL_MASTER_POS)
 
281
      until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_UNKNOWN;
 
282
  }
 
283
 
 
284
  inline void inc_event_relay_log_pos()
 
285
  {
 
286
    event_relay_log_pos= future_event_relay_log_pos;
 
287
  }
 
288
 
 
289
  void inc_group_relay_log_pos(uint64_t log_pos,
 
290
                               bool skip_lock=0);
 
291
 
 
292
  int32_t wait_for_pos(Session* session, String* log_name, int64_t log_pos,
 
293
                   int64_t timeout);
 
294
  void close_temporary_tables();
 
295
 
 
296
  /* Check if UNTIL condition is satisfied. See slave.cc for more. */
 
297
  bool is_until_satisfied(my_off_t master_beg_pos);
 
298
  inline uint64_t until_pos()
 
299
  {
 
300
    return ((until_condition == UNTIL_MASTER_POS) ? group_master_log_pos :
 
301
            group_relay_log_pos);
 
302
  }
 
303
 
 
304
  RPL_TableList *tables_to_lock;           /* RBR: Tables to lock  */
 
305
  uint32_t tables_to_lock_count;        /* RBR: Count of tables to lock */
 
306
  table_mapping m_table_map;      /* RBR: Mapping table-id to table */
 
307
 
 
308
  inline table_def *get_tabledef(Table *tbl)
 
309
  {
 
310
    table_def *td= 0;
 
311
    for (TableList *ptr= tables_to_lock; ptr && !td; ptr= ptr->next_global)
 
312
      if (ptr->table == tbl)
 
313
        td= &((RPL_TableList *)ptr)->m_tabledef;
 
314
    return (td);
 
315
  }
 
316
 
 
317
  void cleanup_context(Session *, bool);
 
318
  void clear_tables_to_lock();
 
319
 
 
320
  /*
 
321
    Used by row-based replication to detect that it should not stop at
 
322
    this event, but give it a chance to send more events. The time
 
323
    where the last event inside a group started is stored here. If the
 
324
    variable is zero, we are not in a group (but may be in a
 
325
    transaction).
 
326
   */
 
327
  time_t last_event_start_time;
 
328
 
 
329
  /**
 
330
    Helper function to do after statement completion.
 
331
 
 
332
    This function is called from an event to complete the group by
 
333
    either stepping the group position, if the "statement" is not
 
334
    inside a transaction; or increase the event position, if the
 
335
    "statement" is inside a transaction.
 
336
 
 
337
    @param event_log_pos
 
338
    Master log position of the event. The position is recorded in the
 
339
    relay log info and used to produce information for <code>SHOW
 
340
    SLAVE STATUS</code>.
 
341
 
 
342
    @param event_creation_time
 
343
    Timestamp for the creation of the event on the master side. The
 
344
    time stamp is recorded in the relay log info and used to compute
 
345
    the <code>Seconds_behind_master</code> field.
 
346
  */
 
347
  void stmt_done(my_off_t event_log_pos,
 
348
                 time_t event_creation_time);
 
349
 
 
350
 
 
351
  /**
 
352
     Set the value of a replication state flag.
 
353
 
 
354
     @param flag Flag to set
 
355
   */
 
356
  void set_flag(enum_state_flag flag)
 
357
  {
 
358
    m_flags |= (1UL << flag);
 
359
  }
 
360
 
 
361
  /**
 
362
     Get the value of a replication state flag.
 
363
 
 
364
     @param flag Flag to get value of
 
365
 
 
366
     @return @c true if the flag was set, @c false otherwise.
 
367
   */
 
368
  bool get_flag(enum_state_flag flag)
 
369
  {
 
370
    return m_flags & (1UL << flag);
 
371
  }
 
372
 
 
373
  /**
 
374
     Clear the value of a replication state flag.
 
375
 
 
376
     @param flag Flag to clear
 
377
   */
 
378
  void clear_flag(enum_state_flag flag)
 
379
  {
 
380
    m_flags &= ~(1UL << flag);
 
381
  }
 
382
 
 
383
  /**
 
384
     Is the replication inside a group?
 
385
 
 
386
     Replication is inside a group if either:
 
387
     - The OPTION_BEGIN flag is set, meaning we're inside a transaction
 
388
     - The RLI_IN_STMT flag is set, meaning we're inside a statement
 
389
 
 
390
     @retval true Replication thread is currently inside a group
 
391
     @retval false Replication thread is currently not inside a group
 
392
   */
 
393
  bool is_in_group() const;
 
394
 
 
395
private:
 
396
  uint32_t m_flags;
 
397
};
 
398
 
 
399
 
 
400
// Defined in rpl_rli.cc
 
401
int32_t init_relay_log_info(Relay_log_info* rli, const char* info_fname);
 
402
 
 
403
 
 
404
#endif /* RPL_RLI_H */