自学教程：C++ GRID_DEBUG函数代码示例

static gboolean_configure_events_queue (struct sqlx_service_s *ss){	if (ss->flag_no_event) {		GRID_DEBUG("Events queue disabled, the service disabled it");		return TRUE;	}	gchar *url =  gridcluster_get_eventagent (SRV.ns_name);	STRING_STACKIFY (url);	if (!url) {		GRID_DEBUG("Events queue disabled, no URL configured");		return TRUE;	}	GError *err = oio_events_queue_factory__create(url, &ss->events_queue);	if (!ss->events_queue) {		GRID_WARN("Events queue creation failure: (%d) %s", err->code, err->message);		return FALSE;	}	GRID_INFO("Event queue ready, connected to [%s]", url);	return TRUE;}

gs_error_t *hc_delete_container(gs_grid_storage_t *hc, struct hc_url_s *url, int force, int flush){	gs_error_t *e = NULL;	gs_container_t *c = NULL;	unsigned int flags = 0;	if (force) flags |= M2V2_DESTROY_FORCE;	// to flush by meta2, but without event generated	//if (flush) flags |= M2V2_DESTROY_FLUSH;	c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, 0, &e);	if(NULL != c) {		// to flush by this process, but with event generated		if (flush) {			if (gs_flush_container(c, &e)) {				GRID_DEBUG("Container flushed/n");		    }		}		// destroy container		if (!e) {			if (gs_destroy_container_flags (c, flags, &e)) {				GRID_DEBUG("Container deleted/n");			}		}		gs_container_free(c);	}	return e;}

static gs_error_t *hc_upload_content(gs_grid_storage_t *hc, struct hc_url_s *url, const char *local_path,		const char *stgpol, const char *sys_metadata, int ac, gboolean is_append){	int in = -1;	struct stat64 s;	gs_container_t *c = NULL;	gs_error_t *e = NULL;	/*init the local path */	if (-1 == stat64(local_path, &s)) {		e = g_malloc0(sizeof(gs_error_t));		e->code = errno;		e->msg = g_strdup_printf("Cannot stat the local file (%s)/n", strerror(errno));		return e;	}	GRID_DEBUG("Local path %s found/n", local_path);	if (-1 == (in = open(local_path, O_RDONLY|O_LARGEFILE))) {		e = g_malloc0(sizeof(gs_error_t));		e->code = errno;		e->msg = g_strdup_printf("Cannot open the local file (%s)/n", strerror(errno));		goto end_put;	}	GRID_DEBUG("Local path %s found and opened/n", local_path);	if(!(c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, ac, &e))) {		g_printerr("Failed to resolve and/or create meta2 entry for reference %s/n",				hc_url_get(url, HCURL_REFERENCE));		goto end_put;	}	/*upload the content */	if (is_append) {		if (!gs_append_content(c, hc_url_get(url, HCURL_PATH), s.st_size, _feed_from_fd, &in, &e)) {			goto end_put;		}	} else {		if (!gs_upload(c, hc_url_get(url, HCURL_PATH), s.st_size, _feed_from_fd,				&in, NULL, sys_metadata, stgpol, &e)) {			goto end_put;		}	}	GRID_INFO("Uploaded a new version of content [%s] in container [%s]/n/n",			hc_url_get(url, HCURL_PATH), hc_url_get(url, HCURL_REFERENCE));	GRID_DEBUG("Content successfully uploaded!/n");end_put:	/** FIXME TODO XXX why not (in >= 0) or (in > -1) ? */	if (in > 1)		metautils_pclose(&in);	if(NULL != c) {		gs_container_free(c);		c = NULL;	}	return e;}

static gboolean_zmq2agent_send_event (time_t now, struct _zmq2agent_ctx_s  *ctx,		struct event_s *evt, const char *dbg){	int rc;	if (ctx->last_error == now) {		GRID_DEBUG("ZMQ2AGENT event delayed, stream paused");		return FALSE;	}	evt->last_sent = now;retry:	rc = zmq_send (ctx->zagent, "", 0, more|ZMQ_DONTWAIT);	if (rc == 0) {		rc = zmq_send (ctx->zagent, evt, HEADER_SIZE, more|ZMQ_DONTWAIT);		if (rc == HEADER_SIZE)			rc = zmq_send (ctx->zagent, evt->message, evt->size, ZMQ_DONTWAIT);	}	if (rc < 0) {		if (EINTR == (rc = zmq_errno ()))			goto retry;		ctx->last_error = evt->last_sent;		GRID_INFO("EVT:ERR %s (%d) %s", dbg, rc, zmq_strerror(rc));		return FALSE;	} else {		++ ctx->q->counter_sent;		ctx->last_error = 0;		GRID_DEBUG("EVT:SNT %s", dbg);		return TRUE;	}}

static int_meta2_filter_check_ns_name(struct gridd_filter_ctx_s *ctx,		struct gridd_reply_ctx_s *reply, int optional){	(void) reply;	TRACE_FILTER();	const struct meta2_backend_s *backend = meta2_filter_ctx_get_backend(ctx);	const char *req_ns = oio_url_get(meta2_filter_ctx_get_url(ctx), OIOURL_NS);	if (!backend || !backend->ns_name[0]) {		GRID_DEBUG("Missing information for namespace checking");		meta2_filter_ctx_set_error(ctx, SYSERR("backend not ready"));		return FILTER_KO;	}	if (!req_ns) {		if (optional)			return FILTER_OK;		GRID_DEBUG("Missing namespace name in request");		meta2_filter_ctx_set_error(ctx, BADREQ("No namespace"));		return FILTER_KO;	}	if (0 != g_ascii_strcasecmp(backend->ns_name, req_ns)) {		meta2_filter_ctx_set_error(ctx, BADNS());		return FILTER_KO;	}	return FILTER_OK;}

/* XXX JFS dupplicated from sqliterepo/sqlite_utils.c */static int_sqlx_exec(sqlite3 *handle, const char *sql){	int rc, grc = SQLITE_OK;	sqlite3_stmt *stmt = NULL;	while ((grc == SQLITE_OK) && sql && *sql) {		const char *next = NULL;		rc = sqlite3_prepare(handle, sql, -1, &stmt, &next);		GRID_DEBUG("sqlite3_prepare(%s) = %d", sql, rc);		sql = next;		if (rc != SQLITE_OK && rc != SQLITE_DONE)			grc = rc;		else {			if (stmt) {				do {					rc = sqlite3_step(stmt);					GRID_DEBUG("sqlite3_step() = %d", rc);				} while (rc == SQLITE_ROW);				if (rc != SQLITE_OK && rc != SQLITE_DONE)					grc = rc;			}		}		if (stmt) {			rc = sqlite3_finalize(stmt);			GRID_DEBUG("sqlite3_finalize() = %d", rc);			stmt = NULL;			if (rc != SQLITE_OK && rc != SQLITE_DONE)				grc = rc;		}	}	return grc;}

static int_meta2_filter_check_ns_name(struct gridd_filter_ctx_s *ctx,		struct gridd_reply_ctx_s *reply, int optional){	(void) reply;	TRACE_FILTER();	const struct meta2_backend_s *backend = meta2_filter_ctx_get_backend(ctx);	const char *req_ns = oio_url_get(meta2_filter_ctx_get_url(ctx), OIOURL_NS);	if (!backend || !backend->ns_name[0]) {		GRID_DEBUG("Missing information for namespace checking");		meta2_filter_ctx_set_error(ctx, NEWERROR(CODE_INTERNAL_ERROR,					"Missing backend information, cannot check namespace"));		return FILTER_KO;	}	if (!req_ns) {		if (optional)			return FILTER_OK;		GRID_DEBUG("Missing namespace name in request");		meta2_filter_ctx_set_error(ctx, NEWERROR(CODE_BAD_REQUEST,					"Bad Request: Missing namespace name information"));		return FILTER_KO;	}	if (0 != g_ascii_strcasecmp(backend->ns_name, req_ns)) {		meta2_filter_ctx_set_error(ctx, NEWERROR(CODE_BAD_REQUEST,					"Request namespace [%s] does not match server namespace [%s]",					req_ns, backend->ns_name));		return FILTER_KO;	}	return FILTER_OK;}

intmeta2_filter_action_has_container(struct gridd_filter_ctx_s *ctx,		struct gridd_reply_ctx_s *reply){	(void) reply;	struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);	struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);	if (!url) {		GRID_WARN("BUG : Checking container's presence : URL not set");		return FILTER_OK;	}	GError *e = meta2_backend_has_container(m2b, url);	if(NULL != e) {		if (e->code == CODE_UNAVAILABLE)			GRID_DEBUG("Container %s exists but could not open it: %s",					hc_url_get(url, HCURL_WHOLE), e->message);		else			GRID_DEBUG("No such container (%s)", hc_url_get(url, HCURL_WHOLE));		if (e->code == CODE_CONTAINER_NOTFOUND) {			hc_decache_reference_service(m2b->resolver, url, META2_TYPE_NAME);		}		meta2_filter_ctx_set_error(ctx, e);		return FILTER_KO;	}	return FILTER_OK;}

GError *network_server_run(struct network_server_s *srv){	struct endpoint_s **pu, *u;	time_t now, last_update;	GError *err = NULL;	/* Sanity checks */	EXTRA_ASSERT(srv != NULL);	for (pu=srv->endpointv; (u = *pu) ;pu++) {		if (u->fd < 0)			return NEWERROR(EINVAL,					"DESIGN ERROR : some servers are not open");	}	if (!srv->flag_continue)		return NULL;	for (pu=srv->endpointv; srv->flag_continue && (u = *pu) ;pu++)		ARM_ENDPOINT(srv, u, EPOLL_CTL_ADD);	ARM_WAKER(srv, EPOLL_CTL_ADD);	_server_start_one_worker(srv, FALSE);	srv->thread_events = g_thread_new("events", _thread_cb_events, srv);	clock_gettime(CLOCK_MONOTONIC_COARSE, &srv->now);	last_update = network_server_bogonow(srv);	while (srv->flag_continue) {		now = network_server_bogonow(srv);		if (last_update < now) {			_server_update_main_stats(srv);			last_update = now;		}		usleep(_start_necessary_threads(srv) ? 50000 : 500000);		clock_gettime(CLOCK_MONOTONIC_COARSE, &srv->now);	}	network_server_close_servers(srv);	/* Wait for all the workers */	while (srv->workers_total) {		GRID_DEBUG("Waiting for %u workers to die", srv->workers_total);		usleep(200000);		clock_gettime(CLOCK_MONOTONIC_COARSE, &srv->now);	}	srv->thread_first_worker = NULL;	/* wait for the first event thread */	if (srv->thread_events) {		g_thread_join(srv->thread_events);		srv->thread_events = NULL;	}	ARM_WAKER(srv, EPOLL_CTL_DEL);	GRID_DEBUG("Server %p exiting its main loop", srv);	return err;}

static gboolean_configure_with_arguments(struct sqlx_service_s *ss, int argc, char **argv){	// Sanity checks	if (ss->sync_mode_solo > SQLX_SYNC_FULL) {		GRID_WARN("Invalid SYNC mode for not-replicated bases");		return FALSE;	}	if (ss->sync_mode_repli > SQLX_SYNC_FULL) {		GRID_WARN("Invalid SYNC mode for replicated bases");		return FALSE;	}	if (!ss->url) {		GRID_WARN("No URL!");		return FALSE;	}	if (!ss->announce) {		ss->announce = g_string_new(ss->url->str);		GRID_DEBUG("No announce set, using endpoint [%s]", ss->announce->str);	}	if (!metautils_url_valid_for_bind(ss->url->str)) {		GRID_ERROR("Invalid URL as a endpoint [%s]", ss->url->str);		return FALSE;	}	if (!metautils_url_valid_for_connect(ss->announce->str)) {		GRID_ERROR("Invalid URL to be announced [%s]", ss->announce->str);		return FALSE;	}	if (argc < 2) {		GRID_ERROR("Not enough options, see usage.");		return FALSE;	}	// Positional arguments	gsize s = g_strlcpy(ss->ns_name, argv[0], sizeof(ss->ns_name));	if (s >= sizeof(ss->ns_name)) {		GRID_WARN("Namespace name too long (given=%"G_GSIZE_FORMAT" max=%u)",				s, (unsigned int)sizeof(ss->ns_name));		return FALSE;	}	GRID_DEBUG("NS configured to [%s]", ss->ns_name);	ss->lb_world = oio_lb_local__create_world();	ss->lb = oio_lb__create();	s = g_strlcpy(ss->volume, argv[1], sizeof(ss->volume));	if (s >= sizeof(ss->volume)) {		GRID_WARN("Volume name too long (given=%"G_GSIZE_FORMAT" max=%u)",				s, (unsigned int) sizeof(ss->volume));		return FALSE;	}	GRID_DEBUG("Volume configured to [%s]", ss->volume);	ss->zk_url = gridcluster_get_zookeeper(ss->ns_name);	return TRUE;}

static voidmonitoring_loop(service_info_t *si){	long jiffies = 0;	GTimer *timer;	GError *error = NULL;	guint proc_count;	timer = g_timer_new();	monitor_get_status(svc_mon, si);	_add_custom_tags(si);	proc_count = supervisor_children_startall(NULL, NULL);	GRID_DEBUG("First started %u processes", proc_count);	while (flag_running) { /* main loop */		if (flag_restart_children) {			if (auto_restart_children) {				supervisor_children_repair(CHILD_KEY);				supervisor_children_enable(CHILD_KEY, TRUE);				proc_count = supervisor_children_startall(NULL,NULL);				GRID_DEBUG("Started %u processes", proc_count);				flag_restart_children = !!proc_count;			} else {				GRID_DEBUG("One of my children died, I will die too (auto_restart_children=%d)", auto_restart_children);				break;			}		}		if (!flag_running)			break;		gdouble elapsed = g_timer_elapsed(timer, NULL);		if (elapsed >= 1.0) {			if (!((++jiffies) % monitor_period)) {				monitor_get_status(svc_mon, si);				_add_custom_tags(si);			}			if (!register_namespace_service(si, &error)) {				GRID_WARN("Failed to register the service: %s", gerror_get_message(error));				g_clear_error(&error);			}			g_timer_reset(timer);			elapsed = 0.0;		}		g_usleep (1000000UL - ((gulong)elapsed));	}	supervisor_children_stopall(4);	supervisor_children_catharsis(NULL, NULL);	g_free(timer);}

gs_error_t *hc_list_contents(gs_grid_storage_t *hc, struct hc_url_s *url, int output_xml, int show_info,		char **result){	gs_error_t *e = NULL;	gs_container_t *c = NULL;	const gchar *snapshot = hc_url_get(url, HCURL_SNAPORVERS);	struct list_content_s lc;	c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, 0, &e);	if (NULL != c) {		GRID_DEBUG("%s found/n", hc_url_get(url, HCURL_REFERENCE));		lc.nb_elts = 0;		lc.xml = output_xml;		lc.show_info = show_info;		lc.buffer = g_string_new("");		lc.listed = NULL;		if(output_xml) {			g_string_append_printf(lc.buffer,					"<Container>/n"					" <Name>%s</Name>/n"					" <Contents>/n",					hc_url_get(url, HCURL_REFERENCE));		} else {			g_string_append_printf(lc.buffer, "#Listing container=[%s]/n", hc_url_get(url, HCURL_REFERENCE));		}		if (!gs_list_container_snapshot(c, NULL, _my_content_filter, &lc,				snapshot, &e)) {			g_printerr("Cannot list %s/n", hc_url_get(url, HCURL_REFERENCE));			g_string_free(lc.buffer, TRUE);		} else {			_sort_listed(&lc);			GRID_DEBUG("%s listed/n", hc_url_get(url, HCURL_REFERENCE));			if(output_xml) {				lc.buffer = g_string_append(lc.buffer,					" </Contents>/n"					"</Container>/n");			} else {				g_string_append_printf(lc.buffer, "#Total in [%s]: %i elements/n",						hc_url_get(url, HCURL_REFERENCE), lc.nb_elts);			}			*result = g_string_free(lc.buffer, FALSE);		}		gs_container_free(c);		return e;	}	g_printerr("Cannot find %s/n", hc_url_get(url, HCURL_REFERENCE));	return e;}

static gpointer_thread_cb_worker(gpointer td){	struct grid_stats_holder_s *local_stats = NULL;	time_t last_update, last_not_idle;	struct network_server_s *srv = td;	metautils_ignore_signals();	_thread_maybe_become_first(srv);	last_update = last_not_idle = network_server_bogonow(srv);	local_stats = grid_stats_holder_init();	GRID_DEBUG("Thread starting for srv %p", srv);	while (srv->flag_continue || srv->cnx_clients > 0) {		struct network_client_s *clt = get_next_client(srv);		if (!clt) {			gboolean expired = network_server_bogonow(srv) >				(last_not_idle + srv->workers_max_idle_delay);			if (expired && _thread_can_die(srv)) {				GRID_DEBUG("Thread idle for too long, exiting!");				goto label_exit;			}		}		else { /* something happened */			EXTRA_ASSERT(clt->server == srv);			_thread_become_active(srv);			last_not_idle = network_server_bogonow(srv);			clt->local_stats = local_stats;			_work_on_client(srv, clt);			_thread_become_inactive(srv);		}		/* periodically merge the local stats in the main stats */		if (last_update < network_server_bogonow(srv)) {			grid_stats_holder_increment_merge(srv->stats, local_stats);			grid_stats_holder_zero(local_stats);			last_update = network_server_bogonow(srv);		}	}	/* thread exiting due to a server stop */	GRID_DEBUG("Thread exiting for srv %p", srv);	_thread_stop(srv);label_exit:	if (local_stats) {		grid_stats_holder_increment_merge(srv->stats, local_stats);		grid_stats_holder_clean(local_stats);	}	return td;}

static gboolean__test_location(gchar *loc, GSList *used_loc, gint64 distance){	GRID_DEBUG("Required distance is %ld", distance);	GSList *l = NULL;	for (l = used_loc; l && l->data; l = l->next) {		gint64 d = distance_between_location(loc, (gchar*) l->data);		GRID_DEBUG("-> found distance %ld", d);		if(d < distance)			return FALSE;	}	return TRUE;}

static service_info_t *_find_matching_rawx(GSList *rawx, GSList *used_loc, gint64 distance,		const gchar *stg_class, GSList **rawx_garbage){	GRID_DEBUG("Searching rawx distant of %"G_GINT64_FORMAT			" with storage class '%s'", distance, stg_class);	GSList *l = NULL;	gchar loc[1024];	struct service_tag_s * loc_tag = NULL;	GRID_DEBUG("Checking for an available rawx in a list of %d elements",			g_slist_length(rawx));	for (l = rawx; l && l->data; l = l->next) {		GRID_DEBUG("Checking one rawx...");		/* ensure service score */		if(((service_info_t*)l->data)->score.value <= 0) {			GRID_DEBUG("Rawx score <= 0");			continue;		}		/* ensure not spotted as unreachable */		if(_is_rawx_in_garbage((service_info_t*)l->data, *rawx_garbage)) {			GRID_DEBUG("Rawx already in unreachable list");			continue;		}		/* check rawx reachable */		if(!is_rawx_reachable((service_info_t*)l->data)) {			GRID_DEBUG("Rawx unreachable");			*rawx_garbage = g_slist_prepend(*rawx_garbage, l->data);			continue;		}		/* check rawx has appropriate storage class (strictly) */		if (!service_info_check_storage_class(l->data, stg_class)) {			GRID_DEBUG(MSG_DONT_MATCH_CRITERIA, "storage class");			continue;		}		/* ensure distance match with our policy */		bzero(loc, sizeof(loc));		loc_tag = service_info_get_tag(((service_info_t*)l->data)->tags, NAME_TAGNAME_RAWX_LOC);		GRID_DEBUG("service tag extracted");		if(!loc_tag) {			if(distance > 1) {				continue;			}			return ((service_info_t*)l->data);		}		service_tag_get_value_string(loc_tag, loc, sizeof(loc), NULL);		if(__test_location(loc, used_loc, distance)) {			return ((service_info_t*)l->data);		} else {			GRID_DEBUG(MSG_DONT_MATCH_CRITERIA, "distance");		}	}	return NULL;}

GError *meta2_filter_ctx_get_error(const struct gridd_filter_ctx_s *ctx){	if(!ctx || !ctx->output_data) {		GRID_DEBUG("uninitialized pointer : %p", ctx);		return NULL;	}	if(NULL != ctx->output_data->error) {		GRID_DEBUG("ctx error : %d, %s", ctx->output_data->error->code, ctx->output_data->error->message);	} else {		GRID_DEBUG("No error found in context");	}	return ctx->output_data->error;}

gs_error_t *hc_delete_content(gs_grid_storage_t *hc, struct hc_url_s *url){	gs_error_t *e = NULL;	gs_container_t *c = NULL;	gs_content_t *content = NULL;	c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE),NULL, 0, &e);	if(NULL != c) {		const gchar *version = hc_url_get(url, HCURL_VERSION);		// First try		content = gs_get_content_from_path_and_version (c, hc_url_get(url, HCURL_PATH), version, &e);		if (content == NULL && e != NULL && e->code == CODE_CONTENT_NOTFOUND && !version) {			// Last version is probably marked deleted, so a "get" without			// version fails. We need to specify we want the latest, even			// if it's deleted, so we can undelete it.			version = HCURL_LATEST_VERSION;			gs_error_free(e);			e = NULL;			// Second try			content = gs_get_content_from_path_and_version (c, hc_url_get(url, HCURL_PATH), version, &e);		}		if (NULL != content) {			if(gs_destroy_content (content, &e)) {				GRID_DEBUG("Content %s deleted/n", hc_url_get(url, HCURL_PATH));			}			gs_content_free(content);		}		gs_container_free(c);	}	return e;}

static int_open_destination(const char *local_path, int force, int *out){	/* Allow everything except execution (umask will apply) */	mode_t file_perms = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IWOTH|S_IROTH;	if (!local_path || !g_ascii_strcasecmp(local_path, "-")) {		*out = 1;	}	else {		*out = open(local_path, O_WRONLY | O_CREAT | (force ? O_TRUNC : O_EXCL),				file_perms);		if (-1 == *out) {			if (errno == ENOENT) {				*out = open(local_path, O_WRONLY | O_CREAT | O_EXCL, file_perms);				if (-1 == *out) {					g_printerr("Cannot create and open the local file %s (%s)/n", local_path,					    strerror(errno));					return 0;				} else {					g_printerr("Local path %s created/n", local_path);				}			} else {				g_printerr("Cannot open the local file %s (%s)/n", local_path, strerror(errno));				return 0;			}		} else {			GRID_DEBUG("Local path %s opened/n", local_path);		}	}	return 1;}

GError*meta1_backend_services_config(struct meta1_backend_s *m1,                              struct oio_url_s *url, const char *packedurl){    struct meta1_service_url_s *m1url;    if (!(m1url = meta1_unpack_url(packedurl)))        return NEWERROR(CODE_BAD_REQUEST, "Invalid URL");    GRID_DEBUG("About to reconfigure [%s] [%"G_GINT64_FORMAT"] [%s] [%s]",               m1url->srvtype, m1url->seq, m1url->host, m1url->args);    struct sqlx_sqlite3_s *sq3 = NULL;    GError *err = _open_and_lock(m1, url, M1V2_OPENBASE_MASTERONLY, &sq3);    if (err) {        g_free(m1url);        return err;    }    struct sqlx_repctx_s *repctx = NULL;    if (!(err = sqlx_transaction_begin(sq3, &repctx))) {        if (!(err = __info_user(sq3, url, FALSE, NULL)))            err = __configure_service(sq3, url, m1url);        if (!(err = sqlx_transaction_end(repctx, err)))            __notify_services_by_cid(m1, sq3, url);    }    sqlx_repository_unlock_and_close_noerror(sq3);    g_free(m1url);    return err;}

/* Clear lines. This just frees and truncates the lines. */voidgrid_clear_lines(struct grid *gd, u_int py, u_int ny){	struct grid_line	*gl;	u_int			 yy;	GRID_DEBUG(gd, "py=%u, ny=%u", py, ny);	if (ny == 0)		return;	if (grid_check_y(gd, py) != 0)		return;	if (grid_check_y(gd, py + ny - 1) != 0)		return;	for (yy = py; yy < py + ny; yy++) {		gl = &gd->linedata[yy];		if (gl->celldata != NULL)			xfree(gl->celldata);		if (gl->utf8data != NULL)			xfree(gl->utf8data);		memset(gl, 0, sizeof *gl);	}}

static struct meta1_service_url_s *__poll_services(struct meta1_backend_s *m1, guint replicas,                struct compound_type_s *ct, guint seq,                struct meta1_service_url_s **used, GError **err){    GRID_DEBUG("Polling %u [%s]", replicas, ct->fulltype);    // ----------------------------------------------------------------------    GPtrArray *ids = g_ptr_array_new_with_free_func(g_free);    oio_location_t *avoid = __locations_from_m1srvurl(used);    oio_location_t *known = NULL;    if (ct->req.k && !strcmp(ct->req.k, NAME_TAGNAME_USER_IS_SERVICE)) {        gchar srvurl[64] = {0};        g_snprintf(srvurl, sizeof(srvurl), "1||%s|", ct->req.v);        struct meta1_service_url_s *inplace[2] = {            meta1_unpack_url(srvurl), NULL        };        /* If ct->req.v is not an addr, known will contain NULL */        // FIXME: this should be in `avoid` instead of `known`        // but avoids are compared without the location mask        known = __locations_from_m1srvurl(inplace);        meta1_service_url_clean(inplace[0]);    }    void _on_id(oio_location_t loc, const char *id)    {        (void)loc;        g_ptr_array_add(ids, g_strdup(id));    }

static GError *_create_on_meta2(const gchar *srv, const gchar *vns, const gchar *cname,		container_id_t cid, struct addr_info_s *m2addr){	gboolean rc;	GError *err = NULL;	GRID_DEBUG("Creation attempt on META2 at [%s]", srv);	if (!srv_to_addr(srv, m2addr))		return g_error_new(gquark_log, 500, "Invalid address (%d %s)",				errno, strerror(errno));	rc = vns && *vns		? meta2_remote_container_create_v2(m2addr, 30000, &err, cid, cname, vns)		: meta2_remote_container_create(m2addr, 30000, &err, cid, cname);	if (!rc) {		if (!err)			return g_error_new(gquark_log, 502,					"Unknown error when contacting META2");		g_prefix_error(&err, "META2 error : ");		return err;	}	return NULL;}

GError*sqlx_remote_execute_DESTROY_many(gchar **targets, GByteArray *sid,		struct sqlx_name_s *name){	(void) sid;	GError *err = NULL;	GByteArray *req = sqlx_pack_DESTROY(name, TRUE);	struct gridd_client_s **clients = gridd_client_create_many(targets, req,			NULL, NULL);	metautils_gba_unref(req);	req = NULL;	if (clients == NULL) {		err = NEWERROR(0, "Failed to create gridd clients");		return err;	}	gridd_clients_start(clients);	err = gridd_clients_loop(clients);	for (struct gridd_client_s **p = clients; !err && p && *p ;p++) {		if (!(err = gridd_client_error(*p)))			continue;		GRID_DEBUG("Database destruction attempts failed: (%d) %s",				err->code, err->message);		if (err->code == CODE_CONTAINER_NOTFOUND || err->code == 404) {			g_clear_error(&err);			continue;		}	}	gridd_clients_free(clients);	return err;}

static gintdo_queryv(struct meta1_service_url_s *surl){	gint rc;	gchar **pq;	struct gridd_client_s *client;	GRID_DEBUG("Contacting SHARD[%"G_GINT64_FORMAT"] at [%s][%s]",			surl->seq, surl->host, surl->args);	client = gridd_client_create_idle(surl->host);	gridd_client_set_keepalive(client, TRUE);	gridd_client_start(client);	rc = 1;	for (pq=query; *pq ;pq++) {		if (!do_query(client, surl, *pq)) {			rc = 0;			break;		}	}	gridd_client_free(client);	return rc;}

static voidallservice_check_start_HT(struct namespace_data_s *ns_data, GHashTable *ht){	gsize offset;	struct taskdata_checksrv_s td_scheme;	GHashTableIter iter_serv;	gpointer k, v;	TRACE_POSITION();	g_hash_table_iter_init(&iter_serv, ht);	while (g_hash_table_iter_next(&iter_serv, &k, &v)) {		struct service_info_s *si = v;		memset(&td_scheme, 0x00, sizeof(td_scheme));		offset = g_snprintf(td_scheme.task_name, sizeof(td_scheme.task_name), "%s.", TASK_ID);		addr_info_to_string(&(si->addr), td_scheme.task_name+offset, sizeof(td_scheme.task_name)-offset);		g_strlcpy(td_scheme.ns_name, ns_data->name, sizeof(td_scheme.ns_name)-1);		if (!_agent_check_enabled(si)) {			GRID_DEBUG("Task [%s] disabled by "					NAME_TAGNAME_AGENT_CHECK, td_scheme.task_name);		} else if (!is_task_scheduled(td_scheme.task_name)) {			GError *error_local = NULL;			task_t *task = NULL;			struct taskdata_checksrv_s *task_data;			TRACE_POSITION();			agent_get_service_key(si, td_scheme.srv_key, sizeof(td_scheme.srv_key));			g_strlcpy(td_scheme.srv_key, (gchar*)k, sizeof(td_scheme.srv_key)-1);			/* prepare the task structure */			task_data = g_memdup(&td_scheme, sizeof(td_scheme));			if (!task_data) {				ERROR("Memory allocation failure");				continue;			}			task = create_task(period_check_services, td_scheme.task_name);			task = set_task_callbacks(task, _check_tcp_service_task,					g_free, task_data);			if (!task) {				ERROR("Memory allocation failure");				continue;			}			/* now start the task! */			if (add_task_to_schedule(task, &error_local))				INFO("Task started: %s", td_scheme.task_name);			else {				ERROR("Failed to add task to scheduler [%s] : %s", td_scheme.task_name, gerror_get_message(error_local));				g_free(task);			}			if (error_local)				g_clear_error(&error_local);		}	}	TRACE_POSITION();}

/* Scroll a region up, moving the top line into the history. */voidgrid_scroll_history_region(struct grid *gd, u_int upper, u_int lower){	struct grid_line	*gl_history, *gl_upper, *gl_lower;	u_int			 yy;	GRID_DEBUG(gd, "upper=%u, lower=%u", upper, lower);	/* Create a space for a new line. */	yy = gd->hsize + gd->sy;	gd->linedata = xrealloc(gd->linedata, yy + 1, sizeof *gd->linedata);	/* Move the entire screen down to free a space for this line. */	gl_history = &gd->linedata[gd->hsize];	memmove(gl_history + 1, gl_history, gd->sy * sizeof *gl_history);	/* Adjust the region and find its start and end. */	upper++;	gl_upper = &gd->linedata[upper];	lower++;	gl_lower = &gd->linedata[lower];	/* Move the line into the history. */	memcpy(gl_history, gl_upper, sizeof *gl_history);	/* Then move the region up and clear the bottom line. */	memmove(gl_upper, gl_upper + 1, (lower - upper) * sizeof *gl_upper);	memset(gl_lower, 0, sizeof *gl_lower);	/* Move the history offset down over the line. */	gd->hsize++;}

/* Clear area. */voidgrid_clear(struct grid *gd, u_int px, u_int py, u_int nx, u_int ny){	u_int	xx, yy;	GRID_DEBUG(gd, "px=%u, py=%u, nx=%u, ny=%u", px, py, nx, ny);	if (nx == 0 || ny == 0)		return;	if (px == 0 && nx == gd->sx) {		grid_clear_lines(gd, py, ny);		return;	}	if (grid_check_y(gd, py) != 0)		return;	if (grid_check_y(gd, py + ny - 1) != 0)		return;	for (yy = py; yy < py + ny; yy++) {		if (px >= gd->linedata[yy].cellsize)			continue;		if (px + nx >= gd->linedata[yy].cellsize) {			gd->linedata[yy].cellsize = px;			continue;		}		for (xx = px; xx < px + nx; xx++) {			if (xx >= gd->linedata[yy].cellsize)				break;			grid_put_cell(gd, xx, yy, &grid_default_cell);		}	}}

int meta2_filter_action_purge_container(struct gridd_filter_ctx_s *ctx,		struct gridd_reply_ctx_s *reply){	(void) reply;	SRVSTUB_PRINTF("packet received...PURGE");	// M2V2_MODE_DRYRUN, ...	guint32 flags = 0;	const char *fstr = NULL;	if (NULL != fstr)		flags = (guint32) g_ascii_strtoull(fstr, NULL, 10);	GSList* del_chunks_list = NULL;	if (NULL != g_err) {		GRID_DEBUG("Container purge failed (%d) : %s", g_err->code, g_err->message);		//meta2_filter_ctx_set_error(ctx, err);		return FILTER_KO;	}	reply->add_body(bean_sequence_marshall(g_responsedata));	reply->send_reply(200, "OK");	_bean_cleanl2(del_chunks_list);	return FILTER_OK;}

/* Move a group of cells. */voidgrid_move_cells(struct grid *gd, u_int dx, u_int px, u_int py, u_int nx){	struct grid_line	*gl;	u_int			 xx;	GRID_DEBUG(gd, "dx=%u, px=%u, py=%u, nx=%u", dx, px, py, nx);	if (nx == 0 || px == dx)		return;	if (grid_check_y(gd, py) != 0)		return;	gl = &gd->linedata[py];	grid_expand_line(gd, py, px + nx);	grid_expand_line(gd, py, dx + nx);	memmove(	    &gl->celldata[dx], &gl->celldata[px], nx * sizeof *gl->celldata);	if (gl->utf8data != NULL) {		grid_expand_line_utf8(gd, py, px + nx);		grid_expand_line_utf8(gd, py, dx + nx);		memmove(&gl->utf8data[dx],		    &gl->utf8data[px], nx * sizeof *gl->utf8data);	}	/* Wipe any cells that have been moved. */	for (xx = px; xx < px + nx; xx++) {		if (xx >= dx && xx < dx + nx)			continue;		grid_put_cell(gd, xx, py, &grid_default_cell);	}}

static int_list_NORMAL(struct gridd_filter_ctx_s *ctx, struct gridd_reply_ctx_s *reply,		struct list_params_s *lp){	GError *e = NULL;	struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);	struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);	struct on_bean_ctx_s *obc = _on_bean_ctx_init(ctx, reply);	if (hc_url_has(url, HCURL_SNAPSHOT)) {		lp->snapshot_name = hc_url_get(url, HCURL_SNAPSHOT);	} else if (hc_url_has(url, HCURL_VERSION)) {		lp->snapshot_name = hc_url_get(url, HCURL_VERSION);	}	e = meta2_backend_list_aliases(m2b, url, lp, _get_cb, obc);	if (NULL != e) {		GRID_DEBUG("Fail to return alias for url: %s",				hc_url_get(url, HCURL_WHOLE));		_on_bean_ctx_clean(obc);		meta2_filter_ctx_set_error(ctx, e);		return FILTER_KO;	}	_on_bean_ctx_send_list(obc, TRUE);	_on_bean_ctx_clean(obc);	return FILTER_OK;}