static void
_manage_requests(struct gridd_client_pool_s *pool)
{
struct event_client_s *ec;
EXTRA_ASSERT(pool != NULL);
while (pool->active_count < pool->active_max) {
ec = g_async_queue_try_pop(pool->pending_clients);
if (NULL == ec)
return;
EXTRA_ASSERT(ec->client != NULL);
if (!gridd_client_start(ec->client)) {
GError *err = gridd_client_error(ec->client);
if (NULL != err) {
GRID_WARN("STARTUP Client fd=%d [%s] : (%d) %s",
gridd_client_fd(ec->client), gridd_client_url(ec->client),
err->code, err->message);
g_clear_error(&err);
}
else {
GRID_WARN("STARTUP Client fd=%d [%s] : already started",
gridd_client_fd(ec->client), gridd_client_url(ec->client));
EXTRA_ASSERT(err != NULL);
}
event_client_free(ec);
}
else if (!event_client_monitor(pool, ec))
event_client_free(ec);
}
}
static void
_manage_prefix(struct meta1_backend_s *m1, guint8 *prefix, sqlite3 *tmpdb)
{
gchar sql[LIMIT_LENGTH_NSNAME + 128];
int cb(void * u, int nbcols, char **vals, char **cols) {
char *err_msg2 = NULL;
(void) u;
(void) nbcols;
(void) cols;
memset(sql, 0, sizeof(sql));
g_snprintf(sql, sizeof(sql), "UPDATE vns SET size = size + %s "
"WHERE vns = '%s'", vals[1], vals[0]);
GRID_TRACE("_manage_prefix executing [%s]", sql);
if (sqlite3_exec(tmpdb, sql, NULL, NULL, &err_msg2) != SQLITE_OK) {
GRID_WARN("Could not update size for VNS %s: %s", vals[0], err_msg2);
}
sqlite3_free(err_msg2);
err_msg2 = NULL;
if (!sqlite3_changes(tmpdb)) { /* VNS not found */
g_snprintf(sql, sizeof(sql), "INSERT INTO vns (vns,size) "
"VALUES ('%s',%s)", vals[0], vals[1]);
GRID_TRACE("_manage_prefix VNS not found, executing [%s]", sql);
if (sqlite3_exec(tmpdb, sql, NULL, NULL, &err_msg2) != SQLITE_OK) {
GRID_WARN("Could not set size for VNS %s: %s", vals[0], err_msg2);
}
sqlite3_free(err_msg2);
}
return 0;
}
static gboolean
_post_config(struct sqlx_service_s *ss)
{
GError *err = NULL;
if (err != NULL) {
GRID_WARN("%s", err->message);
g_clear_error(&err);
return FALSE;
}
// prepare a meta2 backend
err = meta2_backend_init(&m2, ss->repository, ss->ns_name, ss->lb, ss->resolver);
if (NULL != err) {
GRID_WARN("META2 backend init failure: (%d) %s", err->code, err->message);
g_clear_error(&err);
return FALSE;
}
/* Make deleted bases exit the cache */
sqlx_repository_configure_close_callback(ss->repository, meta2_on_close, ss);
/* Register meta2 requests handlers */
transport_gridd_dispatcher_add_requests(ss->dispatcher,
meta2_gridd_get_v2_requests(), m2);
/* Register few meta2 tasks */
grid_task_queue_register(ss->gtq_reload, 5,
_task_reconfigure_m2, NULL, ss);
grid_task_queue_register(ss->gtq_reload, 1,
(GDestroyNotify)sqlx_task_reload_lb, NULL, ss);
m2->notifier = ss->events_queue;
return TRUE;
}
static GError*
_check(GList *working_m1list) {
GError *error = NULL;
if ( working_m1list ) {
working_m1list=g_list_sort(working_m1list,meta0_assign_sort_by_score);
struct meta0_assign_meta1_s *hM1 = working_m1list->data;
struct meta0_assign_meta1_s *lM1 = (g_list_last(working_m1list))->data;
guint highscore = hM1->score;
guint lowscore = lM1->score;
GRID_TRACE("check delta highscore %d ,lowscore %d",highscore,lowscore);
if ( (highscore - lowscore) < (context->avgscore * trigger_assignment )/ 100 ) {
GRID_WARN("New assign not necessary, high score %d , low score %d, average %d", highscore, lowscore, context->avgscore);
error = NEWERROR(0, "New assign not necessary");
return error;
}
}
if ( context->lastAssignTime ) {
GRID_TRACE("last time %s",g_date_time_format (context->lastAssignTime,"%Y-%m-%d %H:%M"));
GDateTime *currentTime, *ltime;
currentTime=g_date_time_new_now_local();
ltime = g_date_time_add_minutes(context->lastAssignTime,period_between_two_assign);
GRID_TRACE("currentTime :%s , last time + %d min :%s, comp :%d",g_date_time_format (currentTime,"%Y-%m-%d %H:%M"),period_between_two_assign,g_date_time_format (ltime,"%Y-%m-%d %H:%M"), g_date_time_compare(ltime,currentTime));
if (g_date_time_compare(ltime,currentTime) > 0 ) {
GRID_WARN("delay between two meta1 assign not respected. Try later. last date [%s]",g_date_time_format (context->lastAssignTime,"%Y-%m-%d %H:%M"));
error = NEWERROR(0,"delay between two meta1 assign not respected. Try later.");
return error;
}
}
return NULL;
}
static GString *
_curl_url_prefix (const char *ns, enum _prefix_e which)
{
if (!ns) {
GRID_WARN ("BUG No namespace configured!");
return NULL;
}
gchar *s = NULL;
if (which == PREFIX_CONSCIENCE)
s = oio_cfg_get_proxy_conscience (ns);
else if (which == PREFIX_CONTAINER)
s = oio_cfg_get_proxy_containers (ns);
else if (which == PREFIX_REFERENCE)
s = oio_cfg_get_proxy_directory (ns);
if (!s)
s = oio_cfg_get_proxy (ns);
if (!s) {
GRID_WARN ("No proxy configured!");
return NULL;
}
GString *hu = g_string_new("http://");
g_string_append (hu, s);
g_free (s);
return hu;
}
struct gridd_client_pool_s *
gridd_client_pool_create(void)
{
int fdmon, fd[2];
struct gridd_client_pool_s *pool;
if (0 != pipe(fd)) {
GRID_WARN("pipe() error: (%d) %s", errno, strerror(errno));
metautils_pclose(&(fd[0]));
metautils_pclose(&(fd[1]));
return NULL;
}
if (0 > (fdmon = epoll_create(64))) {
GRID_WARN("epoll_create error: (%d) %s", errno, strerror(errno));
metautils_pclose(&(fd[0]));
metautils_pclose(&(fd[1]));
return NULL;
}
// TODO FIXME factorize this in metautils
struct rlimit limit;
memset(&limit, 0, sizeof(limit));
if (0 != getrlimit(RLIMIT_NOFILE, &limit))
limit.rlim_cur = limit.rlim_max = 32768;
pool = g_malloc0(sizeof(*pool));
pool->pending_clients = g_async_queue_new();
pool->fdmon = fdmon;
pool->active_max = limit.rlim_cur;
pool->active_clients_size = limit.rlim_cur;
pool->active_clients = g_malloc0(pool->active_clients_size
* sizeof(struct event_client_s*));
pool->fd_in = fd[0];
fd[0] = -1;
metautils_syscall_shutdown(pool->fd_in, SHUT_WR);
sock_set_non_blocking(pool->fd_in, TRUE);
pool->fd_out = fd[1];
fd[1] = -1;
metautils_syscall_shutdown(pool->fd_out, SHUT_RD);
sock_set_non_blocking(pool->fd_out, TRUE);
/* then monitors at least the notifications pipe's output */
struct epoll_event ev;
memset(&ev, 0, sizeof(ev));
ev.events = EPOLLIN;
ev.data.fd = pool->fd_in;
if (0 > epoll_ctl(pool->fdmon, EPOLL_CTL_ADD, pool->fd_in, &ev)) {
GRID_ERROR("epoll error: (%d) %s", errno, strerror(errno));
gridd_client_pool_destroy(pool);
return NULL;
}
pool->vtable = &VTABLE;
return pool;
}
static gboolean
_configure_with_arguments(struct sqlx_service_s *ss, int argc, char **argv)
{
// Sanity checks
if (ss->sync_mode_solo > SQLX_SYNC_FULL) {
GRID_WARN("Invalid SYNC mode for not-replicated bases");
return FALSE;
}
if (ss->sync_mode_repli > SQLX_SYNC_FULL) {
GRID_WARN("Invalid SYNC mode for replicated bases");
return FALSE;
}
if (!ss->url) {
GRID_WARN("No URL!");
return FALSE;
}
if (!ss->announce) {
ss->announce = g_string_new(ss->url->str);
GRID_DEBUG("No announce set, using endpoint [%s]", ss->announce->str);
}
if (!metautils_url_valid_for_bind(ss->url->str)) {
GRID_ERROR("Invalid URL as a endpoint [%s]", ss->url->str);
return FALSE;
}
if (!metautils_url_valid_for_connect(ss->announce->str)) {
GRID_ERROR("Invalid URL to be announced [%s]", ss->announce->str);
return FALSE;
}
if (argc < 2) {
GRID_ERROR("Not enough options, see usage.");
return FALSE;
}
// Positional arguments
gsize s = g_strlcpy(ss->ns_name, argv[0], sizeof(ss->ns_name));
if (s >= sizeof(ss->ns_name)) {
GRID_WARN("Namespace name too long (given=%"G_GSIZE_FORMAT" max=%u)",
s, (unsigned int)sizeof(ss->ns_name));
return FALSE;
}
GRID_DEBUG("NS configured to [%s]", ss->ns_name);
ss->lb_world = oio_lb_local__create_world();
ss->lb = oio_lb__create();
s = g_strlcpy(ss->volume, argv[1], sizeof(ss->volume));
if (s >= sizeof(ss->volume)) {
GRID_WARN("Volume name too long (given=%"G_GSIZE_FORMAT" max=%u)",
s, (unsigned int) sizeof(ss->volume));
return FALSE;
}
GRID_DEBUG("Volume configured to [%s]", ss->volume);
ss->zk_url = gridcluster_get_zookeeper(ss->ns_name);
return TRUE;
}
void
network_server_clean(struct network_server_s *srv)
{
if (!srv)
return;
if (srv->thread_events != NULL) {
GRID_WARN("EventThread not joined!");
g_error("EventThread not joined!");
}
if (srv->thread_first_worker) {
GRID_WARN("FirstThread not joined!");
g_error("FirstThread not joined!");
}
g_mutex_clear(&srv->lock_threads);
network_server_close_servers(srv);
if (srv->endpointv) {
struct endpoint_s **u;
for (u=srv->endpointv; *u ;u++)
g_free(*u);
g_free(srv->endpointv);
}
if (srv->stats) {
grid_stats_holder_clean(srv->stats);
}
metautils_pclose(&(srv->wakeup[0]));
metautils_pclose(&(srv->wakeup[1]));
if (srv->queue_monitor) {
g_async_queue_unref(srv->queue_monitor);
srv->queue_monitor = NULL;
}
if (srv->queue_events) {
g_async_queue_unref(srv->queue_events);
srv->queue_events = NULL;
}
if (srv->workers_active_1) {
grid_single_rrd_destroy(srv->workers_active_1);
srv->workers_active_1 = NULL;
}
if (srv->workers_active_60) {
grid_single_rrd_destroy(srv->workers_active_60);
srv->workers_active_60 = NULL;
}
g_free(srv);
}
static gboolean
_post_config(struct sqlx_service_s *ss)
{
GError *err;
// Create the backend
m0 = meta0_backend_init(ss->ns_name, ss->url->str, ss->repository);
if (!m0) {
GRID_WARN("META0 backend init failure");
return FALSE;
}
// Create the zookeeper poller
if (ss->zk_url) {
err = zk_srv_manager_create(ss->ns_name, ss->zk_url,
NAME_SRVTYPE_META0, &m0zkmanager);
if (err) {
GRID_WARN("Zk manager init failed : (%d) %s",err->code, err->message);
g_clear_error(&err);
return FALSE;
}
for (;;) {
err = create_zk_node(m0zkmanager, NULL, ss->url->str, ss->url->str);
if (!err)
break;
GRID_DEBUG("Meta0's zookeeper node creation failure : (%d) %s",
err->code, err->message);
g_clear_error(&err);
sleep(1);
}
}
m0disp = meta0_gridd_get_dispatcher(m0, m0zkmanager, ss->ns_name);
transport_gridd_dispatcher_add_requests(ss->dispatcher,
meta0_gridd_get_requests(), m0disp);
meta0_backend_migrate(m0);
meta0_gridd_requested_reload(m0disp);
sqlx_repository_configure_change_callback(ss->repository,
_callback_change, NULL);
grid_task_queue_register(ss->gtq_register, 3,
_task_zk_registration, NULL, ss);
return TRUE;
}
static GError *
__del_container_properties(struct sqlx_sqlite3_s *sq3, struct oio_url_s *url,
gchar **names)
{
GError *err = NULL;
gchar **p_name;
if (!names || !*names)
__exec_cid(sq3->db, "DELETE FROM properties WHERE cid = ?", oio_url_get_id(url));
else {
for (p_name=names; !err && p_name && *p_name ;p_name++) {
sqlite3_stmt *stmt = NULL;
gint rc;
sqlite3_prepare_debug(rc, sq3->db, "DELETE FROM properties WHERE cid = ? AND name = ?", -1, &stmt, NULL);
if (rc != SQLITE_OK && rc != SQLITE_DONE)
err = M1_SQLITE_GERROR(sq3->db, rc);
else {
(void) sqlite3_bind_blob(stmt, 1, oio_url_get_id(url), oio_url_get_id_size(url), NULL);
(void) sqlite3_bind_text(stmt, 2, *p_name, strlen(*p_name), NULL);
sqlite3_step_debug_until_end (rc, stmt);
if (rc != SQLITE_DONE)
GRID_WARN("SQLite error rc=%d", rc);
sqlite3_finalize_debug(rc, stmt);
}
}
}
return err;
}
GByteArray*
sqlx_pack_REPLICATE(struct sqlx_name_s *name, struct TableSequence *tabseq)
{
GError *err = NULL;
GByteArray *body, *encoded;
MESSAGE req;
EXTRA_ASSERT(name != NULL);
EXTRA_ASSERT(tabseq != NULL);
body = sqlx_encode_TableSequence(tabseq, &err);
if (!body) {
GRID_WARN("Transaction encoding error : (%d) %s",
err->code, err->message);
return NULL;
}
req = make_request("SQLX_REPLICATE", name);
(void) message_set_BODY(req, body->data, body->len, NULL);
encoded = message_marshall_gba(req, NULL);
g_byte_array_free(body, TRUE);
(void) message_destroy(req, NULL);
return encoded;
}
static int
_create_container(struct gridd_filter_ctx_s *ctx)
{
struct m2v2_create_params_s params;
struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);
struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);
GError *err = NULL;
int retry = 2;
params.storage_policy = meta2_filter_ctx_get_param(ctx, M2_KEY_STORAGE_POLICY);
params.version_policy = meta2_filter_ctx_get_param(ctx, M2_KEY_VERSION_POLICY);
params.local = (meta2_filter_ctx_get_param(ctx, "LOCAL") != NULL);
retry:
err = meta2_backend_create_container(m2b, url, ¶ms);
if (err != NULL && err->code == CODE_REDIRECT && retry-- > 0 &&
!g_strcmp0(err->message, meta2_backend_get_local_addr(m2b))) {
GRID_WARN("Redirecting on myself!?! Retrying request immediately");
g_clear_error(&err);
hc_decache_reference_service(m2b->resolver, url, META2_TYPE_NAME);
goto retry;
}
if (!err)
return FILTER_OK;
meta2_filter_ctx_set_error(ctx, err);
return FILTER_KO;
}
GError*
meta0_remote_get_meta1_info(const char *m0, gchar ***out)
{
GError *e = NULL;
gchar **result = NULL;
gboolean on_reply(gpointer c1, MESSAGE reply) {
(void) c1;
gchar **tmpResult = NULL;
if (NULL != (e = metautils_message_extract_body_strv (reply, &tmpResult))) {
GRID_WARN("GetMeta1Info : invalid reply");
g_clear_error (&e);
return FALSE;
}
if (tmpResult) {
guint len,resultlen,i;
gchar **v0;
if ( result != NULL )
resultlen=g_strv_length(result);
else
resultlen=0;
len = g_strv_length(tmpResult);
v0 = g_realloc(result, sizeof(gchar*) * (len + resultlen+1));
for ( i=0; i<len ; i++) {
v0[resultlen+i] = g_strdup(tmpResult[i]);
}
v0[len+resultlen]=NULL;
result = g_strdupv(v0);
g_strfreev(v0);
g_strfreev(tmpResult);
}
return TRUE;
}
int
meta2_filter_action_has_container(struct gridd_filter_ctx_s *ctx,
struct gridd_reply_ctx_s *reply)
{
(void) reply;
struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);
struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);
if (!url) {
GRID_WARN("BUG : Checking container's presence : URL not set");
meta2_filter_ctx_set_error (ctx, NEWERROR(CODE_BAD_REQUEST, "No URL"));
return FILTER_KO;
}
GError *e = meta2_backend_has_container(m2b, url);
if (NULL != e) {
GRID_DEBUG("Container test error for [%s] : (%d) %s",
hc_url_get(url, HCURL_WHOLE), e->code, e->message);
if (e->code == CODE_CONTAINER_NOTFOUND)
hc_decache_reference_service(m2b->resolver, url, NAME_SRVTYPE_META2);
meta2_filter_ctx_set_error(ctx, e);
return FILTER_KO;
}
return FILTER_OK;
}
void
sqlx_task_reload_lb (struct sqlx_service_s *ss)
{
static volatile gboolean already_succeeded = FALSE;
static volatile guint tick_reload = 0;
static volatile guint period_reload = 1;
EXTRA_ASSERT(ss != NULL);
if (!ss->lb || !ss->nsinfo)
return;
if (already_succeeded && 0 != (tick_reload++ % period_reload))
return;
GError *err = _reload_lbpool(ss->lb, FALSE);
if (!err) {
already_succeeded = TRUE;
period_reload ++;
period_reload = CLAMP(period_reload,2,10);
tick_reload = 1;
} else {
GRID_WARN("Failed to reload the LB pool services: (%d) %s",
err->code, err->message);
g_clear_error(&err);
}
grid_lbpool_reconfigure(ss->lb, ss->nsinfo);
}
GError *
meta2_json_load_setof_beans(struct json_object *jbeans, GSList **beans)
{
static gchar* title[] = { "aliases", "headers", "contents", "chunks", NULL };
static jbean_mapper mapper[] = {
m2v2_json_load_single_alias,
m2v2_json_load_single_header,
m2v2_json_load_single_content,
m2v2_json_load_single_chunk
};
GError *err = NULL;
gchar **ptitle;
jbean_mapper *pmapper;
for (ptitle=title,pmapper=mapper; *ptitle ;++ptitle,++pmapper) {
struct json_object *jv = NULL;
if (!json_object_object_get_ex (jbeans, *ptitle, &jv))
continue;
err = _jarray_to_beans(beans, jv, *pmapper);
if (err != NULL) {
GRID_WARN("Parsing error : (%d) %s", err->code, err->message);
break;
}
}
return err;
}
static void
_task_reload_m2_lb(gpointer p)
{
ADAPTIVE_PERIOD_DECLARE();
if (!PSRV(p)->nsinfo)
return;
if (ADAPTIVE_PERIOD_SKIP())
return;
oio_lb_world__reload_pools(PSRV(p)->lb_world, PSRV(p)->lb,
PSRV(p)->nsinfo);
/* In meta2, we are only interrested in rawx services */
GSList *svctypes = g_slist_prepend(NULL, NAME_SRVTYPE_RAWX);
GError *err = sqlx_reload_lb_service_types(PSRV(p)->lb_world, PSRV(p)->lb,
svctypes);
if (err) {
GRID_WARN("Failed to reload "NAME_SRVTYPE_RAWX" services: %s",
err->message);
g_clear_error(&err);
} else {
ADAPTIVE_PERIOD_ONSUCCESS(10);
}
g_slist_free(svctypes);
oio_lb_world__reload_storage_policies(PSRV(p)->lb_world,
PSRV(p)->lb, PSRV(p)->nsinfo);
oio_lb_world__debug(PSRV(p)->lb_world);
}
static int
event_client_monitor(struct gridd_client_pool_s *pool, struct event_client_s *mc)
{
int fd, rc, interest;
struct epoll_event ev;
EXTRA_ASSERT(pool != NULL);
EXTRA_ASSERT(mc != NULL);
EXTRA_ASSERT(mc->client != NULL);
memset(&ev, 0, sizeof(ev));
interest = gridd_client_interest(mc->client);
if (interest & CLIENT_RD)
ev.events |= EPOLLIN;
if (interest & CLIENT_WR)
ev.events |= EPOLLOUT;
EXTRA_ASSERT(ev.events != 0);
ev.events |= (EPOLLHUP|EPOLLERR|EPOLLONESHOT);
ev.data.fd = fd = gridd_client_fd(mc->client);
EXTRA_ASSERT(fd >= 0);
rc = epoll_ctl(pool->fdmon, EPOLL_CTL_ADD, fd, &ev);
if (rc < 0) {
pool->active_clients[fd] = NULL;
GRID_WARN("MONITOR error: (%d) %s", errno, strerror(errno));
return 0;
}
pool->active_count ++;
pool->active_clients[fd] = mc;
return 1;
}
GError*
sqlx_reload_lb_service_types(struct oio_lb_world_s *lbw,
GSList *list_srvtypes)
{
GError *err = NULL;
struct service_update_policies_s *pols = service_update_policies_create();
gchar *pols_cfg = gridcluster_get_service_update_policy(SRV.nsinfo);
service_update_reconfigure(pols, pols_cfg);
g_free(pols_cfg);
gboolean _reload_srvtype(const gchar *ns, const gchar *srvtype) {
GSList *list_srv = NULL;
err = conscience_get_services(ns, srvtype, FALSE, &list_srv);
if (err) {
GRID_WARN("Gridagent/conscience error: Failed to list the services"
" of type [%s]: code=%d %s", srvtype, err->code,
err->message);
g_clear_error(&err);
return FALSE;
}
oio_lb_world__feed_service_info_list(lbw, list_srv);
oio_lb__force_pool(SRV.lb,
oio_lb_pool__from_service_policy(lbw, srvtype, pols));
g_slist_free_full(list_srv, (GDestroyNotify)service_info_clean);
return TRUE;
}
int
meta2_filter_action_has_container(struct gridd_filter_ctx_s *ctx,
struct gridd_reply_ctx_s *reply)
{
(void) reply;
struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);
struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);
if (!url) {
GRID_WARN("BUG : Checking container's presence : URL not set");
return FILTER_OK;
}
GError *e = meta2_backend_has_container(m2b, url);
if(NULL != e) {
if (e->code == CODE_UNAVAILABLE)
GRID_DEBUG("Container %s exists but could not open it: %s",
hc_url_get(url, HCURL_WHOLE), e->message);
else
GRID_DEBUG("No such container (%s)", hc_url_get(url, HCURL_WHOLE));
if (e->code == CODE_CONTAINER_NOTFOUND) {
hc_decache_reference_service(m2b->resolver, url, META2_TYPE_NAME);
}
meta2_filter_ctx_set_error(ctx, e);
return FILTER_KO;
}
return FILTER_OK;
}
void
peers_restore(gchar **targets, struct sqlx_name_s *name,
GByteArray *dump)
{
GError *err = NULL;
if (!targets || !targets[0]) {
g_byte_array_unref(dump);
return ;
}
GByteArray *encoded = _pack_RESTORE(name, dump);
struct gridd_client_s **clients = gridd_client_create_many(targets, encoded, NULL, NULL);
g_byte_array_unref(encoded);
gridd_clients_set_timeout(clients, SQLX_RESYNC_TIMEOUT);
gridd_clients_start(clients);
if (!(err = gridd_clients_loop(clients)))
err = gridd_clients_error(clients);
gridd_clients_free(clients);
if (err) {
GRID_WARN("RESTORE failed [%s][%s] : (%d) %s", name->base, name->type,
err->code, err->message);
g_clear_error(&err);
}
}
static void
_m1policy_update_thread(gpointer data, gpointer p)
{
gs_error_t *err = NULL;
GError *gerr=NULL;
gchar **tmp=NULL;
container_id_t cid;
struct thread_user_data_s *user_data = (struct thread_user_data_s *)p;
gchar *base = data;
if(!hex2bin(base, cid, 2, &gerr)) {
GRID_WARN("Invalid prefix: %d %s",gerr->code, gerr->message);
g_clear_error(&gerr);
return;
}
err = _m1policy_update(user_data->action,user_data->ns,TRUE,cid, "meta2", user_data->excludesrv, user_data->checkonly, &tmp);
g_mutex_lock(user_data->lock);
_pack_result(&(user_data->gpa),base, tmp, err, user_data->cpts);
user_data->indexreach ++;
g_mutex_unlock(user_data->lock);
if ( err ) {
gs_error_free(err);
err = NULL;
}
if ( tmp )
g_strfreev (tmp);
}
void
meta0_backend_migrate(struct meta0_backend_s *m0)
{
GError *err = NULL;
struct sqlx_sqlite3_s *handle=NULL;
struct sqlx_sqlite3_s *oldhandle=NULL;
struct sqlx_name_s n;
n.base = m0->ns;
n.type = NAME_SRVTYPE_META0;
n.ns = m0->ns;
err = sqlx_repository_open_and_lock(m0->repository, &n, SQLX_OPEN_LOCAL, &handle, NULL);
if ( err )
{
// check if the erreur message is the ENOENT message ; DB doesn't exist
if ( (strstr(err->message, strerror(ENOENT)) != NULL) ) {
g_clear_error(&err);
err = NULL;
err = sqlx_repository_open_and_lock(m0->repository, &n, SQLX_OPEN_LOCAL|SQLX_OPEN_CREATE,&handle, NULL);
if( !err ) {
// Migration (1.7 -> 1.8) from old meta0 database
n.base = m0->id;
err = sqlx_repository_open_and_lock(m0->repository, &n, SQLX_OPEN_LOCAL, &oldhandle,NULL);
if ( ! err ) {
GRID_INFO("Start Migrate meta0 database");
err = sqlx_repository_backup_base(oldhandle,handle);
if ( err ) {
GRID_ERROR("Failed to migrate meta0 database : (%d) %s",err->code,err->message);
} else {
sqlx_repository_unlock_and_close_noerror(oldhandle);
// APPLY schema
gint rc;
char *errmsg = NULL;
rc = sqlite3_exec(handle->db, META0_SCHEMA, NULL, NULL, &errmsg);
if (rc != SQLITE_OK && rc != SQLITE_DONE) {
GRID_WARN("Failed to apply schema (%d) %s %s",rc,sqlite3_errmsg(handle->db), errmsg);
}
if(errmsg != NULL)
g_free(errmsg);
// set table version
GRID_INFO("Update version in database");
sqlx_admin_inc_all_versions(handle, 2);
}
} else {
// database 1.7 doesn't existe ; new grid
g_clear_error(&err);
err = NULL;
}
} else {
GRID_ERROR("Failed to create meta0 database :(%d) %s",err->code,err->message);
}
}
}
if ( handle)
sqlx_repository_unlock_and_close_noerror(handle);
}
static GError*
_reload_lbpool(struct grid_lbpool_s *glp, gboolean flush)
{
gboolean _reload_srvtype(const gchar *ns, const gchar *srvtype) {
GSList *list_srv = NULL;
GError *err = conscience_get_services (ns, srvtype, FALSE, &list_srv);
if (err) {
GRID_WARN("Gridagent/conscience error: Failed to list the services"
" of type [%s]: code=%d %s", srvtype, err->code,
err->message);
g_clear_error(&err);
return FALSE;
}
if (list_srv || flush) {
GSList *l = list_srv;
gboolean provide(struct service_info_s **p_si) {
if (!l)
return FALSE;
*p_si = l->data;
l->data = NULL;
l = l->next;
return TRUE;
}
grid_lbpool_reload(glp, srvtype, provide);
g_slist_free(list_srv);
}
static gboolean
_configure_events_queue (struct sqlx_service_s *ss)
{
if (ss->flag_no_event) {
GRID_DEBUG("Events queue disabled, the service disabled it");
return TRUE;
}
gchar *url = gridcluster_get_eventagent (SRV.ns_name);
STRING_STACKIFY (url);
if (!url) {
GRID_DEBUG("Events queue disabled, no URL configured");
return TRUE;
}
GError *err = oio_events_queue_factory__create(url, &ss->events_queue);
if (!ss->events_queue) {
GRID_WARN("Events queue creation failure: (%d) %s", err->code, err->message);
return FALSE;
}
GRID_INFO("Event queue ready, connected to [%s]", url);
return TRUE;
}
static gboolean
_configure_synchronism(struct sqlx_service_s *ss)
{
if (!ss->zk_url) {
GRID_NOTICE("SYNC off (no ZK)");
return TRUE;
}
ss->sync = sqlx_sync_create(ss->zk_url);
if (!ss->sync)
return FALSE;
gchar *realprefix = g_strdup_printf("/hc/ns/%s/%s", SRV.ns_name,
ss->service_config->zk_prefix);
sqlx_sync_set_prefix(ss->sync, realprefix);
g_free(realprefix);
sqlx_sync_set_hash(ss->sync, ss->service_config->zk_hash_width,
ss->service_config->zk_hash_depth);
GError *err = sqlx_sync_open(ss->sync);
if (err != NULL) {
GRID_WARN("SYNC init error : (%d) %s", err->code, err->message);
g_clear_error(&err);
return FALSE;
}
return TRUE;
}
static GError*
_load_from_base(struct sqlx_sqlite3_s *sq3, GPtrArray **result)
{
GError *err = NULL;
GPtrArray *array;
sqlite3_stmt *stmt;
int rc;
guint count = 0;
sqlite3_prepare_debug(rc, sq3->db, "SELECT prefix,addr,ROWID FROM meta1",
-1, &stmt, NULL);
if (rc != SQLITE_OK && rc != SQLITE_DONE)
return SQLITE_GERROR(sq3->db, rc);
array = meta0_utils_array_create();
for (;;) {
rc = sqlite3_step(stmt);
if (rc == SQLITE_ROW) {
gint64 rowid;
const guint8 *prefix, *url;
gsize prefix_len;
prefix_len = sqlite3_column_bytes(stmt, 0);
prefix = sqlite3_column_blob(stmt, 0);
url = sqlite3_column_text(stmt, 1);
rowid = sqlite3_column_int64(stmt, 2);
if (prefix_len != 2)
GRID_WARN("Invalid prefix for URL [%s] ROWID %"G_GINT64_FORMAT,
url, rowid);
else {
meta0_utils_check_url_from_base((gchar**)&url);
meta0_utils_array_add(array, prefix, (gchar*)url);
count ++;
}
}
else if (rc == SQLITE_DONE || rc == SQLITE_OK)
break;
else if (rc == SQLITE_BUSY)
sleep(1);
else {
err = SQLITE_GERROR(sq3->db, rc);
break;
}
}
sqlite3_finalize_debug(rc, stmt);
if (!err) {
*result = array;
GRID_INFO("Reloaded %u prefixes in %p (%u)",
count, array, array->len);
}
return err;
}
static GError*
_unref_meta1(gchar **urls)
{
GError *error = NULL;
GSList *prefixByMeta1 = meta0_utils_array_to_list(context->array_meta1_by_prefix);
guint8 *prefix_mask = g_malloc0(8192);
for(;*urls;urls++) {
addr_info_t addr;
GRID_DEBUG("unref url %s",*urls);
grid_string_to_addrinfo(*urls,NULL,&addr);
GSList *l=prefixByMeta1;
for (;l;l=l->next) {
struct meta0_info_s *m0info;
if (!(m0info = l->data))
continue;
if (addr_info_equal(&(m0info->addr),&addr)) {
guint16 *p, *max;
p = (guint16*) m0info->prefixes;
max = (guint16*) (m0info->prefixes + m0info->prefixes_size);
for (; p<max; p++) {
if (_is_treat_prefix(prefix_mask,(guint8*)p) ) {
GRID_WARN("prefix %02X%02X manage by two meta1 present in the request",((guint8*)p)[0],((guint8*)p)[1]);
error = NEWERROR(0, "prefix %02X%02X manage by two meta1 present in the request",((guint8*)p)[0],((guint8*)p)[1]);
goto errorLabel;
}
_treat_prefix(prefix_mask,(guint8*)p);
}
}
}
struct meta0_assign_meta1_s *aM1=NULL;
aM1=g_hash_table_lookup(context->map_meta1_ref,*urls);
if( !aM1) {
aM1 = g_malloc0(sizeof(struct meta0_assign_meta1_s));
aM1->addr=g_strdup(*urls);
aM1->score=0;
aM1->used=FALSE;
g_hash_table_insert(context->map_meta1_ref,strdup(*urls),aM1);
} else {
aM1->used=FALSE;
}
}
errorLabel :
meta0_utils_list_clean(prefixByMeta1);
g_free(prefix_mask);
return error;
}
static void
monitoring_loop(service_info_t *si)
{
long jiffies = 0;
GTimer *timer;
GError *error = NULL;
guint proc_count;
timer = g_timer_new();
monitor_get_status(svc_mon, si);
_add_custom_tags(si);
proc_count = supervisor_children_startall(NULL, NULL);
GRID_DEBUG("First started %u processes", proc_count);
while (flag_running) { /* main loop */
if (flag_restart_children) {
if (auto_restart_children) {
supervisor_children_repair(CHILD_KEY);
supervisor_children_enable(CHILD_KEY, TRUE);
proc_count = supervisor_children_startall(NULL,NULL);
GRID_DEBUG("Started %u processes", proc_count);
flag_restart_children = !!proc_count;
} else {
GRID_DEBUG("One of my children died, I will die too (auto_restart_children=%d)", auto_restart_children);
break;
}
}
if (!flag_running)
break;
gdouble elapsed = g_timer_elapsed(timer, NULL);
if (elapsed >= 1.0) {
if (!((++jiffies) % monitor_period)) {
monitor_get_status(svc_mon, si);
_add_custom_tags(si);
}
if (!register_namespace_service(si, &error)) {
GRID_WARN("Failed to register the service: %s", gerror_get_message(error));
g_clear_error(&error);
}
g_timer_reset(timer);
elapsed = 0.0;
}
g_usleep (1000000UL - ((gulong)elapsed));
}
supervisor_children_stopall(4);
supervisor_children_catharsis(NULL, NULL);
g_free(timer);
}
// TODO: factorize with the similar function in sqliterepo/synchro.h
static void
zk_main_watch(zhandle_t *zh, int type, int state, const char *path,
void *watcherCtx)
{
metautils_ignore_signals();
GRID_DEBUG("%s(%p,%d,%d,%s,%p)", __FUNCTION__,
zh, type, state, path, watcherCtx);
struct zk_manager_s *manager = watcherCtx;
const char *zkurl = manager->zk_url;
if (type != ZOO_SESSION_EVENT)
return;
if (state == ZOO_EXPIRED_SESSION_STATE) {
GRID_WARN("Zookeeper: (re)connecting to [%s]", zkurl);
if (manager->zh)
zookeeper_close(manager->zh);
/* XXX(jfs): forget the previous ID and reconnect */
manager->zh = zookeeper_init(manager->zk_url, zk_main_watch,
SQLX_SYNC_DEFAULT_ZK_TIMEOUT, NULL, manager, 0);
if (!manager->zh) {
GRID_ERROR("ZooKeeper init failure: (%d) %s",
errno, strerror(errno));
abort();
}
}
else if (state == ZOO_AUTH_FAILED_STATE) {
GRID_WARN("Zookeeper: auth problem to [%s]", zkurl);
}
else if (state == ZOO_ASSOCIATING_STATE) {
GRID_DEBUG("Zookeeper: associating to [%s]", zkurl);
}
else if (state == ZOO_CONNECTED_STATE) {
GRID_INFO("Zookeeper: connected to [%s]", zkurl);
}
else {
GRID_INFO("Zookeeper: unmanaged event [%s]", zkurl);
}
}
