static int
parse_namespace_info(worker_t *worker, GError **error)
{
gchar *ns_name;
asn1_session_t *asn1_session;
namespace_data_t *ns_data;
namespace_info_t *ns_info = NULL;
asn1_session = asn1_worker_get_session(worker);
ns_name = asn1_worker_get_session_data(worker);
if (!ns_name || !asn1_session) {
GSETERROR(error,"Invalid worker : no session data");
return 0;
}
ns_data = g_hash_table_lookup(namespaces,ns_name);
if (!ns_data) {
GSETERROR(error,"Namespace '%s' does not exist", ns_name);
return 0;
}
if (asn1_session->resp_body != NULL) {
ns_info = namespace_info_unmarshall(asn1_session->resp_body,
asn1_session->resp_body_size, error);
if (ns_info == NULL) {
GSETERROR(error, "Failed to unmarshall namespace_info from ASN1 data");
return 0;
}
memcpy(&(ns_info->addr), &(ns_data->ns_info.addr), sizeof(addr_info_t));
/* Check that we have the same name */
if (strcmp(ns_info->name, ns_data->name)) {
ERROR("Namespace name [%s] in /etc/gridstorage does not match name [%s] in conscience !",
ns_data->name, ns_info->name);
namespace_info_free(ns_info);
return(0);
}
DEBUG("Infos of namespace [%s] updated with value name [%s] / chunk_size[%"G_GINT64_FORMAT"]",
ns_data->ns_info.name, ns_info->name, ns_info->chunk_size);
namespace_info_clear(&(ns_data->ns_info));
namespace_info_copy(ns_info, &(ns_data->ns_info));
namespace_info_free(ns_info);
/* Flag namespace if it's the first config */
ns_data->configured = TRUE;
}
return(1);
}
void
namespace_info_gclean(gpointer p1, gpointer p2)
{
(void) p2;
if (p1)
namespace_info_free((struct namespace_info_s*)p1);
}
void
meta2_backend_clean(struct meta2_backend_s *m2)
{
if (!m2)
return;
if (m2->policies)
service_update_policies_destroy(m2->policies);
if (m2->resolver)
m2->resolver = NULL;
g_mutex_clear(&m2->nsinfo_lock);
namespace_info_free(m2->nsinfo);
g_free(m2);
}
namespace_info_t *
namespace_info_unmarshall(const guint8 * buf, gsize buf_len, GError ** err)
{
asn_dec_rval_t decRet;
asn_codec_ctx_t codecCtx;
namespace_info_t *result = NULL;
NamespaceInfo_t *asn1_namespace_info = NULL;
/*sanity checks */
if (!buf) {
GSETCODE(err, 500+EINVAL, "Invalid paremeter");
return NULL;
}
/*deserialize the encoded form */
codecCtx.max_stack_size = 65536;
decRet = ber_decode(&codecCtx, &asn_DEF_NamespaceInfo, (void *) &asn1_namespace_info, buf, buf_len);
if (decRet.code != RC_OK) {
GSETCODE(err, 500, "Cannot deserialize: %s", (decRet.code == RC_WMORE)
? "uncomplete data" : "invalid data");
namespace_info_cleanASN(asn1_namespace_info, FALSE);
return NULL;
}
/*prepare the working structures */
if (!(result = g_try_malloc0(sizeof(namespace_info_t)))) {
GSETCODE(err, 500+ENOMEM, "Memory allocation failure");
namespace_info_cleanASN(asn1_namespace_info, FALSE);
return NULL;
}
/*map the ASN.1 in a common structure */
int rc = namespace_info_ASN2API(asn1_namespace_info, result);
namespace_info_cleanASN(asn1_namespace_info, FALSE);
asn1_namespace_info = NULL;
if (rc) {
errno = 0;
return result;
}
namespace_info_free(result);
result = NULL;
GSETCODE(err, 500, "ASN.1 to API mapping failure");
return NULL;
}
static void
_task_reload_nsinfo(gpointer p)
{
struct namespace_info_s *ni = NULL, *old = NULL;
GError *err = conscience_get_namespace(PSRV(p)->ns_name, &ni);
EXTRA_ASSERT ((err != NULL) ^ (ni != NULL));
if (err) {
GRID_WARN("NSINFO reload error [%s]: (%d) %s",
PSRV(p)->ns_name, err->code, err->message);
g_clear_error(&err);
} else {
old = PSRV(p)->nsinfo;
PSRV(p)->nsinfo = ni;
namespace_info_free(old);
}
}
void
meta2_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);
}
gint
namespace_info_unmarshall_one(struct namespace_info_s **ni, const void *s, gsize *sSize, GError **err)
{
struct namespace_info_s *result;
result = namespace_info_unmarshall(s, *sSize, err);
if (!result) {
GSETERROR(err, "Unmarshalling error");
return 0;
}
if (ni)
*ni = result;
else
namespace_info_free(result);
errno = 0;
return 1;
}
void
rawx_conf_clean(rawx_conf_t* c)
{
if(!c)
return;
if(c->ni) {
namespace_info_free(c->ni);
c->ni = NULL;
}
if(c->sp) {
storage_policy_clean(c->sp);
c->sp = NULL;
}
if(c->acl) {
g_slist_foreach(c->acl, _rawx_acl_clean, NULL);
g_slist_free(c->acl);
c->acl = NULL;
}
}
static void
sqlx_service_specific_fini(void)
{
// soft stop
if (SRV.gtq_reload)
grid_task_queue_stop(SRV.gtq_reload);
if (SRV.gtq_admin)
grid_task_queue_stop(SRV.gtq_admin);
if (SRV.server) {
network_server_close_servers(SRV.server);
network_server_stop(SRV.server);
}
if (SRV.thread_reload)
g_thread_join(SRV.thread_reload);
if (SRV.thread_admin)
g_thread_join(SRV.thread_admin);
if (SRV.thread_client)
g_thread_join(SRV.thread_client);
if (SRV.thread_queue)
g_thread_join(SRV.thread_queue);
if (SRV.repository) {
sqlx_repository_stop(SRV.repository);
struct sqlx_cache_s *cache = sqlx_repository_get_cache(SRV.repository);
if (cache)
sqlx_cache_expire(cache, G_MAXUINT, 0);
}
if (SRV.election_manager)
election_manager_exit_all(SRV.election_manager, 0, TRUE);
if (SRV.sync)
sqlx_sync_close(SRV.sync);
if (SRV.peering)
sqlx_peering__destroy(SRV.peering);
// Cleanup
if (SRV.gtq_admin) {
grid_task_queue_destroy(SRV.gtq_admin);
SRV.gtq_admin = NULL;
}
if (SRV.gtq_reload) {
grid_task_queue_destroy(SRV.gtq_reload);
SRV.gtq_reload = NULL;
}
if (SRV.server) {
network_server_clean(SRV.server);
SRV.server = NULL;
}
if (SRV.dispatcher) {
gridd_request_dispatcher_clean(SRV.dispatcher);
SRV.dispatcher = NULL;
}
if (SRV.repository) {
sqlx_repository_clean(SRV.repository);
SRV.repository = NULL;
}
if (SRV.sync) {
sqlx_sync_clear(SRV.sync);
SRV.sync = NULL;
}
if (SRV.resolver) {
hc_resolver_destroy(SRV.resolver);
SRV.resolver = NULL;
}
if (SRV.announce) {
g_string_free(SRV.announce, TRUE);
SRV.announce = NULL;
}
if (SRV.url) {
g_string_free(SRV.url, TRUE);
SRV.url = NULL;
}
if (SRV.zk_url)
oio_str_clean(&SRV.zk_url);
if (SRV.clients_pool) {
gridd_client_pool_destroy (SRV.clients_pool);
SRV.clients_pool = NULL;
}
// Must be freed after SRV.clients_pool
if (SRV.election_manager) {
election_manager_clean(SRV.election_manager);
SRV.election_manager = NULL;
}
if (SRV.lb) {
grid_lbpool_destroy (SRV.lb);
SRV.lb = NULL;
}
if (SRV.events_queue) {
oio_events_queue__destroy (SRV.events_queue);
SRV.events_queue = NULL;
}
if (SRV.nsinfo) {
namespace_info_free(SRV.nsinfo);
SRV.nsinfo = NULL;
}
if (all_options) {
g_free (all_options);
all_options = NULL;
}
}
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 void
sqlx_service_specific_fini(void)
{
// soft stop
if (SRV.gtq_reload)
grid_task_queue_stop(SRV.gtq_reload);
if (SRV.gtq_register)
grid_task_queue_stop(SRV.gtq_register);
if (SRV.gtq_admin)
grid_task_queue_stop(SRV.gtq_admin);
if (SRV.server) {
network_server_close_servers(SRV.server);
network_server_stop(SRV.server);
}
if (SRV.thread_reload)
g_thread_join(SRV.thread_reload);
if (SRV.thread_register)
g_thread_join(SRV.thread_register);
if (SRV.thread_admin)
g_thread_join(SRV.thread_admin);
if (SRV.thread_client)
g_thread_join(SRV.thread_client);
if (SRV.thread_queue)
g_thread_join(SRV.thread_queue);
if (SRV.repository) {
sqlx_repository_stop(SRV.repository);
struct sqlx_cache_s *cache = sqlx_repository_get_cache(SRV.repository);
if (cache)
sqlx_cache_expire(cache, G_MAXUINT, 0);
}
if (SRV.election_manager)
election_manager_exit_all(SRV.election_manager, 0, TRUE);
if (SRV.sync)
sqlx_sync_close(SRV.sync);
// Cleanup
if (SRV.gtq_admin)
grid_task_queue_destroy(SRV.gtq_admin);
if (SRV.gtq_reload)
grid_task_queue_destroy(SRV.gtq_reload);
if (SRV.gtq_register)
grid_task_queue_destroy(SRV.gtq_register);
if (SRV.server)
network_server_clean(SRV.server);
if (SRV.dispatcher)
gridd_request_dispatcher_clean(SRV.dispatcher);
if (SRV.repository)
sqlx_repository_clean(SRV.repository);
if (SRV.election_manager)
election_manager_clean(SRV.election_manager);
if (SRV.sync)
sqlx_sync_clear(SRV.sync);
if (SRV.resolver)
hc_resolver_destroy(SRV.resolver);
if (SRV.gsr_reqtime)
grid_single_rrd_destroy(SRV.gsr_reqtime);
if (SRV.gsr_reqcounter)
grid_single_rrd_destroy(SRV.gsr_reqcounter);
if (SRV.custom_tags)
g_slist_free_full(SRV.custom_tags, g_free);
if (SRV.si)
service_info_clean(SRV.si);
if (SRV.announce)
g_string_free(SRV.announce, TRUE);
if (SRV.url)
g_string_free(SRV.url, TRUE);
if (SRV.zk_url)
oio_str_clean(&SRV.zk_url);
if (SRV.clients_pool)
gridd_client_pool_destroy (SRV.clients_pool);
if (SRV.lb)
grid_lbpool_destroy (SRV.lb);
if (SRV.events_queue)
oio_events_queue__destroy (SRV.events_queue);
if (SRV.nsinfo)
namespace_info_free(SRV.nsinfo);
if (all_options) {
g_free (all_options);
all_options = NULL;
}
}
