int
main(int argc, char ** args)
{
int i;
for (i=1; i<argc ;i++) {
struct hc_url_s *url = hc_url_init(args[i]);
if (url && NULL != hc_url_get_id(url)) {
memset(str_id, 0, sizeof(str_id));
buffer2str(hc_url_get_id(url), hc_url_get_id_size(url),
str_id, sizeof(str_id));
fputs(str_id, stdout);
}
else {
fputs(bad, stdout);
}
fputc(' ', stdout);
fputs(args[i], stdout);
fputc('\n', stdout);
if (url)
hc_url_clean(url);
}
fflush(stdout);
return 0;
}
static void
_input_data_clean(struct gridd_filter_input_data_s *input_data)
{
if (!input_data)
return;
if (NULL != input_data->url) {
hc_url_clean(input_data->url);
input_data->url = NULL;
}
if (NULL != input_data->params) {
g_hash_table_destroy(input_data->params);
input_data->params = NULL;
}
if (NULL != input_data->udata) {
if (input_data->cleaner)
input_data->cleaner(input_data->udata);
input_data->udata = NULL;
input_data->cleaner = NULL;
}
g_free(input_data);
}
gs_error_t * hcadmin_touch(char *url,gchar *action, gboolean checkonly, gchar **globalresult, gchar ***result, char ** args)
{
gchar *option = NULL;
guint32 flags = 0;
gs_error_t *err = NULL;
struct hc_url_s *hcurl = NULL;
(void) action;
(void) checkonly;
(void) result;
/* check poptionnal option*/
if (args != NULL) {
option = args[0];
if ( g_strcmp0(option,"UPDATE_CSIZE") == 0) {
flags = META2TOUCH_FLAGS_UPDATECSIZE;
} else if ( g_strcmp0(option,"RECALC_CSIZE") == 0) {
flags = META2TOUCH_FLAGS_RECALCCSIZE;
} else {
if ((option) && (strlen(option) > 0)) {
GSERRORCODE(&err,-1,"invalid option %s\n", option);
return err;
}
}
}
/* check and convert NS/REF/PATH */
if (!(hcurl = hc_url_init(url))) {
GSERRORCODE(&err,-1,"invalid URL: %s\n", url);
return err;
}
err = _m2_touch(hcurl, flags);
if (!err) {
*globalresult = g_strdup_printf("TOUCH done for %s", url);
}
hc_url_clean(hcurl);
return err;
}
gs_error_t*
hcadmin_meta1_policy_update(char *ns,gchar *action, gboolean checkonly, gchar **globalresult, gchar ***result, char ** args)
{
gs_error_t *err = NULL;
GPtrArray *gpa = NULL;
gchar *m1pAction = NULL;
struct global_cpt_s *cpts = NULL;
gchar *excludesrv = NULL;
gchar *srvtype = "meta2";
gchar *hexID = NULL;
GError *gerr = NULL;
container_id_t cid;
gchar **tmp = NULL;
if ((!args) || ( g_strv_length(args) == 0)) {
GSERRORCODE(&err,500, "Invalid argument list\n");
goto failed;
}
// extract ID
hexID = args[0];
// extract specific arg / action type
if ( g_strcmp0(action, "meta1_policy_apply") == 0) {
m1pAction = g_strdup_printf("UPDATE");
if ( g_strv_length(args) > 1 )
if (strlen(args[1]) > 0)
srvtype = args[1];
} else if ( g_strcmp0(action, "meta1_policy_exclude") == 0 ) {
m1pAction = g_strdup_printf("EXCLUDE");
if ( g_strv_length(args) > 1 )
excludesrv = args[1];
else {
GSERRORCODE(&err, 500, "Missing service url \n");
}
} else {
GSERRORCODE(&err, 500, "INVALID meta1 policy action %s\n",action);
}
if (err)
goto failed;
if ( g_strcmp0(hexID,"ALL") == 0) {
guint idx;
struct thread_user_data_s *user_data = NULL;
GThreadPool *pool = NULL;
cpts = g_malloc0(sizeof(struct global_cpt_s));
user_data = g_malloc0(sizeof(struct thread_user_data_s));
user_data->ns = ns;
user_data->action = m1pAction;
user_data->type = g_strdup_printf(srvtype);
user_data->excludesrv = excludesrv;
user_data->checkonly = checkonly;
user_data->lock = g_mutex_new();
user_data->indexreach=0;
user_data->cpts = cpts;
user_data->gpa = NULL;
pool = g_thread_pool_new (_m1policy_update_thread,user_data,10,TRUE,&gerr);
for ( idx=0; idx<65536 ;idx++) {
gchar base[5];
guint8 *prefix=(guint8 *)(&idx);
g_snprintf(base, sizeof(base), "%02X%02X",
prefix[0], prefix[1]);
g_thread_pool_push(pool, g_strdup(base) ,&gerr);
if ( gerr != NULL ) {
GRID_WARN("Failed to push new data thread %d, %d %s",idx,gerr->code,gerr->message);
g_clear_error(&gerr);
gerr = NULL;
}
}
guint lastindex = 0;
while(1) {
if ( user_data->indexreach - lastindex > 500) {
lastindex = user_data->indexreach;
GRID_INFO("%d prefix checked",user_data->indexreach);
}
if ( user_data->indexreach >= 65536 )
break;
usleep(1000000);
}
if ( excludesrv && excludesrv[0] ) {
struct hc_url_s *url = NULL;
url = hc_url_empty();
hc_url_set(url,HCURL_NS,ns);
m2v2_remote_execute_EXITELECTION(excludesrv,NULL,url);
hc_url_clean(url);
}
g_thread_pool_free(pool, FALSE, TRUE);
g_mutex_free(user_data->lock);
g_free(user_data);
gpa = user_data->gpa;
} else {
// prefix ??
if ( strlen(hexID) == 4 ) {
if(!hex2bin(hexID, cid, 2, &gerr)) {
GSERRORCAUSE(&err, gerr, "Invalid prefix\n");
goto failed;
}
err = _m1policy_update(m1pAction,ns,TRUE,cid, srvtype, excludesrv, checkonly, &tmp);
_pack_result(&gpa,hexID,tmp,err,NULL);
if ( err ) {
gs_error_free(err);
err = NULL;
} else {
if ( excludesrv && excludesrv[0] ) {
struct hc_url_s *url = NULL;
url = hc_url_empty();
hc_url_set(url,HCURL_NS,ns);
m2v2_remote_execute_EXITELECTION(excludesrv,NULL,url);
hc_url_clean(url);
}
}
// CID ??
} else if (strlen(hexID) == 64 ) {
if (!hex2bin(hexID, cid, sizeof(container_id_t), &gerr)) {
GSERRORCAUSE(&err, gerr, "Invalid container_id\n");
goto failed;
}
err = _m1policy_update(m1pAction,ns,FALSE,cid, srvtype, excludesrv, checkonly, &tmp);
_pack_result(&gpa,hexID,tmp,err,NULL);
if ( err ) {
gs_error_free(err);
err = NULL;
} else {
if ( excludesrv && excludesrv[0] ) {
struct hc_url_s *url = NULL;
url = hc_url_empty();
hc_url_set(url,HCURL_NS,ns);
hc_url_set(url,HCURL_HEXID,hexID);
m2v2_remote_execute_EXITELECTION(excludesrv,NULL,url);
hc_url_clean(url);
}
}
// other ? --> error
} else {
GSERRORCODE(&err,500,"invalid ID %s, %d \n",hexID, sizeof(hexID));
}
}
// free all memory
if ( gerr)
g_clear_error(&gerr);
if ( gpa ) {
g_ptr_array_add(gpa, NULL);
if ( cpts ) {
*globalresult = g_strdup_printf("Global result : References checked %lu , updated %lu , failed %lu",cpts->checkedRef,cpts->updatedRef,cpts->failedRef);
}
*result = (gchar**)g_ptr_array_free(gpa,FALSE);
}
if ( tmp )
g_strfreev (tmp);
if ( cpts )
g_free(cpts);
failed :
if (m1pAction)
g_free(m1pAction);
return err;
}
static gboolean
meta1_dispatch_v1_CREATE(struct gridd_reply_ctx_s *reply,
struct meta1_backend_s *m1, gpointer ignored)
{
GError *err;
struct addr_info_s m2addr;
container_id_t cid;
gchar **result = NULL;
gchar strcid[65], cname[256], vns[256];
struct hc_url_s *url = NULL;
/* Unpack the request */
(void) ignored;
EXTRACT_CID(cid);
EXTRACT_CNAME(cname);
EXTRACT_VNS(vns);
url = _forge_url(m1, vns, strcid);
reply->subject("%s/%s|%s", vns, cname, strcid);
/* Test if the container exsists */
err = meta1_backend_get_container_all_services(m1, cid, "meta2", &result);
if (NULL != err) {
if (err->code != CODE_CONTAINER_NOTFOUND) {
hc_url_clean(url);
reply->send_error(0, err);
return TRUE;
}
g_clear_error(&err);
GRID_DEBUG("Creating the container reference");
err = meta1_backend_create_container(m1, vns, cname, NULL);
if (NULL != err) {
hc_url_clean(url);
reply->send_error(0, err);
return TRUE;
}
}
/* Associate a META2 to the container */
if (result && !*result) {
g_free(result);
result = NULL;
}
if (!result) {
GRID_TRACE("Meta2 election...");
err = meta1_backend_get_container_service_available(m1, url, "meta2",
FALSE, &result);
if (NULL != err) {
hc_url_clean(url);
reply->send_error(0, err);
return TRUE;
}
}
/* Contact the meta2 and create a container on it */
gchar **p_url;
for (p_url=result; *p_url ;p_url++) {
err = _create_on_meta2(*p_url, vns, cname, cid, &m2addr);
if (!err) {
GRID_DEBUG("Container created on META2");
break;
}
if (err->code == CODE_CONTAINER_EXISTS) {
GRID_DEBUG("Container already present on META2");
break;
}
if (err->code >= 300) {
GRID_DEBUG("Error when creating the container on META2 [%s]"
" : code=%d message=%s",
*p_url, err->code, err->message);
break;
}
GRID_INFO("Network error : code=%d message=%s", err->code, err->message);
g_clear_error(&err);
}
g_strfreev(result);
hc_url_clean(url);
if (err) {
reply->send_error(0, err);
return TRUE;
}
/* Send the META2 address in the body of the reply ? */
reply->add_body(marshall_addrl(singleton_addrl(&m2addr), NULL));
GRID_DEBUG("Container created!");
reply->send_reply(200, "OK");
return TRUE;
}
