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