gboolean stg_pol_rainx_get_param(namespace_info_t *ni, const gchar *stgpol, const gchar *param, gint64 *p_val) { const char *val_str = NULL; struct storage_policy_s *sp = storage_policy_init(ni, stgpol); const struct data_security_s *datasec = storage_policy_get_data_security(sp); gboolean ret; if (!datasec) { GRID_INFO("Cannot find datasecurity values for policy [%s]", stgpol); ret = FALSE; } else { if (NULL == (val_str = data_security_get_param(datasec, param))) { GRID_INFO("Cannot get parameter '%s' from data security [%s]", param, data_security_get_name(datasec)); ret = FALSE; } else { *p_val = g_ascii_strtoll(val_str, NULL, 10); ret = TRUE; } } storage_policy_clean(sp); return ret; }
GError* get_conditioned_spare_chunks2(struct grid_lbpool_s *lbp, struct storage_policy_s *stgpol, GSList *already, GSList *broken, GSList **result, gboolean answer_beans) { const struct data_security_s *ds = storage_policy_get_data_security(stgpol); const struct storage_class_s *stgclass = storage_policy_get_storage_class(stgpol); struct lb_next_opt_ext_s opt_ext; memset(&opt_ext, 0, sizeof(opt_ext)); opt_ext.req.max = 0; opt_ext.req.distance = data_security_get_int64_param(ds, DS_KEY_DISTANCE, 0); opt_ext.req.duplicates = (opt_ext.req.distance <= 0); opt_ext.req.stgclass = stgclass; opt_ext.req.strict_stgclass = FALSE; opt_ext.srv_inplace = NULL; opt_ext.srv_forbidden = NULL; switch (data_security_get_type(ds)) { case DUPLI: opt_ext.req.max = data_security_get_int64_param(ds, DS_KEY_COPY_COUNT, 1); break; case RAIN: opt_ext.req.max = data_security_get_int64_param(ds, DS_KEY_K, 1) + data_security_get_int64_param(ds, DS_KEY_M, 0); break; case DS_NONE: opt_ext.req.max = 1; break; default: return NEWERROR(CODE_POLICY_NOT_SUPPORTED, "Invalid storage policy"); } guint count = g_slist_length(already); if (opt_ext.req.max > count) opt_ext.req.max = opt_ext.req.max - count; else opt_ext.req.max = 1; GError *err = NULL; opt_ext.srv_forbidden = convert_chunks_to_srvinfo(lbp, broken); opt_ext.srv_inplace = convert_chunks_to_srvinfo(lbp, already); err = _poll_services(lbp, "rawx", &opt_ext, result, answer_beans); g_slist_free_full(opt_ext.srv_forbidden, (GDestroyNotify)service_info_clean); g_slist_free_full(opt_ext.srv_inplace, (GDestroyNotify)service_info_clean); return err; }
gboolean stg_pol_is_rainx(namespace_info_t *ni, const gchar *stgpol) { struct storage_policy_s *sp = storage_policy_init(ni, stgpol); const struct data_security_s *datasec = storage_policy_get_data_security(sp); gboolean ret; if (!datasec) { GRID_ERROR("Cannot find datasecurity values for policy [%s]", stgpol); ret = FALSE; } else { ret = data_security_get_type(datasec) == RAIN; } storage_policy_clean(sp); return ret; }
GError* get_spare_chunks(struct grid_lbpool_s *lbp, struct storage_policy_s *stgpol, GSList **result, gboolean use_beans) { const char *k, *m, *cpstr, *diststr; const struct data_security_s *ds = storage_policy_get_data_security(stgpol); struct lb_next_opt_ext_s opt_ext; memset(&opt_ext, 0, sizeof(opt_ext)); opt_ext.req.stgclass = storage_policy_get_storage_class(stgpol); opt_ext.req.strict_stgclass = TRUE; diststr = data_security_get_param(ds, DS_KEY_DISTANCE); opt_ext.req.distance = (NULL != diststr) ? atoi(diststr) : 1; switch (data_security_get_type(ds)) { case RAIN: k = data_security_get_param(ds, DS_KEY_K); m = data_security_get_param(ds, DS_KEY_M); if (!k || !m) return NEWERROR(CODE_BAD_REQUEST, "Invalid RAIN policy (missing K and/or M)"); opt_ext.req.max = atoi(k) + atoi(m); break; case DUPLI: cpstr = data_security_get_param(ds, DS_KEY_COPY_COUNT); opt_ext.req.max = (NULL != cpstr) ? atoi(cpstr) : 1; break; case DS_NONE: opt_ext.req.max = 1; break; default: return NEWERROR(CODE_POLICY_NOT_SUPPORTED, "Invalid policy type"); } return _poll_services(lbp, "rawx", &opt_ext, result, use_beans); }