static int dnet_check_merge(struct dnet_session *s, struct dnet_meta_container *mc)
{
struct dnet_node *n = s->node;
int err;
struct dnet_meta_container remote_mc;
dnet_log(n, DNET_LOG_DEBUG, "in dnet_check_merge mc->size = %d\n", mc->size);
memset(&remote_mc, 0, sizeof(struct dnet_meta_container));
err = dnet_read_meta(s, &remote_mc, NULL, 0, &mc->id);
if (err) {
if (err != -ENOENT) {
dnet_log_raw(n, DNET_LOG_ERROR, "%s: failed to download object to be merged from storage: %d.\n",
dnet_dump_id(&mc->id), err);
goto err_out_exit;
}
dnet_log_raw(n, DNET_LOG_INFO, "%s: there is no meta in the storage to merge with, "
"doing direct merge (plain upload).\n", dnet_dump_id(&mc->id));
err = dnet_merge_direct(s, mc);
} else {
err = dnet_merge_common(s, &remote_mc, mc);
}
if (err)
goto err_out_exit;
err_out_exit:
if (remote_mc.data)
free(remote_mc.data);
return err;
}
static int dnet_check_find_groups(struct dnet_node *n, struct dnet_meta_container *mc, int **groupsp)
{
int err, i, num;
struct dnet_meta *m;
int *groups;
m = dnet_meta_search(n, mc, DNET_META_GROUPS);
if (!m) {
dnet_log_raw(n, DNET_LOG_ERROR, "%s: failed to find groups metadata.\n", dnet_dump_id(&mc->id));
err = -ENOENT;
goto err_out_exit;
}
groups = malloc(m->size);
if (!groups) {
err = -ENOMEM;
goto err_out_exit;
}
memcpy(groups, m->data, m->size);
num = m->size / sizeof(int32_t);
for (i=0; i<num; ++i) {
dnet_log_raw(n, DNET_LOG_DEBUG, "%s: group: %d\n", dnet_dump_id(&mc->id), groups[i]);
}
*groupsp = groups;
return num;
err_out_exit:
dnet_dump_meta_container(n, mc);
return err;
}
static int dnet_dump_meta_container(struct dnet_node *n, struct dnet_meta_container *mc)
{
int fd, err;
char file[256];
char id_str[DNET_ID_SIZE*2+1];
snprintf(file, sizeof(file), "%s/%s.meta", dnet_check_tmp_dir, dnet_dump_id_len_raw(mc->id.id, DNET_ID_SIZE, id_str));
fd = open(file, O_RDWR | O_TRUNC | O_CREAT | O_CLOEXEC, 0644);
if (fd < 0) {
err = -errno;
dnet_log_raw(n, DNET_LOG_ERROR, "Failed to open meta container file '%s': %s\n",
file, strerror(errno));
goto err_out_exit;
}
err = write(fd, mc->data, mc->size);
if (err != (int)mc->size) {
err = -errno;
dnet_log_raw(n, DNET_LOG_ERROR, "Failed to write meta container into '%s': %s\n",
file, strerror(errno));
goto err_out_close;
}
err = 0;
err_out_close:
close(fd);
err_out_exit:
return err;
}
static int dnet_check_fill(struct dnet_session *s, struct dnet_check_request *r, char *data, int num)
{
struct dnet_node *n = dnet_session_get_node(s);
int i;
char *cur;
struct dnet_id id;
struct dnet_id *rid = (struct dnet_id *)(r + 1);
char tmp_str[DNET_ID_SIZE*2+1];
for (i=0; i<num; ++i) {
cur = strchr(data, '\n');
if (!cur || !*cur)
break;
dnet_transform(s, data, cur - data, &id);
rid[i] = id;
dnet_convert_id(&rid[i]);
dnet_log_raw(n, DNET_LOG_NOTICE, "check: %s\n", dnet_dump_id_len_raw(id.id, DNET_ID_SIZE, tmp_str));
data = cur + 1;
}
return 0;
}
static struct dnet_check_request *dnet_check_gen_request(struct dnet_session *s, struct dnet_check_request *base, char *file)
{
struct dnet_node *n = dnet_session_get_node(s);
struct dnet_check_request *r;
char *data, *cur;
int fd, err, num = 0;
struct stat st;
fd = open(file, O_RDONLY);
if (fd < 0) {
err = -errno;
dnet_log_raw(n, DNET_LOG_ERROR, "check: failed to open check file '%s': %s [%d]\n",
file, strerror(errno), errno);
goto err_out_exit;
}
err = fstat(fd, &st);
if (err < 0) {
err = -errno;
dnet_log_raw(n, DNET_LOG_ERROR, "check: failed to stat check file '%s': %s [%d]\n",
file, strerror(errno), errno);
goto err_out_close;
}
data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (data == MAP_FAILED) {
err = -errno;
dnet_log_raw(n, DNET_LOG_ERROR, "check: failed to map check file '%s': %s [%d]\n",
file, strerror(errno), errno);
goto err_out_close;
}
cur = data;
while (cur && *cur) {
cur = strchr(cur, '\n');
if (!cur)
break;
num++;
cur++;
}
if (!num) {
dnet_log_raw(n, DNET_LOG_NOTICE, "check: check file '%s' is empty: %s [%d]\n",
file, strerror(errno), errno);
}
r = malloc(sizeof(*r) + num * sizeof(struct dnet_id));
if (!r) {
err = -ENOMEM;
goto err_out_unmap;
}
memcpy(r, base, sizeof(*r));
r->obj_num = num;
err = dnet_check_fill(s, r, data, num);
if (err)
goto err_out_free;
munmap(data, st.st_size);
close(fd);
return r;
err_out_free:
free(r);
err_out_unmap:
munmap(data, st.st_size);
err_out_close:
close(fd);
err_out_exit:
return NULL;
}
static int dnet_bulk_check_complete_single(struct dnet_net_state *state, struct dnet_bulk_id *ids,
int remote_group, struct dnet_bulk_check_priv *p)
{
struct dnet_session *s = dnet_session_create(state->n);
struct dnet_meta_container mc;
struct dnet_meta_container temp_mc;
struct dnet_meta_update *mu;
struct dnet_meta *mg;
struct dnet_id id;
char *tmpdata = NULL;
int *groups, group_num = 1;
int err = -EINVAL, error = 0;
int i = 0;
int my_group, lastest_group = -1;
struct dnet_meta_update lastest_mu, my_mu;
struct timeval current_ts;
int removed_in_all = 1, updated = 0;
int lastest = 0;
uint64_t cflags = 0;
uint64_t ioflags = 0;
my_group = state->n->id.group_id;
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: checking ID %s\n", dnet_dump_id_str(ids->id.id));
err = -ENOENT;
error = 0;
dnet_setup_id(&mc.id, my_group, ids->id.id);
err = state->n->cb->meta_read(state->n->cb->command_private, &ids->id, &mc.data);
if (err <= 0) {
if (err == 0)
err = -ENOENT;
goto err_out_continue;
}
mc.size = err;
/* Set current group meta_update as lastest_mu */
if (!dnet_get_meta_update(state->n, &mc, &my_mu)) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: meta_update structure doesn't exist for group %d\n",
dnet_dump_id_str(ids->id.id), my_group);
err = -ENOENT;
goto err_out_kcfree;
}
dnet_convert_meta_update(&my_mu);
memcpy(&lastest_mu, &my_mu, sizeof(struct dnet_meta_update));
lastest_group = my_group;
/* Get group list */
if (p->group_num) {
/* groups came from dnet_check utility */
groups = p->groups;
group_num = p->group_num;
} else {
mg = dnet_meta_search(state->n, &mc, DNET_META_GROUPS);
if (!mg) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: DNET_META_GROUPS structure doesn't exist\n", dnet_dump_id_str(ids->id.id));
err = -ENOENT;
goto err_out_kcfree;
}
dnet_convert_meta(mg);
if (mg->size % sizeof(int)) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: DNET_META_GROUPS structure is corrupted\n", dnet_dump_id_str(ids->id.id));
err = -1;
goto err_out_kcfree;
}
group_num = mg->size / sizeof(int);
groups = (int *)mg->data;
dnet_convert_meta(mg);
}
/* Read temporary meta */
temp_mc.data = malloc(sizeof(struct dnet_meta_update) * group_num);
if (!temp_mc.data) {
err = -ENOMEM;
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: could not allocate memory for temp UPDATE_META\n", dnet_dump_id_str(ids->id.id));
goto err_out_kcfree;
}
memset(temp_mc.data, 0, sizeof(struct dnet_meta_update) * group_num);
temp_mc.size = sizeof(struct dnet_meta_update) * group_num;
err = dnet_db_read_raw(p->db->b, &ids->id, (void **)&tmpdata);
if (err <= 0) {
if (err < 0 && err != -2)
goto err_out_free;
/* No data in temp meta was stored. Placing local meta_update at the beginning */
mu = temp_mc.data;
mu[0].group_id = my_group;
mu[0].tm = my_mu.tm;
mu[0].flags = my_mu.flags;
} else {
if (err > (int)(sizeof(struct dnet_meta_update) * group_num)) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: too many data stored in temp meta\n", dnet_dump_id_str(ids->id.id));
err = -ENOMEM;
goto err_out_free;
}
memcpy(temp_mc.data, tmpdata, err);
}
/* Update temp meta with received group */
mu = temp_mc.data;
updated = 0;
lastest = 0;
for (i = 0; i < group_num; ++i) {
if (mu[i].group_id == remote_group) {
mu[i].tm = ids->last_update.tm;
mu[i].flags = ids->last_update.flags;
updated = 1;
}
if (mu[i].group_id == 0)
break;
if (!(mu[i].flags & DNET_IO_FLAGS_REMOVED))
removed_in_all = 0;
if (((mu[i].tm.tsec > mu[lastest].tm.tsec)
|| ((mu[i].tm.tsec == mu[lastest].tm.tsec) && (mu[i].tm.tnsec > mu[lastest].tm.tnsec)))
&& i != lastest) {
lastest = i;
lastest_group = groups[i];
}
}
if (!updated && i == group_num) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: no space left to save group in temp meta!\n", dnet_dump_id_str(ids->id.id));
err = -ENOMEM;
goto err_out_free;
}
if (!updated) {
mu[i].group_id = remote_group;
mu[i].tm = ids->last_update.tm;
mu[i].flags = ids->last_update.flags;
if (((mu[i].tm.tsec > mu[lastest].tm.tsec)
|| ((mu[i].tm.tsec == mu[lastest].tm.tsec) && (mu[i].tm.tnsec > mu[lastest].tm.tnsec)))
&& i != lastest) {
lastest = i;
lastest_group = groups[i];
}
++i;
}
/* Not all groups processed yet */
if (i < group_num) {
err = 0;
err = dnet_db_write_raw(p->db->b, &ids->id, temp_mc.data, temp_mc.size);
if (err) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: unable to save temp meta, err: %d\n", dnet_dump_id_str(ids->id.id), err);
}
goto err_out_free;
}
/* Check if removal_delay second has gone since object was marked as REMOVED */
if (removed_in_all) {
gettimeofday(¤t_ts, NULL);
if (((uint64_t)current_ts.tv_sec < mu[lastest].tm.tsec)
|| ((uint64_t)current_ts.tv_sec - mu[lastest].tm.tsec) < (uint64_t)(state->n->removal_delay * 3600 * 24))
removed_in_all = 0;
}
/* TODO: receive newer files from remote groups
*
* Yep, we should read it locally and send it to other groups too
*/
if ((lastest_group != my_group) && !(mu[lastest].flags & DNET_IO_FLAGS_REMOVED)) {
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: %s: File on remote group %d is newer, skipping this file\n",
dnet_dump_id_str(ids->id.id), lastest_group);
err = 0;
goto err_out_free;
}
for (i = 0; i < group_num; ++i) {
err = 0;
if (mu[i].group_id == my_group)
continue;
dnet_session_set_groups(s, (int *)&mu[i].group_id, 1);
dnet_setup_id(&id, mu[i].group_id, ids->id.id);
id.type = -1;
if (mu[lastest].flags & DNET_IO_FLAGS_REMOVED) {
if (removed_in_all) {
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: dnet_remove_object_now %s in group %d, err=%d\n",
dnet_dump_id(&id), mu[i].group_id, err);
err = dnet_remove_object_now(s, &id, cflags, ioflags);
} else {
if (!(mu[i].flags & DNET_IO_FLAGS_REMOVED)) {
err = dnet_remove_object(s, &id, NULL, NULL, cflags, ioflags);
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: dnet_remove_object %s in group %d err=%d\n",
dnet_dump_id(&id), mu[i].group_id, err);
}
}
if (err < 0)
goto err_out_cont2;
} else {
if ((mu[i].tm.tsec < mu[lastest].tm.tsec) || ((mu[i].tm.tsec == mu[lastest].tm.tsec) &&
((mu[i].tm.tnsec < mu[lastest].tm.tnsec)))) {
err = state->n->cb->send(state, state->n->cb->command_private, &id);
if (err)
goto err_out_cont2;
err = dnet_meta_update_check_status_raw(state->n, &mc);
if (err)
goto err_out_cont2;
memcpy(&mc.id, &id, sizeof(struct dnet_id));
err = dnet_write_metadata(s, &mc, 1, cflags);
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: dnet_write_metadata %s in group %d, err=%d\n",
dnet_dump_id(&id), my_group, err);
if (err < 0)
goto err_out_cont2;
}
}
err_out_cont2:
if (err < 0)
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: Error during sending transaction to group %d, err=%d\n",
dnet_dump_id_str(ids->id.id), groups[i], err);
if (!error && err < 0)
error = err;
}
if (mu[lastest].flags & DNET_IO_FLAGS_REMOVED) {
if (removed_in_all) {
err = dnet_merge_remove_local(state->n, &mc.id, 0);
} else if (!(my_mu.flags & DNET_IO_FLAGS_REMOVED)) {
err = dnet_merge_remove_local(state->n, &mc.id, 1);
}
}
if (!(mu[lastest].flags & DNET_IO_FLAGS_REMOVED) && !error) {
err = dnet_meta_update_check_status(state->n, &mc);
if (err) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: couldn't update meta CHECK_STATUS\n", dnet_dump_id_str(ids->id.id));
}
}
if (group_num > 2) {
err = dnet_db_remove_raw(p->db->b, &ids->id, 1);
if (!err) {
dnet_log_raw(state->n, DNET_LOG_ERROR, "BULK: %s: DB: failed to remove temp_meta object, err: %d.\n",
dnet_dump_id(&mc.id), err);
}
}
if (error > 0)
error = 0;
err_out_free:
free(temp_mc.data);
err_out_kcfree:
free(mc.data);
if (tmpdata)
free(tmpdata);
err_out_continue:
if (error < 0) {
dnet_log(state->n, DNET_LOG_ERROR, "Failed to check ID %s to %s, err=%d\n", dnet_dump_id_str(ids->id.id),
dnet_state_dump_addr(state), error);
}
if (i == group_num) {
dnet_counter_inc(state->n, DNET_CNTR_NODE_CHECK_COPY, error);
}
return error;
}
