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

static void_manage_requests(struct gridd_client_pool_s *pool){	struct event_client_s *ec;	EXTRA_ASSERT(pool != NULL);	while (pool->active_count < pool->active_max) {		ec = g_async_queue_try_pop(pool->pending_clients);		if (NULL == ec)			return;		EXTRA_ASSERT(ec->client != NULL);		if (!gridd_client_start(ec->client)) {			GError *err = gridd_client_error(ec->client);			if (NULL != err) {				GRID_WARN("STARTUP Client fd=%d [%s] : (%d) %s",						gridd_client_fd(ec->client), gridd_client_url(ec->client),						err->code, err->message);				g_clear_error(&err);			}			else {				GRID_WARN("STARTUP Client fd=%d [%s] : already started",						gridd_client_fd(ec->client), gridd_client_url(ec->client));				EXTRA_ASSERT(err != NULL);			}			event_client_free(ec);		}		else if (!event_client_monitor(pool, ec))			event_client_free(ec);	}}

static void_manage_prefix(struct meta1_backend_s *m1, guint8 *prefix, sqlite3 *tmpdb){	gchar sql[LIMIT_LENGTH_NSNAME + 128];	int cb(void * u, int nbcols, char **vals, char **cols) {		char *err_msg2 = NULL;		(void) u;		(void) nbcols;		(void) cols;		memset(sql, 0, sizeof(sql));		g_snprintf(sql, sizeof(sql), "UPDATE vns SET size = size + %s "				"WHERE vns = '%s'", vals[1], vals[0]);		GRID_TRACE("_manage_prefix executing [%s]", sql);		if (sqlite3_exec(tmpdb, sql, NULL, NULL, &err_msg2) != SQLITE_OK) {			GRID_WARN("Could not update size for VNS %s: %s", vals[0], err_msg2);		}		sqlite3_free(err_msg2);		err_msg2 = NULL;		if (!sqlite3_changes(tmpdb)) { /* VNS not found */			g_snprintf(sql, sizeof(sql), "INSERT INTO vns (vns,size) "					"VALUES ('%s',%s)", vals[0], vals[1]);			GRID_TRACE("_manage_prefix VNS not found, executing [%s]", sql);			if (sqlite3_exec(tmpdb, sql, NULL, NULL, &err_msg2) != SQLITE_OK) {				GRID_WARN("Could not set size for VNS %s: %s", vals[0], err_msg2);			}			sqlite3_free(err_msg2);		}		return 0;	}

static gboolean_post_config(struct sqlx_service_s *ss){	GError *err = NULL;	if (err != NULL) {		GRID_WARN("%s", err->message);		g_clear_error(&err);		return FALSE;	}	// prepare a meta2 backend	err = meta2_backend_init(&m2, ss->repository, ss->ns_name, ss->lb, ss->resolver);	if (NULL != err) {		GRID_WARN("META2 backend init failure: (%d) %s", err->code, err->message);		g_clear_error(&err);		return FALSE;	}	/* Make deleted bases exit the cache */	sqlx_repository_configure_close_callback(ss->repository, meta2_on_close, ss);	/* Register meta2 requests handlers */	transport_gridd_dispatcher_add_requests(ss->dispatcher,			meta2_gridd_get_v2_requests(), m2);	/* Register few meta2 tasks */	grid_task_queue_register(ss->gtq_reload, 5,			_task_reconfigure_m2, NULL, ss);	grid_task_queue_register(ss->gtq_reload, 1,			(GDestroyNotify)sqlx_task_reload_lb, NULL, ss);	m2->notifier = ss->events_queue;	return TRUE;}

static GError*_check(GList *working_m1list) {	GError *error = NULL;	if ( working_m1list ) {		working_m1list=g_list_sort(working_m1list,meta0_assign_sort_by_score);		struct meta0_assign_meta1_s *hM1 = working_m1list->data;		struct meta0_assign_meta1_s *lM1 = (g_list_last(working_m1list))->data;		guint highscore = hM1->score;		guint lowscore = lM1->score;		GRID_TRACE("check delta highscore %d ,lowscore %d",highscore,lowscore);		if ( (highscore - lowscore) < (context->avgscore * trigger_assignment )/ 100  ) {			GRID_WARN("New assign not necessary, high score %d , low score %d, average %d", highscore, lowscore, context->avgscore);			error = NEWERROR(0, "New assign not necessary");			return error;		}	}	if ( context->lastAssignTime ) {		GRID_TRACE("last time %s",g_date_time_format (context->lastAssignTime,"%Y-%m-%d %H:%M"));		GDateTime *currentTime, *ltime;		currentTime=g_date_time_new_now_local();		ltime = g_date_time_add_minutes(context->lastAssignTime,period_between_two_assign);		GRID_TRACE("currentTime :%s , last time + %d min :%s, comp :%d",g_date_time_format (currentTime,"%Y-%m-%d %H:%M"),period_between_two_assign,g_date_time_format (ltime,"%Y-%m-%d %H:%M"), g_date_time_compare(ltime,currentTime));		if (g_date_time_compare(ltime,currentTime) > 0 ) {			GRID_WARN("delay between two meta1 assign  not respected. Try later. last date [%s]",g_date_time_format (context->lastAssignTime,"%Y-%m-%d %H:%M"));			error = NEWERROR(0,"delay between two meta1 assign  not respected. Try later.");			return error;		}	}	return NULL;}

static GString *_curl_url_prefix (const char *ns, enum _prefix_e which){	if (!ns) {		GRID_WARN ("BUG No namespace configured!");		return NULL;	}	gchar *s = NULL;	if (which == PREFIX_CONSCIENCE)		s = oio_cfg_get_proxy_conscience (ns);	else if (which == PREFIX_CONTAINER)		s = oio_cfg_get_proxy_containers (ns);	else if (which == PREFIX_REFERENCE)		s = oio_cfg_get_proxy_directory (ns);	if (!s)		s = oio_cfg_get_proxy (ns);	if (!s) {		GRID_WARN ("No proxy configured!");		return NULL;	}	GString *hu = g_string_new("http://");	g_string_append (hu, s);	g_free (s);	return hu;}

struct gridd_client_pool_s *gridd_client_pool_create(void){	int fdmon, fd[2];	struct gridd_client_pool_s *pool;	if (0 != pipe(fd)) {		GRID_WARN("pipe() error: (%d) %s", errno, strerror(errno));		metautils_pclose(&(fd[0]));		metautils_pclose(&(fd[1]));		return NULL;	}	if (0 > (fdmon = epoll_create(64))) {		GRID_WARN("epoll_create error: (%d) %s", errno, strerror(errno));		metautils_pclose(&(fd[0]));		metautils_pclose(&(fd[1]));		return NULL;	}	// TODO FIXME factorize this in metautils	struct rlimit limit;	memset(&limit, 0, sizeof(limit));	if (0 != getrlimit(RLIMIT_NOFILE, &limit))		limit.rlim_cur = limit.rlim_max = 32768;	pool = g_malloc0(sizeof(*pool));	pool->pending_clients = g_async_queue_new();	pool->fdmon = fdmon;	pool->active_max = limit.rlim_cur;	pool->active_clients_size = limit.rlim_cur;	pool->active_clients = g_malloc0(pool->active_clients_size			* sizeof(struct event_client_s*));	pool->fd_in = fd[0];	fd[0] = -1;	metautils_syscall_shutdown(pool->fd_in, SHUT_WR);	sock_set_non_blocking(pool->fd_in, TRUE);	pool->fd_out = fd[1];	fd[1] = -1;	metautils_syscall_shutdown(pool->fd_out, SHUT_RD);	sock_set_non_blocking(pool->fd_out, TRUE);	/* then monitors at least the notifications pipe's output */	struct epoll_event ev;	memset(&ev, 0, sizeof(ev));	ev.events = EPOLLIN;	ev.data.fd = pool->fd_in;	if (0 > epoll_ctl(pool->fdmon, EPOLL_CTL_ADD, pool->fd_in, &ev)) {		GRID_ERROR("epoll error: (%d) %s", errno, strerror(errno));		gridd_client_pool_destroy(pool);		return NULL;	}	pool->vtable = &VTABLE;	return pool;}

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;}

voidnetwork_server_clean(struct network_server_s *srv){	if (!srv)		return;	if (srv->thread_events != NULL) {		GRID_WARN("EventThread not joined!");		g_error("EventThread not joined!");	}	if (srv->thread_first_worker) {		GRID_WARN("FirstThread not joined!");		g_error("FirstThread not joined!");	}	g_mutex_clear(&srv->lock_threads);	network_server_close_servers(srv);	if (srv->endpointv) {		struct endpoint_s **u;		for (u=srv->endpointv; *u ;u++)			g_free(*u);		g_free(srv->endpointv);	}	if (srv->stats) {		grid_stats_holder_clean(srv->stats);	}	metautils_pclose(&(srv->wakeup[0]));	metautils_pclose(&(srv->wakeup[1]));	if (srv->queue_monitor) {		g_async_queue_unref(srv->queue_monitor);		srv->queue_monitor = NULL;	}	if (srv->queue_events) {		g_async_queue_unref(srv->queue_events);		srv->queue_events = NULL;	}	if (srv->workers_active_1) {		grid_single_rrd_destroy(srv->workers_active_1);		srv->workers_active_1 = NULL;	}	if (srv->workers_active_60) {		grid_single_rrd_destroy(srv->workers_active_60);		srv->workers_active_60 = NULL;	}	g_free(srv);}

static gboolean_post_config(struct sqlx_service_s *ss){	GError *err;	// Create the backend	m0 = meta0_backend_init(ss->ns_name, ss->url->str, ss->repository);	if (!m0) {		GRID_WARN("META0 backend init failure");		return FALSE;	}	// Create the zookeeper poller	if (ss->zk_url) {		err = zk_srv_manager_create(ss->ns_name, ss->zk_url,				NAME_SRVTYPE_META0, &m0zkmanager);		if (err) {			GRID_WARN("Zk manager init failed : (%d) %s",err->code, err->message);			g_clear_error(&err);			return FALSE;		}		for (;;) {			err = create_zk_node(m0zkmanager, NULL, ss->url->str, ss->url->str);			if (!err)				break;			GRID_DEBUG("Meta0's zookeeper node creation failure : (%d) %s",				err->code, err->message);			g_clear_error(&err);			sleep(1);		}	}	m0disp = meta0_gridd_get_dispatcher(m0, m0zkmanager, ss->ns_name);	transport_gridd_dispatcher_add_requests(ss->dispatcher,			meta0_gridd_get_requests(), m0disp);	meta0_backend_migrate(m0);	meta0_gridd_requested_reload(m0disp);	sqlx_repository_configure_change_callback(ss->repository,			_callback_change, NULL);	grid_task_queue_register(ss->gtq_register, 3,			_task_zk_registration, NULL, ss);	return TRUE;}

static GError *__del_container_properties(struct sqlx_sqlite3_s *sq3, struct oio_url_s *url,		gchar **names){	GError *err = NULL;	gchar **p_name;	if (!names || !*names)		__exec_cid(sq3->db, "DELETE FROM properties WHERE cid = ?", oio_url_get_id(url));	else {		for (p_name=names; !err && p_name && *p_name ;p_name++) {			sqlite3_stmt *stmt = NULL;			gint rc;			sqlite3_prepare_debug(rc, sq3->db, "DELETE FROM properties WHERE cid = ? AND name = ?", -1, &stmt, NULL);			if (rc != SQLITE_OK && rc != SQLITE_DONE)				err = M1_SQLITE_GERROR(sq3->db, rc);			else {				(void) sqlite3_bind_blob(stmt, 1, oio_url_get_id(url), oio_url_get_id_size(url), NULL);				(void) sqlite3_bind_text(stmt, 2, *p_name, strlen(*p_name), NULL);				sqlite3_step_debug_until_end (rc, stmt);				if (rc != SQLITE_DONE)					GRID_WARN("SQLite error rc=%d", rc);				sqlite3_finalize_debug(rc, stmt);			}		}	}	return err;}

GByteArray*sqlx_pack_REPLICATE(struct sqlx_name_s *name, struct TableSequence *tabseq){	GError *err = NULL;	GByteArray *body, *encoded;	MESSAGE req;	EXTRA_ASSERT(name != NULL);	EXTRA_ASSERT(tabseq != NULL);	body = sqlx_encode_TableSequence(tabseq, &err);	if (!body) {		GRID_WARN("Transaction encoding error : (%d) %s",				err->code, err->message);		return NULL;	}	req = make_request("SQLX_REPLICATE", name);	(void) message_set_BODY(req, body->data, body->len, NULL);	encoded = message_marshall_gba(req, NULL);	g_byte_array_free(body, TRUE);	(void) message_destroy(req, NULL);	return encoded;}

static int_create_container(struct gridd_filter_ctx_s *ctx){	struct m2v2_create_params_s params;	struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);	struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);	GError *err = NULL;	int retry = 2;	params.storage_policy = meta2_filter_ctx_get_param(ctx, M2_KEY_STORAGE_POLICY);	params.version_policy = meta2_filter_ctx_get_param(ctx, M2_KEY_VERSION_POLICY);	params.local = (meta2_filter_ctx_get_param(ctx, "LOCAL") != NULL);retry:	err = meta2_backend_create_container(m2b, url, &params);	if (err != NULL && err->code == CODE_REDIRECT && retry-- > 0 &&			!g_strcmp0(err->message, meta2_backend_get_local_addr(m2b))) {		GRID_WARN("Redirecting on myself!?! Retrying request immediately");		g_clear_error(&err);		hc_decache_reference_service(m2b->resolver, url, META2_TYPE_NAME);		goto retry;	}	if (!err)		return FILTER_OK;	meta2_filter_ctx_set_error(ctx, err);	return FILTER_KO;}

GError*meta0_remote_get_meta1_info(const char *m0, gchar ***out){	GError *e = NULL;	gchar **result = NULL;	gboolean on_reply(gpointer c1, MESSAGE reply) {		(void) c1;		gchar **tmpResult = NULL;		if (NULL != (e = metautils_message_extract_body_strv (reply, &tmpResult))) {			GRID_WARN("GetMeta1Info : invalid reply");			g_clear_error (&e);			return FALSE;		}		if (tmpResult) {			guint len,resultlen,i;			gchar **v0;			if ( result != NULL )				resultlen=g_strv_length(result);			else				resultlen=0;			len = g_strv_length(tmpResult);			v0 = g_realloc(result, sizeof(gchar*) * (len + resultlen+1));			for ( i=0; i<len ; i++) {				v0[resultlen+i] = g_strdup(tmpResult[i]);			}			v0[len+resultlen]=NULL;			result = g_strdupv(v0);			g_strfreev(v0);			g_strfreev(tmpResult);		}		return TRUE;	}

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");		meta2_filter_ctx_set_error (ctx, NEWERROR(CODE_BAD_REQUEST, "No URL"));		return FILTER_KO;	}	GError *e = meta2_backend_has_container(m2b, url);	if (NULL != e) {		GRID_DEBUG("Container test error for [%s] : (%d) %s",					hc_url_get(url, HCURL_WHOLE), e->code, e->message);		if (e->code == CODE_CONTAINER_NOTFOUND)			hc_decache_reference_service(m2b->resolver, url, NAME_SRVTYPE_META2);		meta2_filter_ctx_set_error(ctx, e);		return FILTER_KO;	}	return FILTER_OK;}

voidsqlx_task_reload_lb (struct sqlx_service_s *ss){	static volatile gboolean already_succeeded = FALSE;	static volatile guint tick_reload = 0;	static volatile guint period_reload = 1;	EXTRA_ASSERT(ss != NULL);	if (!ss->lb || !ss->nsinfo)		return;	if (already_succeeded && 0 != (tick_reload++ % period_reload))		return;	GError *err = _reload_lbpool(ss->lb, FALSE);	if (!err) {		already_succeeded = TRUE;		period_reload ++;		period_reload = CLAMP(period_reload,2,10);		tick_reload = 1;	} else {		GRID_WARN("Failed to reload the LB pool services: (%d) %s",				err->code, err->message);		g_clear_error(&err);	}	grid_lbpool_reconfigure(ss->lb, ss->nsinfo);}

GError *meta2_json_load_setof_beans(struct json_object *jbeans, GSList **beans){	static gchar* title[] = { "aliases", "headers", "contents", "chunks", NULL };	static jbean_mapper mapper[] = {		m2v2_json_load_single_alias,		m2v2_json_load_single_header,		m2v2_json_load_single_content,		m2v2_json_load_single_chunk	};	GError *err = NULL;	gchar **ptitle;	jbean_mapper *pmapper;	for (ptitle=title,pmapper=mapper; *ptitle ;++ptitle,++pmapper) {		struct json_object *jv = NULL;		if (!json_object_object_get_ex (jbeans, *ptitle, &jv))			continue;		err = _jarray_to_beans(beans, jv, *pmapper);		if (err != NULL) {			GRID_WARN("Parsing error : (%d) %s", err->code, err->message);			break;		}	}	return err;}

static void_task_reload_m2_lb(gpointer p){	ADAPTIVE_PERIOD_DECLARE();	if (!PSRV(p)->nsinfo)		return;	if (ADAPTIVE_PERIOD_SKIP())		return;	oio_lb_world__reload_pools(PSRV(p)->lb_world, PSRV(p)->lb,			PSRV(p)->nsinfo);	/* In meta2, we are only interrested in rawx services */	GSList *svctypes = g_slist_prepend(NULL, NAME_SRVTYPE_RAWX);	GError *err = sqlx_reload_lb_service_types(PSRV(p)->lb_world, PSRV(p)->lb,			svctypes);	if (err) {		GRID_WARN("Failed to reload "NAME_SRVTYPE_RAWX" services: %s",				err->message);		g_clear_error(&err);	} else {		ADAPTIVE_PERIOD_ONSUCCESS(10);	}	g_slist_free(svctypes);	oio_lb_world__reload_storage_policies(PSRV(p)->lb_world,			PSRV(p)->lb, PSRV(p)->nsinfo);	oio_lb_world__debug(PSRV(p)->lb_world);}

static intevent_client_monitor(struct gridd_client_pool_s *pool, struct event_client_s *mc){	int fd, rc, interest;	struct epoll_event ev;	EXTRA_ASSERT(pool != NULL);	EXTRA_ASSERT(mc != NULL);	EXTRA_ASSERT(mc->client != NULL);	memset(&ev, 0, sizeof(ev));	interest = gridd_client_interest(mc->client);	if (interest & CLIENT_RD)		ev.events |= EPOLLIN;	if (interest & CLIENT_WR)		ev.events |= EPOLLOUT;	EXTRA_ASSERT(ev.events != 0);	ev.events |= (EPOLLHUP|EPOLLERR|EPOLLONESHOT);	ev.data.fd = fd = gridd_client_fd(mc->client);	EXTRA_ASSERT(fd >= 0);	rc = epoll_ctl(pool->fdmon, EPOLL_CTL_ADD, fd, &ev);	if (rc < 0) {		pool->active_clients[fd] = NULL;		GRID_WARN("MONITOR error: (%d) %s", errno, strerror(errno));		return 0;	}	pool->active_count ++;	pool->active_clients[fd] = mc;	return 1;}

GError*sqlx_reload_lb_service_types(struct oio_lb_world_s *lbw,		GSList *list_srvtypes){	GError *err = NULL;	struct service_update_policies_s *pols = service_update_policies_create();	gchar *pols_cfg = gridcluster_get_service_update_policy(SRV.nsinfo);	service_update_reconfigure(pols, pols_cfg);	g_free(pols_cfg);	gboolean _reload_srvtype(const gchar *ns, const gchar *srvtype) {		GSList *list_srv = NULL;		err = conscience_get_services(ns, srvtype, FALSE, &list_srv);		if (err) {			GRID_WARN("Gridagent/conscience error: Failed to list the services"					" of type [%s]: code=%d %s", srvtype, err->code,					err->message);			g_clear_error(&err);			return FALSE;		}		oio_lb_world__feed_service_info_list(lbw, list_srv);		oio_lb__force_pool(SRV.lb,				oio_lb_pool__from_service_policy(lbw, srvtype, pols));		g_slist_free_full(list_srv, (GDestroyNotify)service_info_clean);		return TRUE;	}

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;}

voidpeers_restore(gchar **targets, struct sqlx_name_s *name,		GByteArray *dump){	GError *err = NULL;	if (!targets || !targets[0]) {		g_byte_array_unref(dump);		return ;	}	GByteArray *encoded = _pack_RESTORE(name, dump);	struct gridd_client_s **clients = gridd_client_create_many(targets, encoded, NULL, NULL);	g_byte_array_unref(encoded);	gridd_clients_set_timeout(clients, SQLX_RESYNC_TIMEOUT);	gridd_clients_start(clients);	if (!(err = gridd_clients_loop(clients)))		err = gridd_clients_error(clients);	gridd_clients_free(clients);	if (err) {		GRID_WARN("RESTORE failed [%s][%s] : (%d) %s", name->base, name->type,				err->code, err->message);		g_clear_error(&err);	}}

	static void_m1policy_update_thread(gpointer data, gpointer p){	gs_error_t *err = NULL;	GError *gerr=NULL;	gchar **tmp=NULL;	container_id_t cid;	struct thread_user_data_s *user_data = (struct thread_user_data_s *)p;	gchar *base = data;	if(!hex2bin(base, cid, 2, &gerr)) {		GRID_WARN("Invalid prefix: %d %s",gerr->code, gerr->message);		g_clear_error(&gerr);		return;	}	err = _m1policy_update(user_data->action,user_data->ns,TRUE,cid, "meta2", user_data->excludesrv, user_data->checkonly, &tmp);	g_mutex_lock(user_data->lock);	_pack_result(&(user_data->gpa),base, tmp, err, user_data->cpts);	user_data->indexreach ++;	g_mutex_unlock(user_data->lock);	if ( err ) {		gs_error_free(err);		err = NULL;	}	if ( tmp )		g_strfreev (tmp);}

voidmeta0_backend_migrate(struct meta0_backend_s *m0){	GError *err = NULL;	struct sqlx_sqlite3_s *handle=NULL;	struct sqlx_sqlite3_s *oldhandle=NULL;	struct sqlx_name_s n;	n.base = m0->ns;	n.type = NAME_SRVTYPE_META0;	n.ns = m0->ns;	err = sqlx_repository_open_and_lock(m0->repository, &n, SQLX_OPEN_LOCAL, &handle, NULL);	if ( err )	{		// check if the erreur message is the ENOENT message ; DB doesn't exist		if  (  (strstr(err->message, strerror(ENOENT)) != NULL) ) {			g_clear_error(&err);			err = NULL;			err = sqlx_repository_open_and_lock(m0->repository, &n, SQLX_OPEN_LOCAL|SQLX_OPEN_CREATE,&handle, NULL);			if( !err ) {				// Migration (1.7 -> 1.8) from old meta0 database				n.base = m0->id;				err = sqlx_repository_open_and_lock(m0->repository, &n, SQLX_OPEN_LOCAL, &oldhandle,NULL);				if ( ! err ) {					GRID_INFO("Start Migrate meta0 database");					err = sqlx_repository_backup_base(oldhandle,handle);					if ( err ) {						GRID_ERROR("Failed to migrate meta0 database : (%d) %s",err->code,err->message);					} else {						sqlx_repository_unlock_and_close_noerror(oldhandle);						// APPLY schema						gint rc;						char *errmsg = NULL;						rc = sqlite3_exec(handle->db, META0_SCHEMA, NULL, NULL, &errmsg);						if (rc != SQLITE_OK && rc != SQLITE_DONE)  {							GRID_WARN("Failed to apply schema (%d) %s %s",rc,sqlite3_errmsg(handle->db), errmsg);						}						if(errmsg != NULL)							g_free(errmsg);						// set table version						GRID_INFO("Update version in database");						sqlx_admin_inc_all_versions(handle, 2);					}				} else {					// database 1.7  doesn't existe ; new grid					g_clear_error(&err);					err = NULL;				}			} else {				GRID_ERROR("Failed to create meta0 database :(%d) %s",err->code,err->message);			}		}	}	if ( handle)		sqlx_repository_unlock_and_close_noerror(handle);}

static GError*_reload_lbpool(struct grid_lbpool_s *glp, gboolean flush){	gboolean _reload_srvtype(const gchar *ns, const gchar *srvtype) {		GSList *list_srv = NULL;		GError *err = conscience_get_services (ns, srvtype, FALSE, &list_srv);		if (err) {			GRID_WARN("Gridagent/conscience error: Failed to list the services"					" of type [%s]: code=%d %s", srvtype, err->code,					err->message);			g_clear_error(&err);			return FALSE;		}		if (list_srv || flush) {			GSList *l = list_srv;			gboolean provide(struct service_info_s **p_si) {				if (!l)					return FALSE;				*p_si = l->data;				l->data = NULL;				l = l->next;				return TRUE;			}			grid_lbpool_reload(glp, srvtype, provide);			g_slist_free(list_srv);		}

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;}

static gboolean_configure_synchronism(struct sqlx_service_s *ss){	if (!ss->zk_url) {		GRID_NOTICE("SYNC off (no ZK)");		return TRUE;	}	ss->sync = sqlx_sync_create(ss->zk_url);	if (!ss->sync)		return FALSE;	gchar *realprefix = g_strdup_printf("/hc/ns/%s/%s", SRV.ns_name,			ss->service_config->zk_prefix);	sqlx_sync_set_prefix(ss->sync, realprefix);	g_free(realprefix);	sqlx_sync_set_hash(ss->sync, ss->service_config->zk_hash_width,			ss->service_config->zk_hash_depth);	GError *err = sqlx_sync_open(ss->sync);	if (err != NULL) {		GRID_WARN("SYNC init error : (%d) %s", err->code, err->message);		g_clear_error(&err);		return FALSE;	}	return TRUE;}

static GError*_load_from_base(struct sqlx_sqlite3_s *sq3, GPtrArray **result){	GError *err = NULL;	GPtrArray *array;	sqlite3_stmt *stmt;	int rc;	guint count = 0;	sqlite3_prepare_debug(rc, sq3->db, "SELECT prefix,addr,ROWID FROM meta1",			-1, &stmt, NULL);	if (rc != SQLITE_OK && rc != SQLITE_DONE)		return SQLITE_GERROR(sq3->db, rc);	array = meta0_utils_array_create();	for (;;) {		rc = sqlite3_step(stmt);		if (rc == SQLITE_ROW) {			gint64 rowid;			const guint8 *prefix, *url;			gsize prefix_len;			prefix_len = sqlite3_column_bytes(stmt, 0);			prefix = sqlite3_column_blob(stmt, 0);			url = sqlite3_column_text(stmt, 1);			rowid = sqlite3_column_int64(stmt, 2);			if (prefix_len != 2)				GRID_WARN("Invalid prefix for URL [%s] ROWID %"G_GINT64_FORMAT,						url, rowid);			else {				meta0_utils_check_url_from_base((gchar**)&url);				meta0_utils_array_add(array, prefix, (gchar*)url);				count ++;			}		}		else if (rc == SQLITE_DONE || rc == SQLITE_OK)			break;		else if (rc == SQLITE_BUSY)			sleep(1);		else {			err = SQLITE_GERROR(sq3->db, rc);			break;		}	}	sqlite3_finalize_debug(rc, stmt);	if (!err) {		*result = array;		GRID_INFO("Reloaded %u prefixes in %p (%u)",				count, array, array->len);	}	return err;}

static GError*_unref_meta1(gchar **urls){	GError *error = NULL;	GSList *prefixByMeta1 = meta0_utils_array_to_list(context->array_meta1_by_prefix);	guint8 *prefix_mask = g_malloc0(8192);	for(;*urls;urls++) {		addr_info_t addr;		GRID_DEBUG("unref url %s",*urls);		grid_string_to_addrinfo(*urls,NULL,&addr);		GSList *l=prefixByMeta1;		for (;l;l=l->next) {                        struct meta0_info_s *m0info;                        if (!(m0info = l->data))                                continue;				if (addr_info_equal(&(m0info->addr),&addr)) {				guint16 *p, *max;                                p = (guint16*) m0info->prefixes;                                max = (guint16*) (m0info->prefixes + m0info->prefixes_size);                                for (; p<max; p++) {					if (_is_treat_prefix(prefix_mask,(guint8*)p) ) {						GRID_WARN("prefix %02X%02X manage by two meta1 present in the request",((guint8*)p)[0],((guint8*)p)[1]);						error = NEWERROR(0, "prefix %02X%02X manage by two meta1 present in the request",((guint8*)p)[0],((guint8*)p)[1]);						goto errorLabel;					}					_treat_prefix(prefix_mask,(guint8*)p);                                }			}		}		struct meta0_assign_meta1_s *aM1=NULL;		aM1=g_hash_table_lookup(context->map_meta1_ref,*urls);		if( !aM1) {			aM1 = g_malloc0(sizeof(struct meta0_assign_meta1_s));			aM1->addr=g_strdup(*urls);			aM1->score=0;			aM1->used=FALSE;			g_hash_table_insert(context->map_meta1_ref,strdup(*urls),aM1);		} else {			aM1->used=FALSE;		}	}errorLabel :	meta0_utils_list_clean(prefixByMeta1);	g_free(prefix_mask);	return error;}

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);}

// TODO: factorize with the similar function in sqliterepo/synchro.hstatic voidzk_main_watch(zhandle_t *zh, int type, int state, const char *path,		void *watcherCtx){	metautils_ignore_signals();	GRID_DEBUG("%s(%p,%d,%d,%s,%p)", __FUNCTION__,			zh, type, state, path, watcherCtx);	struct zk_manager_s *manager = watcherCtx;	const char *zkurl = manager->zk_url;	if (type != ZOO_SESSION_EVENT)		return;	if (state == ZOO_EXPIRED_SESSION_STATE) {		GRID_WARN("Zookeeper: (re)connecting to [%s]", zkurl);		if (manager->zh)			zookeeper_close(manager->zh);		/* XXX(jfs): forget the previous ID and reconnect */		manager->zh = zookeeper_init(manager->zk_url, zk_main_watch,				SQLX_SYNC_DEFAULT_ZK_TIMEOUT, NULL, manager, 0);		if (!manager->zh) {			GRID_ERROR("ZooKeeper init failure: (%d) %s",					errno, strerror(errno));			abort();		}	}	else if (state == ZOO_AUTH_FAILED_STATE) {		GRID_WARN("Zookeeper: auth problem to [%s]", zkurl);	}	else if (state == ZOO_ASSOCIATING_STATE) {		GRID_DEBUG("Zookeeper: associating to [%s]", zkurl);	}	else if (state == ZOO_CONNECTED_STATE) {		GRID_INFO("Zookeeper: connected to [%s]", zkurl);	}	else {		GRID_INFO("Zookeeper: unmanaged event [%s]", zkurl);	}}