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

static GError*_client_connect(struct gridd_client_s *client){	GError *err = NULL;	client->fd = _connect(client->url, &err);	if (client->fd < 0) {		EXTRA_ASSERT(err != NULL);		g_prefix_error(&err, "Connect error: ");		return err;	}	EXTRA_ASSERT(err == NULL);	g_get_current_time(&(client->tv_step));	client->step = CONNECTING;	return NULL;}

voidsqlx_name_dup (struct sqlx_name_mutable_s *dst, const struct sqlx_name_s *src){	EXTRA_ASSERT(dst != NULL && src != NULL);	oio_str_replace (&dst->ns, src->ns);	oio_str_replace (&dst->base, src->base);	oio_str_replace (&dst->type, src->type);}

sqlx_cache_t *sqlx_cache_set_close_hook(sqlx_cache_t *cache,                          sqlx_cache_close_hook hook){    EXTRA_ASSERT(cache != NULL);    cache->close_hook = hook;    return cache;}

voidhc_resolver_flush_services(struct hc_resolver_s *r){	EXTRA_ASSERT(r != NULL);	g_mutex_lock(&r->lock);	_lru_flush(r->services.cache);	g_mutex_unlock(&r->lock);}

static GError *_m0_remote_m0info (const char *m0, GByteArray *req, GSList **out){	EXTRA_ASSERT (m0 != NULL);	EXTRA_ASSERT (out != NULL);	GSList *result = NULL;	GError *e = gridd_client_exec_and_decode (m0, M0V2_CLIENT_TIMEOUT,			req, &result, meta0_info_unmarshall);	if (!e) {		*out = result;		return NULL;	} else {		g_slist_free_full (result, (GDestroyNotify)meta0_info_clean);		*out = NULL;		return e;	}}

voidhc_resolver_set_now(struct hc_resolver_s *r, time_t now){	EXTRA_ASSERT(r != NULL);	g_mutex_lock(&r->lock);	r->bogonow = now;	g_mutex_unlock(&r->lock);}

voidhc_resolver_flush_csm0(struct hc_resolver_s *r){	EXTRA_ASSERT(r != NULL);	g_mutex_lock(&r->lock);	_lru_flush(r->csm0.cache);	g_mutex_unlock(&r->lock);}

GError *meta2_backend_init(struct meta2_backend_s **result,		struct sqlx_repository_s *repo, const gchar *ns,		struct grid_lbpool_s *glp, struct hc_resolver_s *resolver){	GError *err = NULL;	struct meta2_backend_s *m2 = NULL;	gsize s;	EXTRA_ASSERT(result != NULL);	EXTRA_ASSERT(glp != NULL);	EXTRA_ASSERT(repo != NULL);	EXTRA_ASSERT(resolver != NULL);	m2 = g_malloc0(sizeof(struct meta2_backend_s));	s = metautils_strlcpy_physical_ns(m2->backend.ns_name, ns,			sizeof(m2->backend.ns_name));	if (sizeof(m2->backend.ns_name) <= s) {		g_free(m2);		return NEWERROR(CODE_BAD_REQUEST, "Namespace too long");	}	m2->backend.type = NAME_SRVTYPE_META2;	m2->backend.repo = repo;	m2->backend.lb = glp;	m2->policies = service_update_policies_create();	g_mutex_init(&m2->nsinfo_lock);	m2->flag_precheck_on_generate = TRUE;	err = sqlx_repository_configure_type(m2->backend.repo,			NAME_SRVTYPE_META2, schema);	if (NULL != err) {		meta2_backend_clean(m2);		g_prefix_error(&err, "Backend init error: ");		return err;	}	m2->resolver = resolver;	GRID_DEBUG("M2V2 backend created for NS[%s] and repo[%p]",			m2->backend.ns_name, m2->backend.repo);	*result = m2;	return NULL;}

GByteArray*sqlx_pack_QUERY_single(const struct sqlx_name_s *name, const gchar *query,		gboolean autocreate){	EXTRA_ASSERT(name != NULL);	EXTRA_ASSERT(query != NULL);	struct Table *t = calloc(1, sizeof(Table_t));	OCTET_STRING_fromBuf(&(t->name), query, strlen(query));	struct TableSequence *ts = calloc(1, sizeof(TableSequence_t));	asn_sequence_add(&(ts->list), t);	GByteArray *req = sqlx_pack_QUERY(name, query, ts, autocreate);	asn_DEF_TableSequence.free_struct(&asn_DEF_TableSequence, ts, FALSE);	return req;}

static gboolean_load_from_file_attr(struct attr_handle_s *attr_handle, GError ** error){	FILE *stream;	struct stat chunk_stats;	char lineBuf[8192];	EXTRA_ASSERT(attr_handle != NULL);	EXTRA_ASSERT(attr_handle->attr_hash != NULL);	/* stat the file */	if (0 > stat(attr_handle->attr_path, &chunk_stats)) {		SETERRCODE(error, errno, "Attr file [%s] not found for chunk", attr_handle->attr_path);		return FALSE;	}	stream = fopen(attr_handle->attr_path, "r");	if (!stream) {		SETERRCODE(error, errno, "Failed to open stream to file [%s] : %s)",			attr_handle->attr_path, strerror(errno));		return FALSE;	}	while (fgets(lineBuf, sizeof(lineBuf), stream)) {		/* Remove trailing /n */		int line_len = strlen(lineBuf);		if (lineBuf[line_len-1] == '/n')			lineBuf[line_len-1] = '/0';		char **tokens = g_strsplit(lineBuf, ":", 2);		if (tokens) {			if (*tokens && *(tokens + 1)) {				g_hash_table_insert(attr_handle->attr_hash, *tokens, *(tokens + 1));				g_free(tokens);			}			else				g_strfreev(tokens);		}	}	fclose(stream);	return TRUE;}

gbooleanmeta2_backend_initiated(struct meta2_backend_s *m2){	EXTRA_ASSERT(m2 != NULL);	g_mutex_lock (&m2->nsinfo_lock);	gboolean rc = (NULL != m2->nsinfo);	g_mutex_unlock (&m2->nsinfo_lock);	return rc;}

GError *oio_events_queue_factory__create_zmq (const char *zurl,		struct oio_events_queue_s **out){	EXTRA_ASSERT (zurl != NULL);	EXTRA_ASSERT (out != NULL);	struct _queue_AGENT_s *self = g_malloc0 (sizeof(*self));	self->vtable = &vtable_AGENT;	self->queue = g_async_queue_new ();	self->url = g_strdup (zurl);	self->max_recv_per_round = 32;	self->max_events_in_queue = OIO_EVTQ_MAXPENDING;	self->procid = getpid();	*out = (struct oio_events_queue_s *) self;	return NULL;}

static void_pool_unmonitor(struct gridd_client_pool_s *pool, int fd){	if (pool->fdmon >= 0)		(void) epoll_ctl(pool->fdmon, EPOLL_CTL_DEL, fd, NULL);	EXTRA_ASSERT(pool->active_count > 0);	-- pool->active_count;	pool->active_clients[fd] = NULL;}

voidmeta2_backend_configure_nsinfo(struct meta2_backend_s *m2,		struct namespace_info_s *ni){	EXTRA_ASSERT(m2 != NULL);	EXTRA_ASSERT(ni != NULL);	struct namespace_info_s *old = NULL, *copy = NULL;	copy = namespace_info_dup (ni);	g_mutex_lock(&m2->nsinfo_lock);	old = m2->nsinfo;	m2->nsinfo = copy;	g_mutex_unlock(&m2->nsinfo_lock);	if (old)		namespace_info_free (old);}

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 void_cnx_notify_close(struct network_server_s *srv){	g_mutex_lock(&srv->lock_threads);	EXTRA_ASSERT(srv->cnx_clients > 0);	-- srv->cnx_clients;	++ srv->cnx_close;	g_mutex_unlock(&srv->lock_threads);}

voidnetwork_client_allow_input(struct network_client_s *clt, gboolean v){	EXTRA_ASSERT(clt != NULL);	EXTRA_ASSERT(clt->fd >= 0);	if (!clt || clt->fd < 0)		return;	if (!v) {		if (!(clt->flags & NETCLIENT_IN_CLOSED))			clt->flags |= NETCLIENT_IN_PAUSED;	}	else {		EXTRA_ASSERT(!(clt->flags & NETCLIENT_IN_CLOSED));		clt->flags &= ~NETCLIENT_IN_PAUSED;	}}

GError*meta1_prefixes_load(struct meta1_prefixes_set_s *m1ps,		const gchar *ns_name, const gchar *local_url, GArray **updated_prefixes, gboolean *meta0_ok){	GError *err = NULL;	EXTRA_ASSERT(m1ps != NULL);	EXTRA_ASSERT(ns_name != NULL);	EXTRA_ASSERT(local_url != NULL);	err = _cache_load_from_ns(m1ps, ns_name, local_url, updated_prefixes, meta0_ok);	if (NULL != err)		g_prefix_error(&err, "NS loading error : ");	else		GRID_DEBUG("Prefixes reloaded for NS[%s]", ns_name);	return err;}

static gboolean_q_is_stalled (struct oio_events_queue_s *self){	struct _queue_AGENT_s *q = (struct _queue_AGENT_s*) self;	EXTRA_ASSERT (q != NULL && q->vtable == &vtable_AGENT);	const int l = g_async_queue_length (q->queue);	const guint waiting = q->gauge_pending;	return (waiting + (guint)(l>0?l:0)) >= q->max_events_in_queue;}

voidoio_events_queue__send_overwritable(struct oio_events_queue_s *self,		gchar *key, gchar *msg){	EXTRA_ASSERT (msg != NULL);	if (VTABLE_HAS(self,struct oio_events_queue_abstract_s*,send_overwritable)			&& key && *key) {		EVTQ_CALL(self,send_overwritable)(self,key,msg);	} else {

GSList*meta0_utils_tree_to_list(GTree *byurl){	GSList *result = NULL;	EXTRA_ASSERT(byurl != NULL);	g_tree_foreach(byurl, _tree2list_traverser, &result);	return result;}

static enum service_update_policy_eservice_howto_update2(struct service_update_policies_s *pol,		const struct hashstr_s *htype){	struct element_s *el;	enum service_update_policy_e policy;	EXTRA_ASSERT(pol != NULL);	EXTRA_ASSERT(htype != NULL);	policy = SVCUPD_KEEP;	g_mutex_lock(&pol->lock);	if (NULL != (el = g_tree_lookup(pol->tree_elements, htype)))		policy = el->howto_update;	g_mutex_unlock(&pol->lock);	return policy;}

gchar*version_dump(GTree *t){	EXTRA_ASSERT(t != NULL);	GString *gstr = g_string_new("");	if (t)		g_tree_foreach(t, hook_dump, gstr);	return g_string_free(gstr, FALSE);}

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){    struct grid_lb_iterator_s *iter = NULL;    struct service_info_s **siv = NULL;    GRID_DEBUG("Polling %u [%s]", replicas, ct->fulltype);    if (!(*err = _get_iterator(m1, ct, &iter))) {        struct lb_next_opt_ext_s opt;        memset(&opt, 0, sizeof(opt));        opt.req.distance = MACRO_COND(replicas>1,1,0);        opt.req.max = replicas;        opt.req.duplicates = FALSE;        opt.req.stgclass = NULL;        opt.req.strict_stgclass = TRUE;        opt.srv_forbidden = __srvinfo_from_m1srvurl(m1->lb, ct->baretype, used);        if (ct->req.k && !strcmp(ct->req.k, NAME_TAGNAME_USER_IS_SERVICE)) {            gchar *srvurl = g_strdup_printf("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, srv_inplace will contain NULL */            opt.srv_inplace = __srvinfo_from_m1srvurl(m1->lb, NULL, inplace);            opt.req.distance = 1;            meta1_service_url_clean(inplace[0]);            g_free(srvurl);        } else {            opt.filter.hook = _filter_tag;            opt.filter.data = ct;        }        if (!grid_lb_iterator_next_set2(iter, &siv, &opt)) {            EXTRA_ASSERT(siv == NULL);            *err = NEWERROR(CODE_POLICY_NOT_SATISFIABLE, "No service available");        }        grid_lb_iterator_clean(iter);        iter = NULL;        g_slist_free_full(opt.srv_forbidden, (GDestroyNotify)service_info_clean);        g_slist_free_full(opt.srv_inplace, (GDestroyNotify)service_info_clean);    }    if(NULL != *err)        return NULL;    struct meta1_service_url_s *m1u = _siv_to_url (siv);    service_info_cleanv(siv, FALSE);    siv = NULL;    g_strlcpy(m1u->srvtype, ct->type, sizeof(m1u->srvtype));    m1u->seq = seq;    return m1u;}

static void_q_set_max_pending (struct oio_events_queue_s *self, guint v){	struct _queue_BEANSTALKD_s *q = (struct _queue_BEANSTALKD_s *)self;	EXTRA_ASSERT (q != NULL && q->vtable == &vtable_BEANSTALKD);	if (q->max_events_in_queue != v) {		GRID_INFO("max events in queue set to [%u]", v);		q->max_events_in_queue = v;	}}

static GError*_client_set_fd(struct gridd_client_s *client, int fd){	EXTRA_ASSERT(client != NULL);	EXTRA_ASSERT(client->abstract.vtable == &VTABLE_CLIENT);	if (fd >= 0) {		switch (client->step) {			case NONE: /* ok */				break;			case CONNECTING:				if (client->request != NULL)					return NEWERROR(500, "Request pending");				/* PASSTHROUGH */			case CONNECTED: /* ok */				break;			case REQ_SENDING:			case REP_READING_SIZE:			case REP_READING_DATA:				return NEWERROR(500, "Request pending");			case STATUS_OK:			case STATUS_FAILED:				/* ok */				break;		}	}	/* reset any connection and request */	_client_reset_reply(client);	_client_reset_request(client);	_client_reset_target(client);	/* XXX do not call _client_reset_cnx(), or close the connexion.	 * It is the responsibility of the caller to manage this, because it	 * explicitely breaks the pending socket management. */	client->fd = fd;	/* CONNECTING instead of CONNECTED helps coping with not yet	 * completely connected sockets */	client->step = (client->fd >= 0) ? CONNECTING : NONE;	return NULL;}

const gchar *path_matching_get_variable (struct path_matching_s *self, const char *name){	EXTRA_ASSERT (self != NULL);	EXTRA_ASSERT (name != NULL);	gsize l = strlen (name);	gchar *key = g_alloca (l+2);	memcpy(key, name, l);	key[l] = '=';	key[l+1] = 0;	for (gchar **p = self->vars; *p ;++p) {		if (g_str_has_prefix (*p, key))			return (*p) + (l+1);	}	return NULL;}

static guint_resolver_expire(struct lru_tree_s *lru, time_t oldest){	struct cached_element_s *elt = NULL;	struct hashstr_s *k = NULL;	guint count = 0;	while (lru_tree_get_last(lru, (void**)&k, (void**)&elt)) {		EXTRA_ASSERT(k != NULL);		EXTRA_ASSERT(elt != NULL);		if (oldest <= elt->use)			break;		lru_tree_steal_last(lru, (void**)&k, (void**)&elt);		metautils_pfree0(&k, NULL);		metautils_pfree0(&elt, NULL);		++ count;	}	return count;}

GByteArray*message_marshall_gba_and_clean(MESSAGE m){	GByteArray *result;	EXTRA_ASSERT(m != NULL);	result = message_marshall_gba(m, NULL);	metautils_message_destroy(m);	return result;}

static GError*_client_request(struct gridd_client_s *client, GByteArray *req,		gpointer ctx, client_on_reply cb){	EXTRA_ASSERT(client != NULL);	EXTRA_ASSERT(client->abstract.vtable == &VTABLE_CLIENT);	if ( NULL == req)		return NEWERROR(CODE_INTERNAL_ERROR, "Invalid parameter");	switch (client->step) {		case NONE:		case CONNECTING:		case CONNECTED:			if (client->request != NULL)				return NEWERROR(500, "Request already pending");			/* ok */			break;		case REQ_SENDING:		case REP_READING_SIZE:		case REP_READING_DATA:			return NEWERROR(500, "Request not terminated");		case STATUS_OK:		case STATUS_FAILED:			/* ok */			if (client->fd >= 0)				client->step = REQ_SENDING;			else				client->step = CONNECTING;			break;	}	/* if any, reset the last reply */	_client_reset_reply(client);	_client_reset_request(client);	_client_reset_error(client);	/* Now set the new request components */	client->ctx = ctx;	client->on_reply = cb;	client->request = g_byte_array_ref(req);	return NULL;}