gint chunk_id_to_string(const chunk_id_t * ci, gchar * dst, gsize dstSize) { gsize offset; gchar str_addr[STRLEN_ADDRINFO+1]; if (!dst || !ci) return 0; bzero(str_addr, sizeof(str_addr)); addr_info_to_string(&(ci->addr), str_addr, sizeof(str_addr)); /*ecrire id.id */ offset = g_snprintf(dst, dstSize, "%02X%02X%02X%02X%02X%02X%02X%02X" "%02X%02X%02X%02X%02X%02X%02X%02X" "%02X%02X%02X%02X%02X%02X%02X%02X" "%02X%02X%02X%02X%02X%02X%02X%02X:%s:%.*s", ci->id[0], ci->id[1], ci->id[2], ci->id[3], ci->id[4], ci->id[5], ci->id[6], ci->id[7], ci->id[8], ci->id[9], ci->id[10], ci->id[11], ci->id[12], ci->id[13], ci->id[14], ci->id[15], ci->id[16], ci->id[17], ci->id[18], ci->id[19], ci->id[20], ci->id[21], ci->id[22], ci->id[23], ci->id[24], ci->id[25], ci->id[26], ci->id[27], ci->id[28], ci->id[29], ci->id[30], ci->id[31], str_addr, LIMIT_LENGTH_VOLUMENAME, ci->vol); return MIN(offset,dstSize); }
static GPtrArray* build_meta0_cache (struct resolver_direct_s *r, GError **err) { GSList *m0_list=NULL; GPtrArray *array=NULL; /*now call the meta0 reference*/ if (!(m0_list = meta0_remote_get_meta1_all (&(r->meta0), r->timeout.m0.op, err))) { gchar str_addr[128]; memset(str_addr, 0x00, sizeof(str_addr)); addr_info_to_string(&(r->meta0), str_addr, sizeof(str_addr)); GSETERROR (err,"META0 error : Cannot get the reference from %s", str_addr); WARN ("Cannot get the META0 reference from %s", str_addr); return NULL; } array = meta0_utils_list_to_array(m0_list); g_slist_foreach (m0_list, meta0_info_gclean, NULL); g_slist_free (m0_list); return array; }
size_t gs_service_get_url(const gs_service_t * service, char *dst, size_t dst_size) { if (!service || !dst || !dst_size) return 0; return addr_info_to_string(&(service->gss_si->addr), dst, dst_size); }
static void allservice_check_start_HT(struct namespace_data_s *ns_data, GHashTable *ht) { gsize offset; struct taskdata_checksrv_s td_scheme; GHashTableIter iter_serv; gpointer k, v; TRACE_POSITION(); g_hash_table_iter_init(&iter_serv, ht); while (g_hash_table_iter_next(&iter_serv, &k, &v)) { struct service_info_s *si = v; memset(&td_scheme, 0x00, sizeof(td_scheme)); offset = g_snprintf(td_scheme.task_name, sizeof(td_scheme.task_name), "%s.", TASK_ID); addr_info_to_string(&(si->addr), td_scheme.task_name+offset, sizeof(td_scheme.task_name)-offset); g_strlcpy(td_scheme.ns_name, ns_data->name, sizeof(td_scheme.ns_name)-1); if (!_agent_check_enabled(si)) { GRID_DEBUG("Task [%s] disabled by " NAME_TAGNAME_AGENT_CHECK, td_scheme.task_name); } else if (!is_task_scheduled(td_scheme.task_name)) { GError *error_local = NULL; task_t *task = NULL; struct taskdata_checksrv_s *task_data; TRACE_POSITION(); agent_get_service_key(si, td_scheme.srv_key, sizeof(td_scheme.srv_key)); g_strlcpy(td_scheme.srv_key, (gchar*)k, sizeof(td_scheme.srv_key)-1); /* prepare the task structure */ task_data = g_memdup(&td_scheme, sizeof(td_scheme)); if (!task_data) { ERROR("Memory allocation failure"); continue; } task = create_task(period_check_services, td_scheme.task_name); task = set_task_callbacks(task, _check_tcp_service_task, g_free, task_data); if (!task) { ERROR("Memory allocation failure"); continue; } /* now start the task! */ if (add_task_to_schedule(task, &error_local)) INFO("Task started: %s", td_scheme.task_name); else { ERROR("Failed to add task to scheduler [%s] : %s", td_scheme.task_name, gerror_get_message(error_local)); g_free(task); } if (error_local) g_clear_error(&error_local); } } TRACE_POSITION(); }
static gchar* _chunk_to_rawxlist_element(chunk_info_t *chunk_info) { GString *res = g_string_new(NULL); char tmpstr[65]; // output format: ip:port/id addr_info_to_string(&(chunk_info->id.addr), tmpstr, sizeof(tmpstr)); g_string_append(res, tmpstr); g_string_append(res, "/"); buffer2str(chunk_info->id.id, sizeof(chunk_info->id.id), tmpstr, sizeof(tmpstr)); g_string_append(res, tmpstr); return g_string_free(res, FALSE); }
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; }
gsize meta0_info_to_string(const meta0_info_t * m0i, gchar * dst, gsize dstSize) { gsize i = 0; gsize offset; offset = g_snprintf(dst, dstSize, "%"G_GSIZE_FORMAT":", m0i->prefixes_size); offset += addr_info_to_string(&(m0i->addr), dst + offset, dstSize - offset); offset += g_snprintf(dst + offset, dstSize - offset, ":"); for (i = 0; i < m0i->prefixes_size; i++) offset += g_snprintf(dst + offset, dstSize - offset, "%02x", m0i->prefixes[i]); return offset; }
GHashTable * meta0_info_list_map_by_prefix(GSList * mL, GError ** err) { GSList *l; GHashTable *mH; (void) err; mH = g_hash_table_new_full(func_hash_prefix, func_equal_prefix, NULL, func_free_meta0); for (l = mL; l; l = l->next) { register int i, max; meta0_info_t dummy, *arg, *m0i; if (!l->data) continue; arg = (meta0_info_t *) l->data; dummy.prefixes_size = 2; dummy.prefixes = g_try_malloc(dummy.prefixes_size); g_memmove(&(dummy.addr), &(arg->addr), sizeof(addr_info_t)); for (i = 1, max = arg->prefixes_size - 1; i < max; i += 2) { g_memmove(dummy.prefixes, arg->prefixes + i - 1, 2); m0i = g_hash_table_lookup(mH, &dummy); if (m0i) { /*prefix already present, we do nothing else a debug */ if (DEBUG_ENABLED()) { char str_addr[128]; addr_info_to_string(&(dummy.addr), str_addr, sizeof(str_addr)); DEBUG("double prefix found %02X%02X -> %s", dummy.prefixes[0], dummy.prefixes[1], str_addr); } } else { /*prefix absent */ m0i = meta0_info_copy(&dummy); g_hash_table_insert(mH, m0i, m0i); } } g_free(dummy.prefixes); } return mH; }
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; }
namespace_info_t * gcluster_get_namespace_info_full(addr_info_t * addr, long timeout, GError ** error) { EXTRA_ASSERT (addr != NULL); gchar str[STRLEN_ADDRINFO]; addr_info_to_string(addr, str, sizeof(str)); GByteArray *out = NULL; GError *err = gridd_client_exec_and_concat (str, ((gdouble)timeout)/1000.0, message_marshall_gba_and_clean(metautils_message_create_named( NAME_MSGNAME_CS_GET_NSINFO)), &out); if (err) { g_prefix_error(&err, "request: "); g_error_transmit(error, err); return NULL; } namespace_info_t *ns_info = namespace_info_unmarshall(out->data, out->len, error); if (!ns_info) GSETERROR(error, "Decoding error"); return ns_info; }
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; }
GHashTable * rawx_client_get_statistics(rawx_session_t * session, const gchar *url, GError ** err) { int rc; gchar str_addr[64]; gsize str_addr_size; GHashTable *parsed = NULL; GHashTable *result = NULL; GByteArray *buffer = NULL; ne_request *request = NULL; if (!session || !url) { GSETERROR(err, "Invalid parameter"); return NULL; } ne_set_connect_timeout(session->neon_session, session->timeout.cnx / 1000); ne_set_read_timeout(session->neon_session, session->timeout.req / 1000); request = ne_request_create(session->neon_session, "GET", url); if (!request) { GSETERROR(err, "neon request creation error"); return NULL; } buffer = g_byte_array_new(); ne_add_response_body_reader(request, ne_accept_2xx, body_reader, buffer); switch (rc = ne_request_dispatch(request)) { case NE_OK: if (ne_get_status(request)->klass != 2) { GSETERROR(err, "RAWX returned an error"); goto exit; } else if (!(parsed = body_parser(buffer, err))) { GSETERROR(err, "No statistics from the RAWX server"); goto exit; } break; case NE_ERROR: case NE_TIMEOUT: case NE_CONNECT: case NE_AUTH: str_addr_size = addr_info_to_string(&(session->addr), str_addr, sizeof(str_addr)); GSETERROR(err, "cannot download the stats from [%.*s]' (%s)", (int)str_addr_size, str_addr, ne_get_error(session->neon_session)); goto exit; default: GSETERROR(err, "Unexpected return code from the neon library : %d", rc); goto exit; } result = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); g_hash_table_foreach(parsed, _convert_string_to_double, result); exit: if (buffer != NULL) g_byte_array_free(buffer, TRUE); if (request != NULL) ne_request_destroy(request); if (parsed != NULL) g_hash_table_destroy(parsed); return result; }
gboolean rawx_client_get_directory_data(rawx_session_t * session, hash_sha256_t chunk_id, struct content_textinfo_s *content, struct chunk_textinfo_s *chunk, GError ** error) { int rc; gchar str_addr[64]; gsize str_addr_size; gchar str_req[2048]; gchar str_chunk_id[(sizeof(hash_sha256_t) * 2) + 1]; GHashTable *result = NULL; GByteArray *buffer = NULL; ne_request *request = NULL; if (!session) { GSETERROR(error, "Invalid parameter"); return FALSE; } memset(str_chunk_id, '\0', sizeof(str_chunk_id)); oio_str_bin2hex(chunk_id, sizeof(hash_sha256_t), str_chunk_id, sizeof(str_chunk_id)); memset(str_req, '\0', sizeof(str_req)); snprintf(str_req, sizeof(str_req) - 1, "%s/%s", RAWX_REQ_GET_DIRINFO, str_chunk_id); ne_set_connect_timeout(session->neon_session, session->timeout.cnx / 1000); ne_set_read_timeout(session->neon_session, session->timeout.req / 1000); request = ne_request_create(session->neon_session, "HEAD", str_req); if (!request) { GSETERROR(error, "neon request creation error"); return FALSE; } buffer = g_byte_array_new(); ne_add_response_body_reader(request, ne_accept_2xx, body_reader, buffer); switch (rc = ne_request_dispatch(request)) { case NE_OK: if (ne_get_status(request)->klass != 2) { GSETERROR(error, "RAWX returned an error %d : %s", ne_get_status(request)->code, ne_get_status(request)->reason_phrase); goto error; } else if (!(result = header_parser(request))) { GSETERROR(error, "No attr from the RAWX server"); goto error; } break; case NE_ERROR: case NE_TIMEOUT: case NE_CONNECT: case NE_AUTH: str_addr_size = addr_info_to_string(&(session->addr), str_addr, sizeof(str_addr)); GSETERROR(error, "cannot download the data from [%.*s]' (%s)", (int)str_addr_size, str_addr, ne_get_error(session->neon_session)); goto error; default: GSETERROR(error, "Unexpected return code from the neon library : %d", rc); goto error; } g_byte_array_free(buffer, TRUE); ne_request_destroy(request); /* Fill the textinfo structs */ parse_chunkinfo_from_rawx(result, content, chunk); g_hash_table_destroy(result); return TRUE; error: g_byte_array_free(buffer, TRUE); ne_request_destroy(request); return FALSE; }
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 void _detect_obsolete_services(struct namespace_data_s *ns_data) { guint counter; time_t time_now, time_down, time_broken; GHashTableIter s_iterator; gpointer s_k, s_v; gchar *str_key; struct service_info_s *si; time_now = g_get_real_time()/1000000; time_down = time_now - 5; time_broken = time_now - 30; counter = 0; if (!ns_data->configured) { return; } /*move services from UP to DOWN */ g_hash_table_iter_init(&s_iterator, ns_data->local_services); while (g_hash_table_iter_next(&s_iterator, &s_k, &s_v)) { str_key = s_k; si = s_v; si->score.value = -2;/*score not set*/ if (si->score.timestamp < time_down) { gchar str_addr[STRLEN_ADDRINFO]; addr_info_to_string(&(si->addr),str_addr,sizeof(str_addr)); DEBUG("Timeout on service [%s/%s/%s] (%"G_GINT32_FORMAT" < %ld) --> DOWN", si->ns_name, si->type, str_addr, si->score.timestamp, time_down); g_hash_table_iter_steal(&s_iterator); g_hash_table_insert(ns_data->down_services, str_key, si); invalidate_conscience_service(ns_data,si); zero_service_stats(si->tags); service_tag_set_value_boolean(service_info_ensure_tag(si->tags,"tag.up"), FALSE); counter++; } } /*remove services DOWN from a long time ago */ g_hash_table_iter_init(&s_iterator, ns_data->down_services); while (g_hash_table_iter_next(&s_iterator, &s_k, &s_v)) { str_key = s_k; si = s_v; si->score.value = -2;/*score not set*/ if (si->score.timestamp < time_broken) { gchar str_addr[STRLEN_ADDRINFO]; addr_info_to_string(&(si->addr),str_addr,sizeof(str_addr)); DEBUG("Service obsolete [%s/%s/%s] --> DELETED", si->ns_name, si->type, str_addr); g_hash_table_iter_remove(&s_iterator); counter++; } else zero_service_stats(si->tags); } if (counter) DEBUG("[task_id=%s] %u services states have changed", TASK_ID, counter); }
gs_status_t rawx_delete (gs_chunk_t *chunk, GError **err) { char str_req_id [1024]; char str_addr [STRLEN_ADDRINFO]; char str_ci [STRLEN_CHUNKID]; char cPath [CI_FULLPATHLEN]; char str_hash[STRLEN_CHUNKHASH]; ne_request *request=NULL; ne_session *session=NULL; memset(str_req_id, 0x00, sizeof(str_req_id)); if (!chunk || !chunk->ci || !chunk->content) { GSETERROR (err,"Invalid parameter (bad chunk structure)"); goto error_label; } addr_info_to_string (&(chunk->ci->id.addr), str_addr, sizeof(str_addr)); chunk_id2str(chunk, str_ci, sizeof(str_ci)); chunk_getpath (chunk, cPath, sizeof(cPath)); DEBUG("about to delete %s on %s", str_ci, cPath); gscstat_tags_start(GSCSTAT_SERVICE_RAWX, GSCSTAT_TAGS_REQPROCTIME); session = rawx_opensession (chunk, err); if (!session) { GSETERROR (err, "Cannot open a webdav session"); goto error_label; } /*Create a webdav request*/ do { request = ne_request_create (session, RAWX_DELETE, cPath); if (!request) { GSETERROR (err, "cannot create a %s WebDAV request", RAWX_DELETE); goto error_label; } } while (0); chunk_id2str (chunk, str_ci, sizeof(str_ci)); chunk_gethash (chunk, str_hash, sizeof(str_hash)); /* Add request header */ add_req_id_header(request, str_req_id, sizeof(str_req_id)-1); ne_add_request_header (request, "chunkid", str_ci); ne_add_request_header (request, "chunkhash", str_hash); ne_add_request_header (request, "containerid", C1_IDSTR(chunk->content)); ne_add_request_header (request, "contentpath", chunk->content->info.path); ne_print_request_header(request, "chunkpos", "%"G_GUINT32_FORMAT, chunk->ci->position); ne_print_request_header(request, "chunknb", "%"G_GUINT32_FORMAT, chunk->ci->nb); ne_print_request_header(request, "chunksize", "%"G_GINT64_FORMAT, chunk->ci->size); ne_print_request_header(request, "contentsize", "%"G_GINT64_FORMAT, chunk->content->info.size); /*now perform the request*/ switch (ne_request_dispatch (request)) { case NE_OK: if (ne_get_status(request)->klass != 2) { GSETERROR (err, "cannot delete '%s' (%s) (ReqId:%s)", cPath, ne_get_error(session), str_req_id); goto error_label; } DEBUG("chunk deletion finished (success) : %s", cPath); break; case NE_AUTH: case NE_CONNECT: case NE_TIMEOUT: case NE_ERROR: GSETERROR (err, "unexpected error from the WebDAV server (%s) (ReqId:%s)", ne_get_error(session), str_req_id); goto error_label; } ne_request_destroy (request); ne_session_destroy (session); TRACE("%s deleted (ReqId:%s)", cPath, str_req_id); gscstat_tags_end(GSCSTAT_SERVICE_RAWX, GSCSTAT_TAGS_REQPROCTIME); return 1; error_label: TRACE("could not delete %s", cPath); if (request) ne_request_destroy (request); if (session) ne_session_destroy (session); gscstat_tags_end(GSCSTAT_SERVICE_RAWX, GSCSTAT_TAGS_REQPROCTIME); return 0; }
static void allservice_check_start_HT(struct namespace_data_s *ns_data, GHashTable *ht) { gsize offset; struct taskdata_checksrv_s td_scheme; GHashTableIter iter_serv; gpointer k, v; g_hash_table_iter_init(&iter_serv, ht); while (g_hash_table_iter_next(&iter_serv, &k, &v)) { struct service_info_s *si = v; gboolean srv_check_enabled = TRUE; /* Services can disable TCP checks (enabled by default) */ service_tag_t *tag = service_info_get_tag(si->tags, NAME_TAGNAME_AGENT_CHECK); if (tag) { GError *err = NULL; if (tag->type == STVT_BOOL) { service_tag_get_value_boolean(tag, &srv_check_enabled, &err); } else { gchar buf[64] = {0}; service_tag_get_value_string(tag, buf, sizeof(buf), &err); srv_check_enabled = metautils_cfg_get_bool(buf, TRUE); } g_clear_error(&err); } memset(&td_scheme, 0x00, sizeof(td_scheme)); offset = g_snprintf(td_scheme.task_name, sizeof(td_scheme.task_name), "%s.", TASK_ID); addr_info_to_string(&(si->addr), td_scheme.task_name+offset, sizeof(td_scheme.task_name)-offset); g_strlcpy(td_scheme.ns_name, ns_data->name, sizeof(td_scheme.ns_name)-1); if (!srv_check_enabled) { GRID_DEBUG("Task [%s] disabled by " NAME_TAGNAME_AGENT_CHECK, td_scheme.task_name); } else if (!is_task_scheduled(td_scheme.task_name)) { GError *error_local = NULL; task_t *task = NULL; struct taskdata_checksrv_s *task_data; agent_get_service_key(si, td_scheme.srv_key, sizeof(td_scheme.srv_key)); g_strlcpy(td_scheme.srv_key, (gchar*)k, sizeof(td_scheme.srv_key)-1); /* prepare the task structure */ task_data = g_memdup(&td_scheme, sizeof(td_scheme)); if (!task_data) { ERROR("Memory allocation failure"); continue; } task = create_task(period_check_services, td_scheme.task_name); task = set_task_callbacks(task, _check_tcp_service_task, g_free, task_data); if (!task) { ERROR("Memory allocation failure"); continue; } /* now start the task! */ if (add_task_to_schedule(task, &error_local)) INFO("Task started: %s", td_scheme.task_name); else { ERROR("Failed to add task to scheduler [%s] : %s", td_scheme.task_name, gerror_get_message(error_local)); g_free(task); } if (error_local) g_clear_error(&error_local); } } }
static int test_add_service(int argc, char ** args, int validation) { GSList *really_removed=NULL, *commit_failed=NULL, *services_used=NULL; struct service_info_s *si; GSList *paths; GError *err; if (argc<1) { g_printerr("Failed to add anything : expecting argument\r\n"); abort(); } err = NULL; if (!meta2_remote_container_open(&(cnx.addr), cnx.timeout.req, &err, cid)) { g_printerr("Failed to open the distant container : %s\r\n", gerror_get_message(err)); g_clear_error(&err); return 0; } paths = build_paths_list(argc,args); si = meta2_remote_service_add_contents(&cnx, cid, service_name, paths, &err); _display_strlist("\tAdd wanted: ", paths); if (si == NULL) { g_printerr("Failed to insert a path : %s\r\n", gerror_get_message(err)); } else { gchar str_addr[128]; addr_info_to_string(&(si->addr), str_addr, sizeof(str_addr)); g_printerr("Service found: %s\r\n", str_addr); } if (validation) { status_t rc0, rc1, rc2; /* COMMIT */ rc0 = meta2_remote_service_commit_contents(&cnx,cid,service_name,paths,&commit_failed,&err); _display_strlist("\tCommit wanted: ", paths); _display_strlist("\tCommit succeeded: ", commit_failed); _gfree_list(&commit_failed); g_printerr("RESULT : %s\r\n", rc0 ? "ok" : gerror_get_message(err)); if (rc0) { GError *e; gboolean rc_local; /* Second-COMMIT */ e = NULL; rc_local = meta2_remote_service_commit_contents(&cnx,cid,service_name,paths,&commit_failed,&e); _display_strlist("\tSecond Commit wanted: ", paths); _display_strlist("\tSecond Commit failed: ", commit_failed); _gfree_list(&commit_failed); g_printerr("Second Commit RESULT : %s\r\n", rc_local ? "ok" : gerror_get_message(e)); } /* DELETE */ rc1 = meta2_remote_service_delete_contents(&cnx, cid, service_name, paths, &really_removed, &services_used, &err); _display_strlist("\tDelete wanted: ", paths); _display_strlist("\tservices used: ", services_used); _display_strlist("\tcontent removed : ", really_removed); _gfree_list(&services_used); _gfree_list(&really_removed); g_printerr("RESULT : %s\r\n", rc1 ? "ok" : gerror_get_message(err)); /* COMMIT */ rc2 = meta2_remote_service_commit_contents(&cnx,cid,service_name,paths,&commit_failed,&err); _display_strlist("\tCommit wanted: ", paths); _display_strlist("\tCommit succeeded: ", commit_failed); _gfree_list(&commit_failed); g_printerr("RESULT : %s\r\n", rc2 ? "ok" : gerror_get_message(err)); if (!rc0 || !rc1 || !rc2) goto error_label; } else { status_t rc0, rc1, rc2; rc0 = rc1 = rc2 = ~0; /* ROLLBACK */ rc0 = meta2_remote_service_rollback_contents(&cnx,cid,service_name,paths,&commit_failed,&err); _display_strlist("\tRollback wanted: ", paths); _display_strlist("\tRollback failed: ", commit_failed); _gfree_list(&commit_failed); g_printerr("RESULT : %s\r\n", rc0 ? "ok" : gerror_get_message(err)); if (rc0) { GError *e; gboolean rc_local; /* Second-COMMIT */ e = NULL; rc_local = meta2_remote_service_rollback_contents(&cnx,cid,service_name,paths,&commit_failed,&e); _display_strlist("\tSecond Rollback wanted: ", paths); _display_strlist("\tSecond Rollback failed: ", commit_failed); _gfree_list(&commit_failed); g_printerr("Second Rollback RESULT : %s\r\n", rc_local ? "ok" : gerror_get_message(e)); } /* DELETE */ rc1 = meta2_remote_service_delete_contents(&cnx, cid, service_name, paths, &really_removed, &services_used, &err); _display_strlist("\tDelete wanted: ", paths); _display_strlist("\tservices used: ", services_used); _display_strlist("\tcontent removed : ", really_removed); g_printerr("RESULT : %s\r\n", rc1 ? "ok" : gerror_get_message(err)); if (services_used || really_removed) { g_printerr("ADD+ROLLBACK content should not be found\n"); rc2 = 0; } if (!rc0 || !rc1 || !rc2) goto error_label; } meta2_remote_container_close_in_fd(cnx.fd, cnx.timeout.req, NULL, cid); return 1; error_label: g_slist_free(paths); meta2_remote_container_close_in_fd(cnx.fd, cnx.timeout.req, NULL, cid); g_clear_error(&err); return 0; }