Example #1
0
static int dnet_merge_remove_local(struct dnet_node *n, struct dnet_id *id, int full_process)
{
	char buf[sizeof(struct dnet_cmd)];
	struct dnet_cmd *cmd;
	struct dnet_net_state *base;
	int err = -ENOENT;

	memset(buf, 0, sizeof(buf));

	cmd = (struct dnet_cmd *)buf;

	memcpy(&cmd->id, id, sizeof(struct dnet_id));
	cmd->size = 0;

	cmd->cmd = DNET_CMD_DEL;
	if (!full_process)
		cmd->flags = DNET_ATTR_DELETE_HISTORY;

	base = dnet_node_state(n);
	if (base) {
		err = dnet_process_meta(base, cmd, NULL);
		dnet_state_put(base);
	}

	return err;
}
Example #2
0
static int dnet_merge_direct(struct dnet_session *s, struct dnet_meta_container *mc)
{
	struct dnet_node *n = s->node;
	struct dnet_net_state *base;
	int cflags = 0;
	int err;

	dnet_log(n, DNET_LOG_DEBUG, "in dnet_merge_direct mc->size = %u\n", mc->size);
	base = dnet_node_state(n);
	if (!base) {
		err = -ENOENT;
		goto err_out_exit;
	}

	err = n->cb->send(base, n->cb->command_private, &mc->id);
	dnet_log(n, DNET_LOG_DEBUG, "in dnet_merge_direct after n->cb->send err = %d\n\n", err);
	if (err < 0)
		goto err_out_put;

	dnet_log(n, DNET_LOG_DEBUG, "in dnet_merge_direct2 mc->size = %u\n", mc->size);
	err = dnet_write_metadata(s, mc, 0, cflags);
	if (err <= 0)
		goto err_out_put;

	err = 0;

err_out_put:
	dnet_state_put(base);
err_out_exit:
	return err;
}
Example #3
0
	err = dnet_send(send, buf, size);

	free(buf);

err_out_exit:
	return err;
}

static int dnet_cmd_reverse_lookup(struct dnet_net_state *st, struct dnet_cmd *cmd, void *data __unused)
{
	struct dnet_node *n = st->n;
	struct dnet_net_state *base;
	int err = -ENOENT;

	cmd->id.group_id = n->id.group_id;
	base = dnet_node_state(n);
	if (base) {
		err = dnet_send_idc(base, st, &cmd->id, cmd->trans, DNET_CMD_REVERSE_LOOKUP, 1, 0, 0);
		dnet_state_put(base);
	}

	return err;
}

static int dnet_check_connection(struct dnet_node *n, struct dnet_addr_attr *a)
{
	int s;

	s = dnet_socket_create_addr(n, a->sock_type, a->proto, a->family,
			(struct sockaddr *)a->addr.addr, a->addr.addr_len, 0);
	if (s < 0)