static GError *
_resolve_meta1(struct hc_resolver_s *r, struct hc_url_s *u, gchar ***result)
{
struct hashstr_s *hk;
GError *err = NULL;
GRID_TRACE2("%s(%s)", __FUNCTION__, hc_url_get(u, HCURL_WHOLE));
hk = hashstr_printf("meta1|%s|%.4s",
hc_url_get(u, HCURL_NSPHYS),
hc_url_get(u, HCURL_HEXID));
/* Try to hit the cache */
if (!(*result = hc_resolver_get_cached(r, r->csm0.cache, hk))) {
/* get a meta0, then store it in the cache */
gchar **m0urlv = NULL;
err = _resolve_meta0(r, hc_url_get(u, HCURL_NSPHYS), &m0urlv);
if (err != NULL)
g_prefix_error(&err, "M0 resolution error: ");
else {
err = _resolve_m1_through_many_m0(m0urlv, hc_url_get_id(u), result);
if (!err)
hc_resolver_store(r, r->csm0.cache, hk, *result);
g_strfreev(m0urlv);
}
}
g_free(hk);
return err;
}
GError*
hc_resolve_reference_service(struct hc_resolver_s *r, struct hc_url_s *url,
const gchar *srvtype, gchar ***result)
{
GError *err;
struct hashstr_s *hk;
GRID_TRACE2("%s(%s,%s)", __FUNCTION__, hc_url_get(url, HCURL_WHOLE), srvtype);
g_assert(r != NULL);
g_assert(url != NULL);
g_assert(srvtype != NULL);
g_assert(result != NULL);
g_assert(*result == NULL);
if (!hc_url_get_id(url) || !hc_url_has(url, HCURL_NS))
return NEWERROR(400, "Incomplete URL [%s]", hc_url_get(url, HCURL_WHOLE));
hk = hashstr_printf("%s|%s|%s", srvtype,
hc_url_get(url, HCURL_NSPHYS),
hc_url_get(url, HCURL_HEXID));
err = _resolve_reference_service(r, hk, url, srvtype, result);
g_free(hk);
return err;
}
GError*
hc_resolve_reference_directory(struct hc_resolver_s *r, struct hc_url_s *url,
gchar ***result)
{
GRID_TRACE2("%s(%s)", __FUNCTION__, hc_url_get(url, HCURL_WHOLE));
EXTRA_ASSERT(r != NULL);
EXTRA_ASSERT(url != NULL);
EXTRA_ASSERT(result != NULL);
if (!hc_url_get_id(url) || !hc_url_has(url, HCURL_NS))
return NEWERROR(CODE_BAD_REQUEST, "Incomplete URL [%s]", hc_url_get(url, HCURL_WHOLE));
GError *err = NULL;
gchar **m1v = NULL, **m0v = NULL;
if (!(err = _resolve_meta0(r, hc_url_get(url, HCURL_NS), &m0v)))
err = _resolve_meta1(r, url, &m1v);
if (err) {
if (m0v) g_strfreev (m0v);
if (m1v) g_strfreev (m1v);
return err;
}
*result = g_malloc0(sizeof(gchar*) *
(g_strv_length(m0v) + g_strv_length(m1v) + 1));
gchar **d = *result;
for (gchar **p=m0v; *p ;++p) { *(d++) = *p; }
g_free (m0v); // pointers reused
for (gchar **p=m1v; *p ;++p) { *(d++) = *p; }
g_free (m1v); // pointers reused
return NULL;
}
gs_error_t *
hc_func_delete_property(gs_grid_storage_t *hc, struct hc_url_s *url, char **keys)
{
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) {
if (hc_url_has(url, HCURL_PATH)) {
content = gs_get_content_from_path_and_version (c,
hc_url_get(url, HCURL_PATH), hc_url_get(url, HCURL_VERSION),
&e);
if (NULL != content) {
hc_delete_content_property(content, keys, &e);
gs_content_free(content);
}
} else {
e = hc_del_container_global_property(c, keys[0]);
}
gs_container_free(c);
}
return e;
}
int
meta2_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;
}
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;
}
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;
}
gs_error_t *
hc_func_list_snapshots(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;
struct list_content_s lc;
redc_snapshot_t **snapshots = NULL;
c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE),
NULL, 0, &e);
if (c != NULL) {
lc.nb_elts = 0;
lc.xml = output_xml;
lc.show_info = show_info;
lc.buffer = g_string_new("");
lc.listed = NULL;
e = redc_list_snapshots(c, &snapshots);
if (e == NULL) {
int i = 0;
redc_snapshot_t *snap = snapshots[i];
if (output_xml) {
g_string_append_printf(lc.buffer,
"<Container>\n"
" <Name>%s</Name>\n"
" <Snapshots>\n",
hc_url_get(url, HCURL_REFERENCE));
} else {
g_string_append_printf(lc.buffer,
"#Listing snapshots of container=[%s]\n",
hc_url_get(url, HCURL_REFERENCE));
}
for (; snap != NULL; ++i, snap = snapshots[i]) {
const char *name = redc_snapshot_get_name(snap);
lc.nb_elts++;
if (lc.xml) {
g_string_append_printf(lc.buffer, " <Snapshot>\n");
g_string_append_printf(lc.buffer, " <Name>%s</Name>\n"
" </Snapshot>\n", name);
} else {
g_string_append_printf(lc.buffer, "%s\n", name);
}
}
if (output_xml) {
g_string_append_printf(lc.buffer,
" </Snapshots>\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);
redc_snapshot_array_clean(snapshots);
}
gs_container_free(c);
}
return e;
}
gs_error_t *
hc_func_set_property(gs_grid_storage_t *hc, struct hc_url_s *url,
char ** args)
{
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) {
if (hc_url_has(url, HCURL_PATH)) {
content = gs_get_content_from_path_and_version (c,
hc_url_get(url, HCURL_PATH), hc_url_get(url, HCURL_VERSION),
&e);
if (NULL != content) {
gchar **props = g_malloc0(sizeof(gchar*) * 2);
props[0] = g_strdup_printf("%s=%s", args[0], args[1]);
props[1] = NULL;
hc_set_content_property(content, props, &e);
gs_content_free(content);
g_strfreev(props);
}
} else {
e = hc_set_container_global_property(c, args[0], args[1]);
}
gs_container_free(c);
}
return e;
}
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_func_copy_content(gs_grid_storage_t *hc, struct hc_url_s *url, const char *source)
{
gs_error_t *e = NULL;
gs_container_t *c = NULL;
c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, 0, &e);
if(NULL != c) {
hc_copy_content(c, source, hc_url_get(url, HCURL_PATH), &e);
gs_container_free(c);
}
return e;
}
GError*
hc_resolve_reference_directory(struct hc_resolver_s *r, struct hc_url_s *url,
gchar ***result)
{
GRID_TRACE2("%s(%s)", __FUNCTION__, hc_url_get(url, HCURL_WHOLE));
g_assert(r != NULL);
g_assert(url != NULL);
g_assert(result != NULL);
if (!hc_url_get_id(url) || !hc_url_has(url, HCURL_NS))
return NEWERROR(400, "Incomplete URL [%s]", hc_url_get(url, HCURL_WHOLE));
return _resolve_meta1(r, url, result);
}
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 GError *
_m1_action (struct req_args_s *args, gchar ** m1v,
GError * (*hook) (const gchar * m1))
{
for (gchar ** pm1 = m1v; *pm1; ++pm1) {
struct meta1_service_url_s *m1 = meta1_unpack_url (*pm1);
if (!m1)
continue;
if (0 != g_ascii_strcasecmp(m1->srvtype, "meta1")) {
meta1_service_url_clean (m1);
continue;
}
struct addr_info_s m1a;
if (!grid_string_to_addrinfo (m1->host, NULL, &m1a)) {
GRID_INFO ("Invalid META1 [%s] for [%s]",
m1->host, hc_url_get (args->url, HCURL_WHOLE));
meta1_service_url_clean (m1);
continue;
}
GError *err = hook (m1->host);
meta1_service_url_clean (m1);
if (!err)
return NULL;
else if (err->code == CODE_REDIRECT)
g_clear_error (&err);
else {
g_prefix_error (&err, "META1 error: ");
return err;
}
}
return NEWERROR (CODE_UNAVAILABLE, "No meta1 answered");
}
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 = hc_url_get(meta2_filter_ctx_get_url(ctx), HCURL_NS);
if (!backend || !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->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->backend.ns_name));
return FILTER_KO;
}
return FILTER_OK;
}
GError *
meta1_backend_user_info(struct meta1_backend_s *m1,
struct hc_url_s *url, gchar ***result)
{
struct sqlx_sqlite3_s *sq3 = NULL;
GError *err = _open_and_lock(m1, url, SQLX_OPEN_MASTERSLAVE, &sq3);
if (!err) {
struct hc_url_s **urls = NULL;
if (!(err = __info_user(sq3, url, FALSE, &urls))) {
if (result) {
if (!urls)
*result = g_malloc0(sizeof(struct hc_url_s*));
else {
*result = g_malloc0(sizeof(gchar*) * (1+g_strv_length((gchar**)urls)));
for (int i=0; urls[i] ; ++i)
(*result)[i] = g_strdup(hc_url_get(urls[i], HCURL_WHOLE));
}
}
}
hc_url_cleanv (urls);
sqlx_repository_unlock_and_close_noerror(sq3);
}
return err;
}
void
sqlx_name_fill (struct sqlx_name_mutable_s *n, struct hc_url_s *url,
const char *srvtype, gint64 seq)
{
EXTRA_ASSERT (n != NULL);
EXTRA_ASSERT (url != NULL);
EXTRA_ASSERT (srvtype != NULL);
const gchar *subtype = hc_url_get (url, HCURL_TYPE);
n->ns = g_strdup(hc_url_get (url, HCURL_NS));
n->base = g_strdup_printf ("%s.%"G_GINT64_FORMAT, hc_url_get (url, HCURL_HEXID), seq);
if (subtype && 0 != strcmp(subtype, HCURL_DEFAULT_TYPE))
n->type = g_strdup_printf ("%s.%s", srvtype, subtype);
else
n->type = g_strdup (srvtype);
}
int
meta2_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;
}
static GError *
_resolve_service_through_many_meta1(gchar **urlv, struct hc_url_s *u,
const gchar *s, gchar ***result)
{
guint i, last;
gchar *url;
GRID_TRACE2("%s(%s,%s)", __FUNCTION__, hc_url_get(u, HCURL_WHOLE), s);
for (last=g_strv_length(urlv); last ;last--) {
/* pick a random URL */
i = rand() % last;
url = urlv[i];
GError *err = _resolve_service_through_one_m1(url, u, s, result);
g_assert((err!=NULL) ^ (*result!=NULL));
if (!err)
return NULL;
if (err->code >= 100)
return err;
g_clear_error(&err);
/* swap 'i' and 'last' */
urlv[i] = urlv[last-1];
urlv[last-1] = url;
}
return NEWERROR(500, "No META0 answered");
}
static GError*
_resolve_reference_service(struct hc_resolver_s *r, struct hashstr_s *hk,
struct hc_url_s *u, const gchar *s, gchar ***result)
{
GError *err;
gchar **m1urlv = NULL;
GRID_TRACE2("%s(%s,%s,%s)", __FUNCTION__, hashstr_str(hk),
hc_url_get(u, HCURL_WHOLE), s);
/* Try to hit the cache for the service itself */
*result = hc_resolver_get_cached(r, r->services.cache, hk);
if (NULL != *result) {
return NULL;
}
/* now attempt a real resolution */
err = _resolve_meta1(r, u, &m1urlv);
g_assert((err!=NULL) ^ (m1urlv!=NULL));
if (NULL != err)
return err;
err = _resolve_service_through_many_meta1(m1urlv, u, s, result);
g_assert((err!=NULL) ^ (*result!=NULL));
if (!err) {
/* fill the cache */
if (!(r->flags & HC_RESOLVER_NOCACHE))
hc_resolver_store(r, r->services.cache, hk, *result);
}
g_strfreev(m1urlv);
return err;
}
void test(struct meta2_backend_s *m2, struct hc_url_s *url) {
GError *err;
/* Generate a list of beans */
GSList *beans = create_alias(m2, url, NULL);
/* Change the hash of the chunk beans (0 by default) */
change_chunk_hash(beans, 0);
/* Put the beans in the database */
err = meta2_backend_put_alias(m2, url, beans, NULL, NULL);
g_assert_no_error(err);
_bean_cleanl2(beans);
/* Generate other contents with same hashes */
for (guint counter = 1; counter <= num_duplicates; counter++) {
/* Suffix the base url */
gchar *url_str = g_strdup_printf("%s_%d", hc_url_get(url, HCURL_WHOLE),
counter);
struct hc_url_s *url2 = hc_url_oldinit(url_str);
g_free(url_str);
GSList *beans2 = create_alias(m2, url2, NULL);
change_chunk_hash(beans2, counter);
err = meta2_backend_put_alias(m2, url2, beans2, NULL, NULL);
g_assert_no_error(err);
_bean_cleanl2(beans2);
}
err = meta2_backend_deduplicate_chunks(m2, url);
g_assert_no_error(err);
}
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 GError *
_resolve_service_through_one_m1(const gchar *m1, struct hc_url_s *u,
const gchar *s, gchar ***result)
{
GError *err = NULL;
struct addr_info_s ai;
GRID_TRACE2("%s(%s,%s,%s)", __FUNCTION__, m1, hc_url_get(u, HCURL_WHOLE), s);
meta1_strurl_get_address(m1, &ai);
*result = meta1v2_remote_list_reference_services(&ai, &err,
hc_url_get(u, HCURL_NS), hc_url_get_id(u), s,
_timeout(&rc_resolver_timeout_m1, 30.0),
_timeout(&rc_resolver_timeout_m1, 30.0));
g_assert((err!=NULL) ^ (*result!=NULL));
return err;
}
/* Generic function to avoid code duplication */
static gs_error_t *
_hc_func_snapshot_generic(snap_func func, gs_grid_storage_t *hc,
struct hc_url_s *url, void *param)
{
gs_error_t *e = NULL;
gs_container_t *c = NULL;
const gchar *snap_name = hc_url_get(url, HCURL_SNAPORVERS);
if (snap_name == NULL) {
GSERRORSET(&e, ERR_MISSING_SNAPSHOT_IN_URL);
} else {
c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE),
NULL, 0, &e);
if (c != NULL) {
e = func(c, snap_name, param);
gs_container_free(c);
}
}
return e;
}
void
hc_decache_reference_service(struct hc_resolver_s *r, struct hc_url_s *url,
const gchar *srvtype)
{
struct hashstr_s *hk;
GRID_TRACE2("%s(%s,%s)", __FUNCTION__, hc_url_get(url, HCURL_WHOLE), srvtype);
EXTRA_ASSERT(r != NULL);
EXTRA_ASSERT(url != NULL);
EXTRA_ASSERT(srvtype != NULL);
if (r->flags & HC_RESOLVER_NOCACHE)
return;
hk = hashstr_printf("%s|%s|%s", srvtype,
hc_url_get(url, HCURL_NS), hc_url_get(url, HCURL_HEXID));
hc_resolver_forget(r, r->services.cache, hk);
g_free(hk);
}
static void
wrapper(void (*cb)(void))
{
gboolean rc = FALSE;
GError *err = NULL;
g_printerr("\n");
hc_url_set(url, HCURL_REFERENCE, next_name("container"));
hc_url_set(url, HCURL_PATH, next_name("content"));
g_debug("ROUND with [%s] %s", hc_url_get(url, HCURL_HEXID),
hc_url_get(url, HCURL_WHOLE));
rc = meta2_remote_container_create(&addr, timeout, &err, hc_url_get_id(url),
hc_url_get(url, HCURL_REFERENCE));
CHECK_RC_ERR(rc, err, "CREATE");
if (cb)
cb();
}
gs_error_t *
hc_get_content(gs_grid_storage_t *hc, struct hc_url_s *url, const char *local_path, int force, int cache, gchar *stgpol)
{
gs_error_t *e = NULL;
/* download a content */
gs_download_info_t dl_info;
int out = 0;
memset(&dl_info, 0x00, sizeof(dl_info));
if(_open_destination(local_path, force, &out)) {
GRID_DEBUG("Destination file descriptor ready fd=%d path=%s\n", out, local_path ? local_path : "<stdout>");
/*download the content */
dl_info.offset = 0;
dl_info.size = 0;
dl_info.writer = _write_to_fd;
dl_info.user_data = &out;
e = hc_dl_content(hc, url, &dl_info, cache, stgpol);
if (out >= 0) {
metautils_pclose(&out);
}
if (e) {
g_printerr("Cannot download %s from %s (into %s)\n",
hc_url_get(url, HCURL_PATH),
hc_url_get(url, HCURL_REFERENCE),
local_path ? local_path : "<stdout>");
} else {
GRID_DEBUG("Download done from %s to %s\n",
hc_url_get(url, HCURL_PATH),
local_path ? local_path : "<stdout>");
}
} else {
gchar tmp[256];
bzero(tmp, sizeof(tmp));
g_snprintf(tmp, sizeof(tmp), "Failed to open the destination file descriptor to path=%s\n", local_path ? local_path : "<stdout>");
e = g_malloc0(sizeof(gs_error_t));
e->code = 0;
e->msg = g_strdup(tmp);
}
return e;
}
void
hc_decache_reference(struct hc_resolver_s *r, struct hc_url_s *url)
{
struct hashstr_s *hk;
GRID_TRACE2("%s(%s)", __FUNCTION__, hc_url_get(url, HCURL_WHOLE));
g_assert(r != NULL);
g_assert(url != NULL);
if (r->flags & HC_RESOLVER_NOCACHE)
return;
hk = hashstr_printf("meta0|%s", hc_url_get(url, HCURL_NSPHYS));
hc_resolver_forget(r, r->csm0.cache, hk);
g_free(hk);
hk = hashstr_printf("meta1|%s|%.4s", hc_url_get(url, HCURL_NSPHYS),
hc_url_get(url, HCURL_HEXID));
hc_resolver_forget(r, r->csm0.cache, hk);
g_free(hk);
}
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;
}
gs_error_t *
hc_dl_content(gs_grid_storage_t *hc, struct hc_url_s *url, gs_download_info_t *dl_info, int cache, gchar *stgpol)
{
gs_error_t *e = NULL;
gs_container_t *c = NULL;
c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, 0, &e);
if (c) {
if (cache) {
gs_download_content_by_name_full(c, hc_url_get(url, HCURL_PATH),
hc_url_get(url, HCURL_SNAPORVERS), stgpol, dl_info, &e);
} else {
e = _dl_nocache(c, url, dl_info, stgpol);
}
gs_container_free(c);
} else {
g_printerr("Failed to resolve meta2 entry for reference %s\n",
hc_url_get(url, HCURL_REFERENCE));
}
return e;
}
