« back to all changes in this revision
Viewing changes to drizzled/repl_failsafe.cc
- browse files at revision 486
- compare with another revision
- compare with revision 2422
- download diff
- download tarball
- view history from revision 486
- Committer: Brian Aker
- Date: 2008-10-06 21:06:15 UTC
- Revision ID: brian@tangent.org-20081006210615-65c8oe0wxkpcp6xl
Removed dead repl_failsafe file.
added
removed
drizzled/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
#include <drizzled/server_includes.h>
26
27
#include "repl_failsafe.h"
28
#include "sql_repl.h"
29
#include "rpl_mi.h"
30
#include "rpl_filter.h"
31
#include "log_event.h"
32
33
#define SLAVE_LIST_CHUNK 128
34
#define SLAVE_ERRMSG_SIZE (FN_REFLEN+64)
35
36
37
RPL_STATUS rpl_status=RPL_NULL;
38
pthread_mutex_t LOCK_rpl_status;
39
pthread_cond_t COND_rpl_status;
40
HASH slave_list;
41
42
const char *rpl_role_type[] = {"MASTER","SLAVE",NULL};
43
TYPELIB rpl_role_typelib = {array_elements(rpl_role_type)-1,"",
44
rpl_role_type, NULL};
45
46
const char* rpl_status_type[]=
47
{
48
"AUTH_MASTER","ACTIVE_SLAVE","IDLE_SLAVE", "LOST_SOLDIER","TROOP_SOLDIER",
49
"RECOVERY_CAPTAIN","NULL",NULL
50
};
51
TYPELIB rpl_status_typelib= {array_elements(rpl_status_type)-1,"",
52
rpl_status_type, NULL};
53
54
55
void change_rpl_status(RPL_STATUS from_status, RPL_STATUS to_status)
56
{
57
pthread_mutex_lock(&LOCK_rpl_status);
58
if (rpl_status == from_status || rpl_status == RPL_ANY)
59
rpl_status = to_status;
60
pthread_cond_signal(&COND_rpl_status);
61
pthread_mutex_unlock(&LOCK_rpl_status);
62
}
63
64
65
#define get_object(p, obj, msg) \
66
{\
67
uint32_t len = (uint)*p++; \
68
if (p + len > p_end || len >= sizeof(obj)) \
69
{\
70
errmsg= msg;\
71
goto err; \
72
}\
73
strmake(obj,(char*) p,len); \
74
p+= len; \
75
}\
76
77
78
static inline int cmp_master_pos(Slave_log_event* sev, LEX_MASTER_INFO* mi)
79
{
80
return cmp_master_pos(sev->master_log, sev->master_pos, mi->log_file_name,
81
mi->pos);
82
}
83
84
85
void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
86
{
87
if (thd->server_id)
88
{
89
if (need_mutex)
90
pthread_mutex_lock(&LOCK_slave_list);
91
92
SLAVE_INFO* old_si;
93
if ((old_si = (SLAVE_INFO*)hash_search(&slave_list,
94
(unsigned char*)&thd->server_id, 4)) &&
95
(!only_mine || old_si->thd == thd))
96
hash_delete(&slave_list, (unsigned char*)old_si);
97
98
if (need_mutex)
99
pthread_mutex_unlock(&LOCK_slave_list);
100
}
101
}
102
103
104
/**
105
Register slave in 'slave_list' hash table.
106
107
@return
108
0 ok
109
@return
110
1 Error. Error message sent to client
111
*/
112
113
int register_slave(THD* thd, unsigned char* packet, uint32_t packet_length)
114
{
115
int res;
116
SLAVE_INFO *si;
117
unsigned char *p= packet, *p_end= packet + packet_length;
118
const char *errmsg= "Wrong parameters to function register_slave";
119
120
if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
121
goto err2;
122
123
thd->server_id= si->server_id= uint4korr(p);
124
p+= 4;
125
get_object(p,si->host, "Failed to register slave: too long 'report-host'");
126
get_object(p,si->user, "Failed to register slave: too long 'report-user'");
127
get_object(p,si->password, "Failed to register slave; too long 'report-password'");
128
if (p+10 > p_end)
129
goto err;
130
si->port= uint2korr(p);
131
p += 2;
132
si->rpl_recovery_rank= uint4korr(p);
133
p += 4;
134
if (!(si->master_id= uint4korr(p)))
135
si->master_id= server_id;
136
si->thd= thd;
137
138
pthread_mutex_lock(&LOCK_slave_list);
139
unregister_slave(thd,0,0);
140
res= my_hash_insert(&slave_list, (unsigned char*) si);
141
pthread_mutex_unlock(&LOCK_slave_list);
142
return res;
143
144
err:
145
free(si);
146
my_message(ER_UNKNOWN_ERROR, errmsg, MYF(0)); /* purecov: inspected */
147
err2:
148
return 1;
149
}
150
151
extern "C" uint32_t
152
*slave_list_key(SLAVE_INFO* si, size_t *len,
153
bool not_used __attribute__((unused)))
154
{
155
*len = 4;
156
return &si->server_id;
157
}
158
159
extern "C" void slave_info_free(void *s)
160
{
161
free(s);
162
}
163
164
void init_slave_list()
165
{
166
hash_init(&slave_list, system_charset_info, SLAVE_LIST_CHUNK, 0, 0,
167
(hash_get_key) slave_list_key, (hash_free_key) slave_info_free, 0);
168
pthread_mutex_init(&LOCK_slave_list, MY_MUTEX_INIT_FAST);
169
}
170
171
void end_slave_list()
172
{
173
/* No protection by a mutex needed as we are only called at shutdown */
174
if (hash_inited(&slave_list))
175
{
176
hash_free(&slave_list);
177
pthread_mutex_destroy(&LOCK_slave_list);
178
}
179
}
180
181
182
bool show_slave_hosts(THD* thd)
183
{
184
List<Item> field_list;
185
Protocol *protocol= thd->protocol;
186
187
field_list.push_back(new Item_return_int("Server_id", 10,
188
DRIZZLE_TYPE_LONG));
189
field_list.push_back(new Item_empty_string("Host", 20));
190
if (opt_show_slave_auth_info)
191
{
192
field_list.push_back(new Item_empty_string("User",20));
193
field_list.push_back(new Item_empty_string("Password",20));
194
}
195
field_list.push_back(new Item_return_int("Port", 7, DRIZZLE_TYPE_LONG));
196
field_list.push_back(new Item_return_int("Rpl_recovery_rank", 7,
197
DRIZZLE_TYPE_LONG));
198
field_list.push_back(new Item_return_int("Master_id", 10,
199
DRIZZLE_TYPE_LONG));
200
201
if (protocol->send_fields(&field_list,
202
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
203
return(true);
204
205
pthread_mutex_lock(&LOCK_slave_list);
206
207
for (uint32_t i = 0; i < slave_list.records; ++i)
208
{
209
SLAVE_INFO* si = (SLAVE_INFO*) hash_element(&slave_list, i);
210
protocol->prepare_for_resend();
211
protocol->store((uint32_t) si->server_id);
212
protocol->store(si->host, &my_charset_bin);
213
if (opt_show_slave_auth_info)
214
{
215
protocol->store(si->user, &my_charset_bin);
216
protocol->store(si->password, &my_charset_bin);
217
}
218
protocol->store((uint32_t) si->port);
219
protocol->store((uint32_t) si->rpl_recovery_rank);
220
protocol->store((uint32_t) si->master_id);
221
if (protocol->write())
222
{
223
pthread_mutex_unlock(&LOCK_slave_list);
224
return(true);
225
}
226
}
227
pthread_mutex_unlock(&LOCK_slave_list);
228
my_eof(thd);
229
return(false);
230
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1