Exemple #1
0
static int notify_complete(struct dnet_net_state *state,
			struct dnet_cmd *cmd,
			void *priv)
{
	struct dnet_io_notification *io;
	char str[64];
	struct tm tm;
	struct timeval tv;
	FILE *stream = priv;

	if (is_trans_destroyed(state, cmd))
		return 0;

	if (cmd->size != sizeof(struct dnet_io_notification))
		return 0;

	gettimeofday(&tv, NULL);
	localtime_r((time_t *)&tv.tv_sec, &tm);
	strftime(str, sizeof(str), "%F %R:%S", &tm);

	fprintf(stream, "%s.%06lu : ", str, (unsigned long)tv.tv_usec);

	io = (struct dnet_io_notification *)(cmd + 1);

	dnet_convert_io_notification(io);

	fprintf(stream, "%s: client: %s, size: %llu, offset: %llu, flags: %x\n",
			dnet_dump_id_str(io->io.id), dnet_server_convert_dnet_addr(&io->addr.addr),
			(unsigned long long)io->io.size,
			(unsigned long long)io->io.offset, io->io.flags);
	fflush(stream);

	return 0;
}
Exemple #2
0
void iterate_node(Ctx &ctx, const dnet_addr &node) {
	std::cout << "Iterating node: " << dnet_server_convert_dnet_addr(const_cast<dnet_addr*>(&node)) << ":" << node.family << std::endl;
	std::vector<dnet_iterator_range> ranges;
	if (ctx.iflags & DNET_IFLAGS_KEY_RANGE)
		ranges.push_back(ctx.key_range);

	dnet_id id;
	bool found = false;
	for (auto it = ctx.routes.begin(), end = ctx.routes.end(); it != end; ++it) {
		if (dnet_addr_equal(&it->second, const_cast<dnet_addr*>(&node))) {
			id = it->first;
			found = true;
			break;
		}
	}

	if (!found) {
		std::cerr << "Node was'n found in route list" << std::endl;
		return;
	}

	ctx.session->set_groups(std::vector<int>(1, id.group_id));

	auto res = ctx.session->start_iterator(ioremap::elliptics::key(id),
	                                       ranges, DNET_ITYPE_NETWORK,
	                                       ctx.iflags, ctx.time_begin, ctx.time_end);

	char buffer[2*DNET_ID_SIZE + 1] = {0};
	for (auto it = res.begin(), end = res.end(); it != end; ++it) {
		std::cout << "node: "    << dnet_server_convert_dnet_addr(const_cast<dnet_addr*>(&node)) << node.family
		          << ", key: "   << dnet_dump_id_len_raw(it->reply()->key.id, DNET_ID_SIZE, buffer)
		          << ", flags: " << it->reply()->user_flags
		          << ", ts: "    << it->reply()->timestamp.tsec << "/" << it->reply()->timestamp.tnsec
		          << " size: "   << it->reply_data().size()
		          << " data: "   << it->reply_data().to_string()
		          << std::endl;
	}
}
static std::set<std::tuple<std::string, int, uint32_t>> get_unique_hosts(session &sess)
{
	std::vector<dnet_route_entry> routes = sess.get_routes();

	std::set<std::tuple<std::string, int, uint32_t>> unique_hosts;

	for (auto it = routes.begin(); it != routes.end(); ++it) {
		dnet_route_entry &entry = *it;
		std::string addr = dnet_server_convert_dnet_addr(&entry.addr);

		unique_hosts.insert(std::make_tuple(addr, entry.group_id, entry.backend_id));
	}

	return unique_hosts;
}
Exemple #4
0
int dnet_ids_update(int update_local, const char *file, struct dnet_addr *cfg_addrs, char *remotes)
{
	char remote_id[1024];
	sprintf(remote_id, "elliptics_node_ids_%s", dnet_server_convert_dnet_addr(cfg_addrs));

	ioremap::elliptics::file_logger log("/dev/null", 0);
	ioremap::elliptics::node node(log);
	ioremap::elliptics::session session(node);

	session.set_exceptions_policy(ioremap::elliptics::session::no_exceptions);

	std::stringstream remotes_stream;
	remotes_stream << remotes;
	std::string addr;
	while (std::getline(remotes_stream, addr, ' ')) {
		try {
			node.add_remote(addr.c_str());
		} catch(...) {}
	}

	auto routes = session.get_routes();
	std::set<int> groups_set;

	for(auto it = routes.begin(), end = routes.end(); it != end; ++it) {
		groups_set.insert(it->first.group_id);
	}

	session.set_groups(std::vector<int>(groups_set.begin(), groups_set.end()));

	try {
		if (update_local)
			session.read_file(std::string(remote_id), file, 0, 0);
		else
			session.write_file(std::string(remote_id), file, 0, 0, 0);
	} catch(...) {
		return -1;
	}

	return 0;
}
Exemple #5
0
static int dnet_bulk_add_id(struct dnet_node *n, struct dnet_bulk_array *bulk_array, struct dnet_id *id,
				struct dnet_meta_container *mc, struct dnet_check_params *params)
{
	int err = 0;
	struct dnet_bulk_state tmp;
	struct dnet_bulk_state *state = NULL;
	struct dnet_net_state *st = dnet_state_get_first(n, id);
	struct dnet_bulk_id *bulk_id;
	struct dnet_meta_update mu;

	dnet_log(n, DNET_LOG_DEBUG, "BULK: adding ID %s to array\n", dnet_dump_id(id));
	if (!st)
		return -1;

	memcpy(&tmp.addr, &st->addr, sizeof(struct dnet_addr));
	dnet_state_put(st);

	dnet_log(n, DNET_LOG_DEBUG, "BULK: Searching state in states array\n");
	state = bsearch(&tmp, bulk_array->states, bulk_array->num, sizeof(struct dnet_bulk_state), dnet_compare_bulk_state);
	if (!state)
		return -1;

	if (!dnet_get_meta_update(n, mc, &mu))
		return -ENOENT;

	dnet_log(n, DNET_LOG_DEBUG, "BULK: addr = %s state->num = %d\n", dnet_server_convert_dnet_addr(&state->addr), state->num);
	//pthread_mutex_lock(&state->state_lock);
	if (state->num >= DNET_BULK_IDS_SIZE || state->num < 0)
		goto err_out_unlock;

	bulk_id = &state->ids[state->num];
	memset(bulk_id, 0, sizeof(struct dnet_bulk_id));

	memcpy(&bulk_id->id, &id->id, DNET_ID_SIZE);

	dnet_log(n, DNET_LOG_DEBUG, "BULK: ID: %s, last_update->tsec=%llu, last_update->tnsec=%llu, flags=%02llx\n", 
			dnet_dump_id_str(bulk_id->id.id), (unsigned long long)mu.tm.tsec, (unsigned long long)mu.tm.tnsec,
			(unsigned long long)mu.flags);

	dnet_convert_meta_update(&mu);

	memcpy(&bulk_id->last_update, &mu, sizeof(struct dnet_meta_update));

	state->num++;

	dnet_log(n, DNET_LOG_DEBUG, "BULK: addr = %s state->num = %d\n", dnet_server_convert_dnet_addr(&state->addr), state->num);
	if (state->num == DNET_BULK_IDS_SIZE) {
		err = dnet_request_bulk_check(n, state, params);
		state->num = 0;
		if (err)
			goto err_out_unlock;
	}

	//pthread_mutex_unlock(&state->state_lock);

	return 0;

err_out_unlock:
	//pthread_mutex_unlock(&state->state_lock);
	return -2;
}
Exemple #6
0
int dnet_request_bulk_check(struct dnet_node *n, struct dnet_bulk_state *state, struct dnet_check_params *params)
{
	struct dnet_trans_control ctl;
	struct dnet_net_state *st;
	struct dnet_bulk_check_priv *p;
	struct timespec	wait_ts;
	int err;

	p = (struct dnet_bulk_check_priv *)malloc(sizeof(struct dnet_bulk_check_priv));
	if (!p) {
		err = -ENOMEM;
		goto err_out_exit;
	}
	atomic_init(&p->refcnt, 2);
	p->db = params->db;
	dnet_check_temp_db_get(p->db);

	p->w = dnet_wait_alloc(0);
	if (!p->w) {
		err = -ENOMEM;
		goto err_out_free;
	}

	p->group_num = params->group_num;
	p->groups = (int *)malloc(sizeof(int) * params->group_num);
	if (!p->groups) {
		err = -ENOMEM;
		goto err_out_put;
	}
	memcpy(p->groups, params->groups, sizeof(int) * params->group_num);

	memset(&ctl, 0, sizeof(struct dnet_trans_control));

	ctl.cmd = DNET_CMD_LIST;
	ctl.complete = dnet_bulk_check_complete;
	ctl.priv = p;
	ctl.cflags = DNET_FLAGS_NEED_ACK | DNET_FLAGS_NOLOCK | DNET_ATTR_BULK_CHECK;

	ctl.data = state->ids;
	ctl.size = sizeof(struct dnet_bulk_id) * state->num;

	st = dnet_state_search_by_addr(n, &state->addr);
	if (!st) {
		err = -ENOENT;
		goto err_out_put;
	}
	dnet_setup_id(&ctl.id, st->idc->group->group_id, st->idc->ids[0].raw.id);
	dnet_wait_get(p->w);

	dnet_log(n, DNET_LOG_DEBUG, "BULK: sending %u bytes of data to %s (%s)\n",
			ctl.size, dnet_dump_id(&ctl.id), dnet_server_convert_dnet_addr(&state->addr));
	err = dnet_trans_alloc_send_state(st, &ctl);
	dnet_state_put(st);

	wait_ts = n->wait_ts;
	wait_ts.tv_sec *= DNET_BULK_IDS_SIZE;
	err = dnet_wait_event(p->w, p->w->cond != 0, &wait_ts);
	if (err)
		goto err_out_put;

	if (p->w->status) {
		err = p->w->status;
		goto err_out_put;
	}

	dnet_wait_put(p->w);

	if (atomic_dec_and_test(&p->refcnt)) {
		free(p->groups);
		free(p);
	}

	return 0;

err_out_put:
	dnet_wait_put(p->w);

err_out_free:
	if (atomic_dec_and_test(&p->refcnt)) {
		free(p->groups);
		free(p);
	}

err_out_exit:
	dnet_log(n, DNET_LOG_ERROR, "Bulk check exited with status %d\n", err);
	return err;
}