/*
* DESCRIPTION
* send slave dump cmd
* format : slave.info\n,filter.tables,\0ringbuf_sleep_usec(binary)
* eaxmplae : /data/mysql-bin.00001,0\n,test.test,\01000(binary)
*
*
*/
static int rs_send_dumpcmd(rs_slave_info_t *si)
{
int32_t l;
ssize_t n;
l = rs_strlen(si->dump_info) + 2 + rs_strlen(si->filter_tables) + 2 + 4;
char buf[4 + l], *p;
p = buf;
p = rs_cpymem(buf, &l, 4);
if(snprintf(p, l + 1, "%s\n,%s,%c", si->dump_info, si->filter_tables, 0)
< 0)
{
rs_log_error(RS_LOG_ERR, rs_errno, "snprintf() failed");
return RS_ERR;
}
rs_memcpy(p + l - 4, &(si->rb_esusec), 4);
n = rs_write(si->svr_fd, buf, 4 + l);
if(n != 4 + l) {
return RS_ERR;
}
return RS_OK;
}
char *rs_strerror(rs_err_t err, char *errstr, size_t size)
{
char *msg;
msg = ((uint32_t) err < RS_SYS_NERR) ? rs_sys_errlist[err]
: rs_unknown_error; // not modify
size = rs_min(size, rs_strlen(msg));
return rs_cpymem(errstr, msg, size);
}
int rs_binlog_create_data(rs_reqdump_data_t *rd)
{
int r, len;
char istr[UINT32_LEN + 1], *p;
rs_binlog_info_t *bi;
rs_ringbuf_data_t *rbd;
bi = &(rd->binlog_info);
p = NULL;
if(bi->mev == 0) {
if(bi->skip_n++ % RS_SKIP_DATA_FLUSH_NUM != 0) {
bi->skip_n = 1;
return RS_OK;
}
}
for( ;; ) {
r = rs_ringbuf_set(rd->ringbuf, &rbd);
if(r == RS_FULL) {
sleep(RS_RINGBUF_FSSEC);
continue;
} else if(r == RS_ERR) {
return RS_ERR;
}
/* free memory */
if(rbd->data != NULL) {
rs_pfree(rd->pool, rbd->data, rbd->id);
rs_ringbuf_data_t_init(rbd);
}
/* rs_uint32_to_str(rd->dump_pos, istr); */
len = snprintf(istr, UINT32_LEN + 1, "%u", rd->dump_pos);
len += rs_strlen(rd->dump_file) + 1 + 1 + 1;
if(bi->mev == 0) {
rbd->len = len;
rbd->id = rs_palloc_id(rd->pool, len);
rbd->data = rs_palloc(rd->pool, len, rbd->id);
if(rbd->data == NULL) {
return RS_ERR;
}
len = snprintf(rbd->data, rbd->len, "%s,%s\n%c", rd->dump_file,
istr, bi->mev);
if(len < 0) {
rs_log_error(RS_LOG_ERR, rs_errno, "snprintf() failed");
return RS_ERR;
}
} else {
if(bi->log_format == RS_BINLOG_FORMAT_ROW_BASED) {
/* RBR */
len += bi->el - RS_BINLOG_EVENT_HEADER_LEN
+ rs_strlen(bi->tb) + 3 + rs_strlen(bi->db) + 4 +
bi->cn + 4 + bi->ml;
rbd->len = len;
rbd->id = rs_palloc_id(rd->pool, len);
rbd->data = rs_palloc(rd->pool, len, rbd->id);
if(rbd->data == NULL) {
return RS_ERR;
}
len = snprintf(rbd->data, rbd->len,
"%s,%u\n%c,%s.%s%c",
rd->dump_file, rd->dump_pos, bi->mev, bi->db,
bi->tb, 0);
if(len < 0) {
rs_log_error(RS_LOG_ERR, rs_errno, "snprintf() failed");
return RS_ERR;
}
p = (char *) rbd->data + len;
p = rs_cpymem(p, &(bi->cn), 4);
p = rs_cpymem(p, bi->ct, bi->cn);
p = rs_cpymem(p, &(bi->ml), 4);
p = rs_cpymem(p, bi->cm, bi->ml);
rs_memcpy(p, bi->data, rbd->len - len - 8 - bi->cn -
bi->ml);
}
}
rs_ringbuf_set_advance(rd->ringbuf);
break;
} // EXIT RING BUFFER
bi->flush = 0;
bi->mev = 0;
bi->sent = 1;
return RS_OK;
}
int rs_eof_read_binlog2(rs_reqdump_data_t *rd, void *buf, size_t size)
{
int wd1, wd2, err, r;
size_t ms, n, ls, tl;
ssize_t l;
struct inotify_event *e;
char eb[1024], *p, *f;
n = 0;
wd1 = -1;
wd2 = -2;
f = buf;
r = RS_ERR;
ms = rs_min((uint32_t) (rd->io_buf->last - rd->io_buf->pos), size);
/* use io_buf */
if(ms > 0) {
f = rs_cpymem(f, rd->io_buf->pos, ms);
rd->io_buf->pos += ms;
}
while(ms < size) {
/* feed io_buf */
n = fread(rd->io_buf->start, 1, rd->io_buf->size, rd->binlog_fp);
if(n > 0) {
ls = rs_min(n, size - ms);
f = rs_cpymem(f, rd->io_buf->start, ls);
rd->io_buf->pos = rd->io_buf->start + ls;
rd->io_buf->last = rd->io_buf->start + n;
ms += ls;
} else {
if(feof(rd->binlog_fp) == 0) {
if((err = ferror(rd->binlog_fp)) != 0) {
/* file error */
rs_log_error(RS_LOG_ERR, err, "ferror(\"%s\") failed",
rd->dump_file);
goto free;
}
}
/* set inotify */
if(rd->notify_fd == -1) {
rd->notify_fd = rs_init_io_watch();
if(rd->notify_fd < 0) {
goto free;
}
wd1 = rs_add_io_watch(rd->notify_fd, rd->dump_file,
RS_IN_MODIFY);
wd2 = inotify_add_watch(rd->notify_fd,
rs_master_info->binlog_idx_file, RS_IN_MODIFY);
if(wd1 < 0 || wd2 < 0) {
goto free;
}
}
/* test has binlog */
if((err = rs_has_next_binlog(rd)) == RS_OK) {
r = RS_HAS_BINLOG;
goto free;
}
if(err == RS_ERR) {
goto free;
}
/* sleep wait, release cpu */
err = rs_timed_select(rd->notify_fd, RS_BINLOG_EOF_WAIT_SEC, 0);
if(err == RS_ERR) {
goto free;
} else if(err == RS_TIMEDOUT) {
continue;
}
l = rs_read(rd->notify_fd, eb, 1024);
if(l <= 0) {
goto free;
}
p = eb;
e = (struct inotify_event *) eb;
if(e == NULL) {
goto free;
}
while (((char *) e - eb) < l) {
if (e->wd == wd1 && e->mask & RS_IN_MODIFY) {
break;
} else if(e->wd == wd2 && e->mask & RS_IN_MODIFY) {
break;
}
tl = sizeof(struct inotify_event) + e->len;
e = (struct inotify_event *) (p + tl);
if(e == NULL) {
break;
}
p += tl;
} // end while
}
}
r = RS_OK;
clearerr(rd->binlog_fp);
free:
if(rd->notify_fd != -1) {
if(close(rd->notify_fd) != 0) {
rs_log_error(RS_LOG_ERR, rs_errno, "close() failed");
r = RS_ERR;
}
rd->notify_fd = -1;
}
return r;
}
