← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/repl_failsafe.cc

  • Committer: Monty Taylor
  • Date: 2008-09-15 17:24:04 UTC
  • Revision ID: monty@inaugust.com-20080915172404-ygh6hiyu0q7qpa9x
Removed strndup calls.

Show diffs side-by-side

added added

removed removed

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