← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/repl_failsafe.cc

  • Committer: Monty Taylor
  • Date: 2008-10-16 06:32:30 UTC
  • mto: (511.1.5 codestyle)
  • mto: This revision was merged to the branch mainline in revision 521.
  • Revision ID: monty@inaugust.com-20081016063230-4brxsra0qsmsg84q
Added -Wunused-macros.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/repl_failsafe.cc
1
 
/* Copyright (C) 2001-2006 MySQL AB & Sasha
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
/**
17
 
  @file
18
 
 
19
 
  All of the functions defined in this file which are not used (the ones to
20
 
  handle failsafe) are not used; their code has not been updated for more
21
 
  than one year now so should be considered as BADLY BROKEN. Do not enable
22
 
  it. The used functions (to handle LOAD DATA FROM MASTER, plus some small
23
 
  functions like register_slave()) are working.
24
 
*/
25
 
 
26
 
#include "mysql_priv.h"
27
 
#ifdef HAVE_REPLICATION
28
 
 
29
 
#include "repl_failsafe.h"
30
 
#include "sql_repl.h"
31
 
#include "slave.h"
32
 
#include "rpl_mi.h"
33
 
#include "rpl_filter.h"
34
 
#include "log_event.h"
35
 
 
36
 
#define SLAVE_LIST_CHUNK 128
37
 
#define SLAVE_ERRMSG_SIZE (FN_REFLEN+64)
38
 
 
39
 
 
40
 
RPL_STATUS rpl_status=RPL_NULL;
41
 
pthread_mutex_t LOCK_rpl_status;
42
 
pthread_cond_t COND_rpl_status;
43
 
HASH slave_list;
44
 
 
45
 
const char *rpl_role_type[] = {"MASTER","SLAVE",NullS};
46
 
TYPELIB rpl_role_typelib = {array_elements(rpl_role_type)-1,"",
47
 
                            rpl_role_type, NULL};
48
 
 
49
 
const char* rpl_status_type[]=
50
 
{
51
 
  "AUTH_MASTER","ACTIVE_SLAVE","IDLE_SLAVE", "LOST_SOLDIER","TROOP_SOLDIER",
52
 
  "RECOVERY_CAPTAIN","NULL",NullS
53
 
};
54
 
TYPELIB rpl_status_typelib= {array_elements(rpl_status_type)-1,"",
55
 
                             rpl_status_type, NULL};
56
 
 
57
 
 
58
 
void change_rpl_status(RPL_STATUS from_status, RPL_STATUS to_status)
59
 
{
60
 
  pthread_mutex_lock(&LOCK_rpl_status);
61
 
  if (rpl_status == from_status || rpl_status == RPL_ANY)
62
 
    rpl_status = to_status;
63
 
  pthread_cond_signal(&COND_rpl_status);
64
 
  pthread_mutex_unlock(&LOCK_rpl_status);
65
 
}
66
 
 
67
 
 
68
 
#define get_object(p, obj, msg) \
69
 
{\
70
 
  uint len = (uint)*p++;  \
71
 
  if (p + len > p_end || len >= sizeof(obj)) \
72
 
  {\
73
 
    errmsg= msg;\
74
 
    goto err; \
75
 
  }\
76
 
  strmake(obj,(char*) p,len); \
77
 
  p+= len; \
78
 
}\
79
 
 
80
 
 
81
 
static inline int cmp_master_pos(Slave_log_event* sev, LEX_MASTER_INFO* mi)
82
 
{
83
 
  return cmp_master_pos(sev->master_log, sev->master_pos, mi->log_file_name,
84
 
                        mi->pos);
85
 
}
86
 
 
87
 
 
88
 
void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
89
 
{
90
 
  if (thd->server_id)
91
 
  {
92
 
    if (need_mutex)
93
 
      pthread_mutex_lock(&LOCK_slave_list);
94
 
 
95
 
    SLAVE_INFO* old_si;
96
 
    if ((old_si = (SLAVE_INFO*)hash_search(&slave_list,
97
 
                                           (uchar*)&thd->server_id, 4)) &&
98
 
        (!only_mine || old_si->thd == thd))
99
 
    hash_delete(&slave_list, (uchar*)old_si);
100
 
 
101
 
    if (need_mutex)
102
 
      pthread_mutex_unlock(&LOCK_slave_list);
103
 
  }
104
 
}
105
 
 
106
 
 
107
 
/**
108
 
  Register slave in 'slave_list' hash table.
109
 
 
110
 
  @return
111
 
    0   ok
112
 
  @return
113
 
    1   Error.   Error message sent to client
114
 
*/
115
 
 
116
 
int register_slave(THD* thd, uchar* packet, uint packet_length)
117
 
{
118
 
  int res;
119
 
  SLAVE_INFO *si;
120
 
  uchar *p= packet, *p_end= packet + packet_length;
121
 
  const char *errmsg= "Wrong parameters to function register_slave";
122
 
 
123
 
  if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
124
 
    goto err2;
125
 
 
126
 
  thd->server_id= si->server_id= uint4korr(p);
127
 
  p+= 4;
128
 
  get_object(p,si->host, "Failed to register slave: too long 'report-host'");
129
 
  get_object(p,si->user, "Failed to register slave: too long 'report-user'");
130
 
  get_object(p,si->password, "Failed to register slave; too long 'report-password'");
131
 
  if (p+10 > p_end)
132
 
    goto err;
133
 
  si->port= uint2korr(p);
134
 
  p += 2;
135
 
  si->rpl_recovery_rank= uint4korr(p);
136
 
  p += 4;
137
 
  if (!(si->master_id= uint4korr(p)))
138
 
    si->master_id= server_id;
139
 
  si->thd= thd;
140
 
 
141
 
  pthread_mutex_lock(&LOCK_slave_list);
142
 
  unregister_slave(thd,0,0);
143
 
  res= my_hash_insert(&slave_list, (uchar*) si);
144
 
  pthread_mutex_unlock(&LOCK_slave_list);
145
 
  return res;
146
 
 
147
 
err:
148
 
  my_free(si, MYF(MY_WME));
149
 
  my_message(ER_UNKNOWN_ERROR, errmsg, MYF(0)); /* purecov: inspected */
150
 
err2:
151
 
  return 1;
152
 
}
153
 
 
154
 
extern "C" uint32
155
 
*slave_list_key(SLAVE_INFO* si, size_t *len,
156
 
                bool not_used __attribute__((unused)))
157
 
{
158
 
  *len = 4;
159
 
  return &si->server_id;
160
 
}
161
 
 
162
 
extern "C" void slave_info_free(void *s)
163
 
{
164
 
  my_free(s, MYF(MY_WME));
165
 
}
166
 
 
167
 
void init_slave_list()
168
 
{
169
 
  hash_init(&slave_list, system_charset_info, SLAVE_LIST_CHUNK, 0, 0,
170
 
            (hash_get_key) slave_list_key, (hash_free_key) slave_info_free, 0);
171
 
  pthread_mutex_init(&LOCK_slave_list, MY_MUTEX_INIT_FAST);
172
 
}
173
 
 
174
 
void end_slave_list()
175
 
{
176
 
  /* No protection by a mutex needed as we are only called at shutdown */
177
 
  if (hash_inited(&slave_list))
178
 
  {
179
 
    hash_free(&slave_list);
180
 
    pthread_mutex_destroy(&LOCK_slave_list);
181
 
  }
182
 
}
183
 
 
184
 
 
185
 
bool show_slave_hosts(THD* thd)
186
 
{
187
 
  List<Item> field_list;
188
 
  Protocol *protocol= thd->protocol;
189
 
 
190
 
  field_list.push_back(new Item_return_int("Server_id", 10,
191
 
                                           MYSQL_TYPE_LONG));
192
 
  field_list.push_back(new Item_empty_string("Host", 20));
193
 
  if (opt_show_slave_auth_info)
194
 
  {
195
 
    field_list.push_back(new Item_empty_string("User",20));
196
 
    field_list.push_back(new Item_empty_string("Password",20));
197
 
  }
198
 
  field_list.push_back(new Item_return_int("Port", 7, MYSQL_TYPE_LONG));
199
 
  field_list.push_back(new Item_return_int("Rpl_recovery_rank", 7,
200
 
                                           MYSQL_TYPE_LONG));
201
 
  field_list.push_back(new Item_return_int("Master_id", 10,
202
 
                                           MYSQL_TYPE_LONG));
203
 
 
204
 
  if (protocol->send_fields(&field_list,
205
 
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
206
 
    return(true);
207
 
 
208
 
  pthread_mutex_lock(&LOCK_slave_list);
209
 
 
210
 
  for (uint i = 0; i < slave_list.records; ++i)
211
 
  {
212
 
    SLAVE_INFO* si = (SLAVE_INFO*) hash_element(&slave_list, i);
213
 
    protocol->prepare_for_resend();
214
 
    protocol->store((uint32) si->server_id);
215
 
    protocol->store(si->host, &my_charset_bin);
216
 
    if (opt_show_slave_auth_info)
217
 
    {
218
 
      protocol->store(si->user, &my_charset_bin);
219
 
      protocol->store(si->password, &my_charset_bin);
220
 
    }
221
 
    protocol->store((uint32) si->port);
222
 
    protocol->store((uint32) si->rpl_recovery_rank);
223
 
    protocol->store((uint32) si->master_id);
224
 
    if (protocol->write())
225
 
    {
226
 
      pthread_mutex_unlock(&LOCK_slave_list);
227
 
      return(true);
228
 
    }
229
 
  }
230
 
  pthread_mutex_unlock(&LOCK_slave_list);
231
 
  my_eof(thd);
232
 
  return(false);
233
 
}
234
 
 
235
 
#endif /* HAVE_REPLICATION */
236