static void
_init_nsinfo(struct namespace_info_s *nsinfo, const gchar *ns)
{
memset(nsinfo, 0, sizeof(*nsinfo));
metautils_strlcpy_physical_ns(nsinfo->name, ns, sizeof(nsinfo->name));
nsinfo->chunk_size = chunk_size;
nsinfo->writable_vns = g_slist_prepend(nsinfo->writable_vns, g_strdup("NS.VNS0"));
nsinfo->writable_vns = g_slist_prepend(nsinfo->writable_vns, g_strdup("NS.VNS1"));
nsinfo->storage_policy = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, metautils_gba_unref);
nsinfo->data_security = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, metautils_gba_unref);
nsinfo->data_treatments = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, metautils_gba_unref);
g_hash_table_insert(nsinfo->storage_policy, g_strdup("classic"),
metautils_gba_from_string("DUMMY:DUPONETWO:NONE"));
g_hash_table_insert(nsinfo->storage_policy, g_strdup("polcheck"),
metautils_gba_from_string("DUMMY:DUPONETHREE:SIMCOMP"));
g_hash_table_insert(nsinfo->storage_policy, g_strdup("secure"),
metautils_gba_from_string("DUMMY:DUP_SECURE:NONE"));
g_hash_table_insert(nsinfo->data_security, g_strdup("DUPONETWO"),
metautils_gba_from_string("DUP:distance=1|nb_copy=2"));
g_hash_table_insert(nsinfo->data_security, g_strdup("DUPONETHREE"),
metautils_gba_from_string("DUP:distance=1|nb_copy=3"));
g_hash_table_insert(nsinfo->data_security, g_strdup("DUP_SECURE"),
metautils_gba_from_string("DUP:distance=4|nb_copy=2"));
g_hash_table_insert(nsinfo->data_treatments, g_strdup("SIMCOMP"),
metautils_gba_from_string("COMP:algo=ZLIB|blocksize=262144"));
}
namespace_data_t*
get_namespace(const char *ns_name, GError **error)
{
gchar ns[LIMIT_LENGTH_NSNAME];
namespace_data_t *ns_data = NULL;
metautils_strlcpy_physical_ns(ns, ns_name, sizeof(ns));
/* Get namespace data */
ns_data = g_hash_table_lookup(namespaces, ns);
if (ns_data == NULL) {
GSETERROR(error, "Namespace [%s] unknown in config", ns);
goto end_label;
}
if (!ns_data->configured) {
GSETERROR(error, "Namespace [%s] unavailable", ns);
ns_data = NULL;
goto end_label;
}
if (!ns_data->local_services
|| !ns_data->down_services
|| !ns_data->conscience)
{
GSETERROR(error,"Namespace [%s] misconfigured", ns);
ns_data = NULL;
}
end_label:
return ns_data;
}
GError *
namespace_info_init_json_object(struct json_object *obj,
struct namespace_info_s *ni)
{
EXTRA_ASSERT(ni != NULL);
struct json_object *ns=NULL, *sz=NULL;
struct oio_ext_json_mapping_s mapping[] = {
{"ns", &ns, json_type_string, 1},
{"chunksize", &sz, json_type_int, 1},
{NULL, NULL, 0, 0}
};
GError *err = oio_ext_extract_json (obj, mapping);
if (err) return err;
metautils_strlcpy_physical_ns(ni->name, json_object_get_string(ns), sizeof(ni->name));
ni->chunk_size = json_object_get_int64(sz);
if (NULL != (err = _load_hash(obj, "options", ni->options))
|| NULL != (err = _load_hash(obj, "storage_policy", ni->storage_policy))
|| NULL != (err = _load_hash(obj, "data_security", ni->data_security))
|| NULL != (err = _load_hash(obj, "data_treatments", ni->data_treatments))
|| NULL != (err = _load_hash(obj, "storage_class", ni->storage_class)))
return err;
return NULL;
}
static void
test_strlcpy_pns(void)
{
gchar * _trans(const gchar *s0) {
gchar *s = g_strdup(s0);
metautils_strlcpy_physical_ns(s, s0, strlen(s0)+1);
return s;
}
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;
}
static struct grid_lbpool_s *
_init_lb(const gchar *ns)
{
struct def_s { const gchar *url, *loc; };
static struct def_s defs[] = {
{"127.0.0.1:1025","site0.salle0.baie0.device0"},
{"127.0.0.1:1026","site0.salle0.baie0.device1"},
{"127.0.0.1:1027","site0.salle0.baie1.device0"},
{"127.0.0.1:1028","site0.salle1.baie0.device0"},
{"127.0.0.1:1029","site0.salle1.baie1.device0"},
{"127.0.0.1:1030","site0.salle1.baie0.device1"},
{NULL,NULL}
};
struct def_s *pdef = defs;
gint score = 0;
gboolean provide(struct service_info_s **p_si) {
struct service_info_s *si;
if (!pdef->url)
return FALSE;
si = g_malloc0(sizeof(*si));
metautils_strlcpy_physical_ns(si->ns_name, "NS", sizeof(si->ns_name));
g_strlcpy(si->type, "rawx", sizeof(si->type));
si->score.timestamp = time(0);
si->score.value = ++score;
grid_string_to_addrinfo(pdef->url, NULL, &(si->addr));
pdef++;
*p_si = si;
return TRUE;
}
struct grid_lbpool_s *glp = grid_lbpool_create(ns);
g_assert(glp != NULL);
grid_lbpool_configure_string(glp, "rawx", "RR");
grid_lbpool_reload(glp, "rawx", provide);
return glp;
}
struct meta1_backend_s *
meta1_backend_init(const gchar *ns, struct sqlx_repository_s *repo,
struct grid_lbpool_s *glp)
{
struct meta1_backend_s *m1;
EXTRA_ASSERT(ns != NULL);
EXTRA_ASSERT(*ns != '\0');
EXTRA_ASSERT(glp != NULL);
EXTRA_ASSERT(repo != NULL);
m1 = g_malloc0(sizeof(*m1));
metautils_strlcpy_physical_ns(m1->backend.ns_name, ns,
sizeof(m1->backend.ns_name));
m1->backend.type = NAME_SRVTYPE_META1;
m1->backend.lb = glp;
m1->backend.repo = repo;
m1->prefixes = meta1_prefixes_init();
m1->svcupdate = service_update_policies_create();
return m1;
}
