static gs_container_t* gs_container_init_from_location(gs_grid_storage_t *client, struct gs_container_location_s *location, gs_error_t **gserr) { GError *gerr = NULL; gs_container_t *container = NULL; container = calloc(1, sizeof(struct gs_container_s)); container->meta2_cnx = -1; container->opened = 0; l4_address_init_with_url(&(container->meta2_addr), location->m2_url[0], NULL); if (!oio_str_hex2bin(location->container_hexid, container->cID, sizeof(container_id_t))) { GSERRORCAUSE(gserr, gerr, "Invalid hexadecimal container ID"); g_error_free(gerr); free(container); return NULL; } if (gerr) g_clear_error(&gerr); container->info.gs = client; if (location->container_name) g_strlcpy(container->info.name, location->container_name, sizeof(container->info.name)-1); if (location->container_hexid) g_strlcpy(container->str_cID, location->container_hexid, sizeof(container->str_cID)-1); return container; }
gs_status_t gs_delete_services_for_paths(gs_container_t * container, const char *srvtype, char **paths, char ***really_removed, gs_service_t ***services_used, gs_error_t ** err) { status_t rc; char **path; struct metacnx_ctx_s ctx; GError *gerr; GSList *removed, *to_be_removed, *used; if (!container || !paths) { GSERR_EINVAL(err); if (really_removed) *really_removed = NULL; return GS_ERROR; } gerr = NULL; removed = to_be_removed = used = NULL; for (path=paths; *path ;path++) to_be_removed = g_slist_prepend(to_be_removed,*path); init_cnx_with_container(&ctx,container); rc = meta2_remote_service_delete_contents(&ctx, C0_ID(container), srvtype, to_be_removed, &removed, &used, &gerr); if (!rc) metacnx_close(&ctx); merge_cnx_in_container(&ctx,container); g_slist_free(to_be_removed); if (!rc) { GSERRORCAUSE(err,gerr,"Failed to remove (at least one of) the pahs"); if (really_removed) *really_removed = NULL; if (services_used) *services_used = NULL; } else { if (really_removed) *really_removed = strlist_make_deep_copy(removed); if (services_used) *services_used = addrlist_make_service_array(used, srvtype, container); } if (gerr) g_error_free(gerr); if (removed) { g_slist_foreach(removed,g_free1,NULL); g_slist_free(removed); } if (used) { g_slist_foreach(used,g_free1,NULL); g_slist_free(used); } return rc ? GS_OK : GS_ERROR; }
static status_t _get_container_user_properties(gs_grid_storage_t *hc, struct hc_url_s *url, char ***props, gs_error_t **gserr) { GError *gerr = NULL; gboolean rc; addr_info_t *m1 = NULL; GSList *excluded = NULL; gs_container_t *c = gs_get_container(hc, hc_url_get(url, HCURL_USER), 0, gserr); if(!c) return 0; for (;;) { m1 = gs_resolve_meta1v2(hc, hc_url_get_id(url), c->info.name, 1, &excluded, &gerr); if (!m1) { *gserr = gs_error_new(CODE_INTERNAL_ERROR, "No META1 found for [%s]", hc_url_get(url, HCURL_USER)); break; } rc = meta1v2_remote_reference_get_property (m1, &gerr, url, NULL, props); if (!rc) { excluded = g_slist_prepend(excluded, m1); m1=NULL; if (gerr) { if (CODE_IS_NETWORK_ERROR(gerr->code)) { g_error_free(gerr); gerr = NULL; } else { GSERRORCAUSE(gserr, gerr, "Cannot get container user properties"); break; } } } else { break; } } if (excluded) { g_slist_foreach(excluded, addr_info_gclean, NULL); g_slist_free(excluded); } if (m1) g_free(m1); gs_container_free(c); if (gerr) g_error_free(gerr); return rc; }
gs_error_t * hc_create_container(gs_grid_storage_t *hc, struct hc_url_s *url, const char *stgpol, const char *versioning) { GError *err = NULL; gs_error_t *e = NULL; gs_container_t *c = NULL; struct m2v2_create_params_s params = {stgpol, versioning, FALSE}; c = gs_get_storage_container2(hc, hc_url_get(url, HCURL_REFERENCE), ¶ms, 0, &e); if (c != NULL) { gchar m2[STRLEN_ADDRINFO] = {0}; addr_info_to_string(&(c->meta2_addr), m2, STRLEN_ADDRINFO); err = m2v2_remote_execute_HAS(m2, NULL, url); if (err == NULL) { e = gs_error_new(CODE_CONTAINER_EXISTS, "Failed to create container [%s]: " "container already exists in namespace [%s]\n", hc_url_get(url, HCURL_REFERENCE), hc_url_get(url, HCURL_NS)); goto end_label; } else if (err->code != CODE_CONTAINER_NOTFOUND) { GSERRORCAUSE(&e, err, "Failed to check container existence in meta2: "); goto end_label; } else { GRID_WARN("Container exists in meta1 but not in meta2"); } } gs_error_free(e); e = NULL; c = gs_get_storage_container2(hc, hc_url_get(url, HCURL_REFERENCE), ¶ms, 1, &e); if (c) GRID_INFO("Container [%s] created in namespace [%s].\n\n", hc_url_get(url, HCURL_REFERENCE), hc_url_get(url, HCURL_NS)); end_label: gs_container_free(c); g_clear_error(&err); return e; }
static gs_error_t * _dl_nocache(gs_container_t *c, struct hc_url_s *url, gs_download_info_t *dlinfo, gchar *stgpol) { gs_error_t *e = NULL; GError *err = NULL; gs_content_t *content = NULL; namespace_info_t *ni = NULL; GSList *filtered = NULL, *beans = NULL; /*find the content*/ content = gs_get_content_from_path_full(c, hc_url_get(url, HCURL_PATH), hc_url_get(url, HCURL_SNAPORVERS), &filtered, &beans, &e); if(NULL != content) { GRID_DEBUG("Content %s found in container %s\n", hc_url_get(url, HCURL_PATH), hc_url_get(url, HCURL_REFERENCE)); ni = get_namespace_info(hc_url_get(url, HCURL_NS), &err); if (!ni) { GSERRORCAUSE(&e, err, "Cannot get namespace info for NS [%s]", hc_url_get(url, HCURL_NS)); g_clear_error(&err); return e; } namespace_info_copy(ni, &(content->info.container->info.gs->ni), &err); /*download the content*/ (void) gs_download_content_full (content, dlinfo, stgpol, filtered, beans, &e); namespace_info_clear(ni); g_free(ni); gs_content_free (content); g_slist_free(filtered); _bean_cleanl2(beans); return e; } g_printerr("'%s' not found in '%s'\n", hc_url_get(url, HCURL_PATH), hc_url_get(url, HCURL_REFERENCE)); return e; }
static gs_error_t* _m1policy_update(gchar *action, gchar *ns,gboolean isprefix, container_id_t cid, gchar *type, gchar *exludesrv, gboolean checkonly, gchar ***result ) { GError *err=NULL; gs_error_t *hc_error = NULL; GSList *exclude = NULL; addr_info_t *m1addr; gs_grid_storage_t *hc; gchar ** hc_result = NULL; hc = gs_grid_storage_init(ns, &hc_error); if (!hc) return hc_error; m1addr = gs_resolve_meta1v2(hc,cid,NULL,0,exclude,&err); while (m1addr) { hc_result = meta1v2_remote_update_m1_policy(m1addr, &err, ns, ( isprefix ? cid : NULL), ( isprefix ? NULL: cid), type, action, checkonly, exludesrv, 300, 300); if ( err ) { if ( err->code < 100 || err->code > 500 ) { exclude=g_slist_prepend(exclude,m1addr); m1addr = gs_resolve_meta1v2(hc,cid,NULL,0,exclude,&err); } else { GRID_WARN("META1 request error (%d) : %s", err->code, err->message); GSERRORCAUSE(&hc_error, err, "Failed to apply Meta1 policy\n"); m1addr=NULL; } g_clear_error(&err); } else { break; } } gs_grid_storage_free(hc); if(exclude) { g_slist_foreach(exclude, addr_info_gclean, NULL); g_slist_free(exclude); } if(m1addr) g_free(m1addr); *result = hc_result; return hc_error; }
static gboolean _open_meta2_connection(struct metacnx_ctx_s *cnx, const gchar *m2_url, gs_error_t **e) { GError *ge = NULL; gboolean ret = FALSE; metacnx_clear(cnx); if (!metacnx_init_with_url(cnx, m2_url, &ge)) { GSERRORCAUSE(e, ge, "Invalid META2 address"); goto clean; } ret = TRUE; clean: if (ge) g_error_free(ge); return ret; }
gs_service_t * gs_choose_service_for_paths(gs_container_t * container, const char *srvtype, char **paths, gs_error_t ** err) { char **path; GSList *paths_list; GError *gerr; struct service_info_s *si; struct metacnx_ctx_s ctx; if (!container || !paths || !*paths) { GSERR_EINVAL(err); return NULL; } /*make the request on a path list, then free the list*/ paths_list = NULL; for (path=paths; *path ;path++) paths_list = g_slist_prepend(paths_list,*path); gerr = NULL; init_cnx_with_container(&ctx,container); si = meta2_remote_service_add_contents(&ctx, C0_ID(container), srvtype, paths_list, &gerr); if (!si) metacnx_close(&ctx); merge_cnx_in_container(&ctx,container); g_slist_free(paths_list); if (!si) { GSERRORCAUSE(err,gerr,"Failed to add at least one of the paths"); if (gerr) g_error_free(gerr); return NULL; } /*Wrap the service_info_s in gs_service_t*/ return _make_service_from_srvinfo(container, si); }
static gs_error_t * _get_content(struct metacnx_ctx_s *cnx, struct hc_url_s *url, struct beans_content_s **content) { GSList *beans = NULL; char target[STRLEN_ADDRINFO]; GError *e = NULL; gs_error_t *result = NULL; addr_info_to_string(&(cnx->addr), target, sizeof(target)); if(!(e = m2v2_remote_execute_GET(target, url, 0, &beans))) { *content = _beans_to_content(beans); g_slist_free_full(beans, _bean_clean); } if(NULL != e) { GSERRORCAUSE(&result, e, "Error while retrieving content"); g_clear_error(&e); } return result; }
static gs_error_t* _m2_touch(struct hc_url_s *hcurl, guint32 flags) { GError* err = NULL; gs_error_t* gserr = NULL; gs_container_t* cid = NULL; gs_grid_storage_t* hc = NULL; GSList* m2list = NULL; addr_info_t* m2addr = NULL; char str_addr[STRLEN_ADDRINFO] = ""; const char* ns = NULL; const char* content = NULL; const char* container_name = NULL; ns = hc_url_get(hcurl, HCURL_NS); container_name = hc_url_get(hcurl, HCURL_REFERENCE); content = hc_url_get(hcurl, HCURL_PATH); /* init grid client */ if ((ns==NULL) || (strlen(ns)==0)) { GSERRORCODE(&gserr, -1, "Invalid namespace"); return gserr; } hc = gs_grid_storage_init(ns, &gserr); if (!hc) { return gserr; } /* init container_id */ if ((container_name==NULL) || (strlen(container_name)==0)) { GSERRORCODE(&gserr, -1, "Invalid container_name"); return gserr; } cid = gs_init_container(hc, container_name, FALSE, &gserr); if (!gserr) { if (!cid) { gs_grid_storage_free(hc); GSERRORCODE(&gserr, -1, "Invalid container_name %s/%s", ns, container_name); return gserr; } } else return gserr; /* search meta2 master */ m2list = gs_resolve_meta2(hc, C0_ID(cid), &err); if (!m2list) { GSERRORCODE(&gserr, -1, "Meta2 Resolution error for NAME=[%s] ID=[%s]", C0_NAME(cid), C0_IDSTR(cid)); if (cid) gs_container_free (cid); gs_grid_storage_free(hc); return gserr; } m2addr = (addr_info_t*) m2list->data; addr_info_to_string (m2addr, str_addr, sizeof(str_addr)); /* execute touch command */ if (content && strlen(content)>0) err = m2v2_remote_touch_content(str_addr, NULL, hcurl); else err = m2v2_remote_touch_container_ex(str_addr, NULL, hcurl, flags); /* an error occurs ? */ if (err) { GSERRORCAUSE(&gserr, err, "Failed to execute touch command"); g_clear_error(&err); } gs_grid_storage_free(hc); if (cid) gs_container_free (cid); return gserr; }
gs_error_t* hcadmin_meta1_policy_update(char *ns,gchar *action, gboolean checkonly, gchar **globalresult, gchar ***result, char ** args) { gs_error_t *err = NULL; GPtrArray *gpa = NULL; gchar *m1pAction = NULL; struct global_cpt_s *cpts = NULL; gchar *excludesrv = NULL; gchar *srvtype = "meta2"; gchar *hexID = NULL; GError *gerr = NULL; container_id_t cid; gchar **tmp = NULL; if ((!args) || ( g_strv_length(args) == 0)) { GSERRORCODE(&err,500, "Invalid argument list\n"); goto failed; } // extract ID hexID = args[0]; // extract specific arg / action type if ( g_strcmp0(action, "meta1_policy_apply") == 0) { m1pAction = g_strdup_printf("UPDATE"); if ( g_strv_length(args) > 1 ) if (strlen(args[1]) > 0) srvtype = args[1]; } else if ( g_strcmp0(action, "meta1_policy_exclude") == 0 ) { m1pAction = g_strdup_printf("EXCLUDE"); if ( g_strv_length(args) > 1 ) excludesrv = args[1]; else { GSERRORCODE(&err, 500, "Missing service url \n"); } } else { GSERRORCODE(&err, 500, "INVALID meta1 policy action %s\n",action); } if (err) goto failed; if ( g_strcmp0(hexID,"ALL") == 0) { guint idx; struct thread_user_data_s *user_data = NULL; GThreadPool *pool = NULL; cpts = g_malloc0(sizeof(struct global_cpt_s)); user_data = g_malloc0(sizeof(struct thread_user_data_s)); user_data->ns = ns; user_data->action = m1pAction; user_data->type = g_strdup_printf(srvtype); user_data->excludesrv = excludesrv; user_data->checkonly = checkonly; user_data->lock = g_mutex_new(); user_data->indexreach=0; user_data->cpts = cpts; user_data->gpa = NULL; pool = g_thread_pool_new (_m1policy_update_thread,user_data,10,TRUE,&gerr); for ( idx=0; idx<65536 ;idx++) { gchar base[5]; guint8 *prefix=(guint8 *)(&idx); g_snprintf(base, sizeof(base), "%02X%02X", prefix[0], prefix[1]); g_thread_pool_push(pool, g_strdup(base) ,&gerr); if ( gerr != NULL ) { GRID_WARN("Failed to push new data thread %d, %d %s",idx,gerr->code,gerr->message); g_clear_error(&gerr); gerr = NULL; } } guint lastindex = 0; while(1) { if ( user_data->indexreach - lastindex > 500) { lastindex = user_data->indexreach; GRID_INFO("%d prefix checked",user_data->indexreach); } if ( user_data->indexreach >= 65536 ) break; usleep(1000000); } if ( excludesrv && excludesrv[0] ) { struct hc_url_s *url = NULL; url = hc_url_empty(); hc_url_set(url,HCURL_NS,ns); m2v2_remote_execute_EXITELECTION(excludesrv,NULL,url); hc_url_clean(url); } g_thread_pool_free(pool, FALSE, TRUE); g_mutex_free(user_data->lock); g_free(user_data); gpa = user_data->gpa; } else { // prefix ?? if ( strlen(hexID) == 4 ) { if(!hex2bin(hexID, cid, 2, &gerr)) { GSERRORCAUSE(&err, gerr, "Invalid prefix\n"); goto failed; } err = _m1policy_update(m1pAction,ns,TRUE,cid, srvtype, excludesrv, checkonly, &tmp); _pack_result(&gpa,hexID,tmp,err,NULL); if ( err ) { gs_error_free(err); err = NULL; } else { if ( excludesrv && excludesrv[0] ) { struct hc_url_s *url = NULL; url = hc_url_empty(); hc_url_set(url,HCURL_NS,ns); m2v2_remote_execute_EXITELECTION(excludesrv,NULL,url); hc_url_clean(url); } } // CID ?? } else if (strlen(hexID) == 64 ) { if (!hex2bin(hexID, cid, sizeof(container_id_t), &gerr)) { GSERRORCAUSE(&err, gerr, "Invalid container_id\n"); goto failed; } err = _m1policy_update(m1pAction,ns,FALSE,cid, srvtype, excludesrv, checkonly, &tmp); _pack_result(&gpa,hexID,tmp,err,NULL); if ( err ) { gs_error_free(err); err = NULL; } else { if ( excludesrv && excludesrv[0] ) { struct hc_url_s *url = NULL; url = hc_url_empty(); hc_url_set(url,HCURL_NS,ns); hc_url_set(url,HCURL_HEXID,hexID); m2v2_remote_execute_EXITELECTION(excludesrv,NULL,url); hc_url_clean(url); } } // other ? --> error } else { GSERRORCODE(&err,500,"invalid ID %s, %d \n",hexID, sizeof(hexID)); } } // free all memory if ( gerr) g_clear_error(&gerr); if ( gpa ) { g_ptr_array_add(gpa, NULL); if ( cpts ) { *globalresult = g_strdup_printf("Global result : References checked %lu , updated %lu , failed %lu",cpts->checkedRef,cpts->updatedRef,cpts->failedRef); } *result = (gchar**)g_ptr_array_free(gpa,FALSE); } if ( tmp ) g_strfreev (tmp); if ( cpts ) g_free(cpts); failed : if (m1pAction) g_free(m1pAction); return err; }
gs_grid_storage_t* gs_grid_storage_init_flags(const gchar *ns, uint32_t flags, int to_cnx, int to_req, gs_error_t **err) { gs_grid_storage_t *gs=NULL; register const gchar *sep; namespace_info_t *ni; env_init(); /*parse the arguments*/ if (!ns || !*ns) { GSERRORSET(err,"Invalid parameter"); return NULL; } DEBUG("Creating a new GridStorage client for namespace [%s]", ns); /*inits a new gs_grid_storage_t*/ gs = calloc (1, sizeof(gs_grid_storage_t)); if (!gs) { GSERRORSET(err,"Memory allocation failure"); return NULL; } if (!(flags & GSCLIENT_NOINIT)) { GError *gErr = NULL; ni = get_namespace_info(ns, &gErr); if (!ni) { GSERRORCAUSE(err,gErr,"Cannot get namespace info"); if (gErr) g_clear_error(&gErr); free(gs); return NULL; } namespace_info_copy(ni, &(gs->ni), &gErr); namespace_info_free(ni); if (gErr != NULL) { GSERRORCAUSE(err, gErr, "Failed to copy namespace info"); g_clear_error(&gErr); free(gs); return NULL; } } if (NULL != (sep = strchr(ns, '.'))) { gs->physical_namespace = g_strndup(ns, sep-ns); } else { gs->physical_namespace = g_strdup(ns); } gs->full_vns = g_strdup(ns); if (!(flags & GSCLIENT_NOINIT)) { GError *gErr = NULL; gs->metacd_resolver = resolver_metacd_create (ns, &gErr); if (!gs->metacd_resolver) { GSERRORCAUSE(err,gErr,"Cannot init the metacd"); if (gErr) g_clear_error(&gErr); free(gs); return NULL; } gs->direct_resolver = resolver_direct_create_with_metacd (ns, gs->metacd_resolver, to_cnx, to_req, &gErr); if (!gs->direct_resolver) { GSERRORCAUSE(err,gErr,"Cannot init the direct resolver"); if (gErr) g_clear_error(&gErr); resolver_metacd_free(gs->metacd_resolver); free(gs); return NULL; } } gs->timeout.rawx.op = RAWX_TOREQ_DEFAULT; gs->timeout.rawx.cnx = RAWX_TOCNX_DEFAULT; gs->timeout.m2.op = M2_TOREQ_DEFAULT; gs->timeout.m2.cnx = M2_TOCNX_DEFAULT; g_strlcpy(gs->ni.name, ns, sizeof(gs->ni.name)); if (NULL != strchr(gs->ni.name, '.')) * (strchr(gs->ni.name, '.')) = '\0'; return gs; }
static status_t _get_container_global_property(gs_grid_storage_t *hc, struct metacnx_ctx_s *cnx, container_id_t cid, GHashTable **ht, gs_error_t **gserr) { GSList *prop_list = NULL, *l = NULL; GError *gerr = NULL; // get all properties with current meta2 if (!meta2_remote_list_all_container_properties(cnx, cid, &prop_list, &gerr)) { GSList *m2_list = NULL; addr_info_t *addr = NULL; GSList *m2 = NULL; gchar str_addr[STRLEN_ADDRINFO]; struct metacnx_ctx_s cnxOther; gs_error_t *e = NULL; gboolean bResult = FALSE; // search all meta2 fo current contener m2_list = gs_resolve_meta2(hc, cid, &gerr); if (!m2_list) { GSERRORCAUSE(gserr, gerr, "Failed to get container admin entries, Cannot find meta2(s)"); if (gerr) g_error_free(gerr); return 0; } // test each meta2... for (m2=m2_list; m2 ;m2=m2->next) { addr = m2->data; if (addr) { addr_info_to_string(addr, str_addr, sizeof(str_addr)); DEBUG("Failed to get container admin entries -> test with next meta2 [%s]", str_addr); if (!_open_meta2_connection(&cnxOther, str_addr/*ctx->loc->m2_url[0]*/, &e)) { GSERRORCODE(gserr, e->code, "Failed to open connection to meta2 (%s)\n", str_addr); gs_error_free(e); continue; } if (!meta2_remote_list_all_container_properties(&cnxOther, cid, &prop_list, &gerr)) { _close_meta2_connection(&cnxOther); GSERRORCAUSE(gserr, gerr, "Failed to get container admin entries: %s\n",str_addr); continue; } else { _close_meta2_connection(&cnxOther); // no error bResult = TRUE; break; } } } if (m2_list) { g_slist_foreach(m2_list, addr_info_gclean, NULL); g_slist_free(m2_list); } if (gerr) g_error_free(gerr); if (bResult == FALSE) return 0; } // here: reading properties ok *ht = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); for (l = prop_list; l && l->data; l = l->next) { gchar *tmp = l->data; gchar **tok = g_strsplit(tmp, "=", 2); if (tok[0] && tok[1]) g_hash_table_insert(*ht, g_strdup(tok[0]), g_strdup(tok[1])); g_strfreev(tok); } g_slist_free_full(prop_list, g_free); /* Ensure we have some mandatory properties */ if(!g_hash_table_lookup(*ht, M2V2_ADMIN_STORAGE_POLICY)) g_hash_table_insert(*ht, g_strdup(M2V2_ADMIN_STORAGE_POLICY), g_strdup("namespace default")); if(!g_hash_table_lookup(*ht, M2V2_ADMIN_VERSIONING_POLICY)) g_hash_table_insert(*ht, g_strdup(M2V2_ADMIN_VERSIONING_POLICY), g_strdup("namespace default")); if(!g_hash_table_lookup(*ht, M2V2_ADMIN_QUOTA)) g_hash_table_insert(*ht, g_strdup(M2V2_ADMIN_QUOTA), g_strdup("namespace default")); return 1; }
static int add_event(gs_grid_storage_t * gs, const char *cName, const char *msg) { int rc = -1; gs_error_t **gserr = NULL; gs_error_t *locerr = NULL; struct gs_container_location_s *location = NULL; container_id_t cid; struct metacnx_ctx_s cnx; gchar *hexid = NULL; gchar * meta2_url = NULL; GError *gerr = NULL; metacnx_clear(&cnx); if (!gs || !cName || !msg) { PRINT_ERROR("Invalid parameter (%p %p %p)\n", gs, cName, msg); return rc; } location = gs_locate_container_by_name(gs, cName, &locerr); if (!location) { PRINT_ERROR("cannot find %s\n", cName); goto exit_label; } if (!location->m0_url || !location->m1_url || !location->m2_url || !location->m2_url[0]) { PRINT_ERROR("cannot find %s\n", cName); goto exit_label; } PRINT_DEBUG("%s found\n", cName); hexid = location->container_hexid; meta2_url = location->m2_url[0]; if (!container_id_hex2bin(hexid, strlen(hexid), &cid, &gerr)) { GSERRORCAUSE(gserr, gerr, "Invalid container id"); goto exit_label; } if (!metacnx_init_with_url(&cnx, meta2_url, &gerr)) { GSERRORCAUSE(gserr, gerr, "Invalid META2 address"); goto exit_label; } container_event_t event; bzero(&event, sizeof(event)); event.timestamp = time(0); g_strlcpy(event.type, "test", sizeof(event.type)); g_strlcpy(event.ref, "test", sizeof(event.type)); event.message = metautils_gba_from_string(msg); PRINT_DEBUG("Adding event [%s]", msg); rc = meta2_remote_add_container_event(&cnx, cid, &event, &gerr); g_byte_array_free(event.message, TRUE); event.message = NULL; metacnx_close(&cnx); metacnx_clear(&cnx); if (!rc) { PRINT_ERROR("Failed to add event : %s\n", gerror_get_message(gerr)); g_clear_error(&gerr); } exit_label: return rc; }