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