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;
}
gs_error_t *
hc_delete_container(gs_grid_storage_t *hc, struct hc_url_s *url, int force, int flush)
{
gs_error_t *e = NULL;
gs_container_t *c = NULL;
unsigned int flags = 0;
if (force) flags |= M2V2_DESTROY_FORCE;
// to flush by meta2, but without event generated
//if (flush) flags |= M2V2_DESTROY_FLUSH;
c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, 0, &e);
if(NULL != c) {
// to flush by this process, but with event generated
if (flush) {
if (gs_flush_container(c, &e)) {
GRID_DEBUG("Container flushed\n");
}
}
// destroy container
if (!e) {
if (gs_destroy_container_flags (c, flags, &e)) {
GRID_DEBUG("Container deleted\n");
}
}
gs_container_free(c);
}
return e;
}
static gs_error_t *
hc_upload_content(gs_grid_storage_t *hc, struct hc_url_s *url, const char *local_path,
const char *stgpol, const char *sys_metadata, int ac, gboolean is_append)
{
int in = -1;
struct stat64 s;
gs_container_t *c = NULL;
gs_error_t *e = NULL;
/*init the local path */
if (-1 == stat64(local_path, &s)) {
e = g_malloc0(sizeof(gs_error_t));
e->code = errno;
e->msg = g_strdup_printf("Cannot stat the local file (%s)\n", strerror(errno));
return e;
}
GRID_DEBUG("Local path %s found\n", local_path);
if (-1 == (in = open(local_path, O_RDONLY|O_LARGEFILE))) {
e = g_malloc0(sizeof(gs_error_t));
e->code = errno;
e->msg = g_strdup_printf("Cannot open the local file (%s)\n", strerror(errno));
goto end_put;
}
GRID_DEBUG("Local path %s found and opened\n", local_path);
if(!(c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, ac, &e))) {
g_printerr("Failed to resolve and/or create meta2 entry for reference %s\n",
hc_url_get(url, HCURL_REFERENCE));
goto end_put;
}
/*upload the content */
if (is_append) {
if (!gs_append_content(c, hc_url_get(url, HCURL_PATH), s.st_size, _feed_from_fd, &in, &e)) {
goto end_put;
}
} else {
if (!gs_upload(c, hc_url_get(url, HCURL_PATH), s.st_size, _feed_from_fd,
&in, NULL, sys_metadata, stgpol, &e)) {
goto end_put;
}
}
GRID_INFO("Uploaded a new version of content [%s] in container [%s]\n\n",
hc_url_get(url, HCURL_PATH), hc_url_get(url, HCURL_REFERENCE));
GRID_DEBUG("Content successfully uploaded!\n");
end_put:
/** FIXME TODO XXX why not (in >= 0) or (in > -1) ? */
if (in > 1)
metautils_pclose(&in);
if(NULL != c) {
gs_container_free(c);
c = NULL;
}
return e;
}
static gboolean
_zmq2agent_send_event (time_t now, struct _zmq2agent_ctx_s *ctx,
struct event_s *evt, const char *dbg)
{
int rc;
if (ctx->last_error == now) {
GRID_DEBUG("ZMQ2AGENT event delayed, stream paused");
return FALSE;
}
evt->last_sent = now;
retry:
rc = zmq_send (ctx->zagent, "", 0, more|ZMQ_DONTWAIT);
if (rc == 0) {
rc = zmq_send (ctx->zagent, evt, HEADER_SIZE, more|ZMQ_DONTWAIT);
if (rc == HEADER_SIZE)
rc = zmq_send (ctx->zagent, evt->message, evt->size, ZMQ_DONTWAIT);
}
if (rc < 0) {
if (EINTR == (rc = zmq_errno ()))
goto retry;
ctx->last_error = evt->last_sent;
GRID_INFO("EVT:ERR %s (%d) %s", dbg, rc, zmq_strerror(rc));
return FALSE;
} else {
++ ctx->q->counter_sent;
ctx->last_error = 0;
GRID_DEBUG("EVT:SNT %s", dbg);
return TRUE;
}
}
static int
_meta2_filter_check_ns_name(struct gridd_filter_ctx_s *ctx,
struct gridd_reply_ctx_s *reply, int optional)
{
(void) reply;
TRACE_FILTER();
const struct meta2_backend_s *backend = meta2_filter_ctx_get_backend(ctx);
const char *req_ns = oio_url_get(meta2_filter_ctx_get_url(ctx), OIOURL_NS);
if (!backend || !backend->ns_name[0]) {
GRID_DEBUG("Missing information for namespace checking");
meta2_filter_ctx_set_error(ctx, SYSERR("backend not ready"));
return FILTER_KO;
}
if (!req_ns) {
if (optional)
return FILTER_OK;
GRID_DEBUG("Missing namespace name in request");
meta2_filter_ctx_set_error(ctx, BADREQ("No namespace"));
return FILTER_KO;
}
if (0 != g_ascii_strcasecmp(backend->ns_name, req_ns)) {
meta2_filter_ctx_set_error(ctx, BADNS());
return FILTER_KO;
}
return FILTER_OK;
}
/* XXX JFS dupplicated from sqliterepo/sqlite_utils.c */
static int
_sqlx_exec(sqlite3 *handle, const char *sql)
{
int rc, grc = SQLITE_OK;
sqlite3_stmt *stmt = NULL;
while ((grc == SQLITE_OK) && sql && *sql) {
const char *next = NULL;
rc = sqlite3_prepare(handle, sql, -1, &stmt, &next);
GRID_DEBUG("sqlite3_prepare(%s) = %d", sql, rc);
sql = next;
if (rc != SQLITE_OK && rc != SQLITE_DONE)
grc = rc;
else {
if (stmt) {
do {
rc = sqlite3_step(stmt);
GRID_DEBUG("sqlite3_step() = %d", rc);
} while (rc == SQLITE_ROW);
if (rc != SQLITE_OK && rc != SQLITE_DONE)
grc = rc;
}
}
if (stmt) {
rc = sqlite3_finalize(stmt);
GRID_DEBUG("sqlite3_finalize() = %d", rc);
stmt = NULL;
if (rc != SQLITE_OK && rc != SQLITE_DONE)
grc = rc;
}
}
return grc;
}
static int
_meta2_filter_check_ns_name(struct gridd_filter_ctx_s *ctx,
struct gridd_reply_ctx_s *reply, int optional)
{
(void) reply;
TRACE_FILTER();
const struct meta2_backend_s *backend = meta2_filter_ctx_get_backend(ctx);
const char *req_ns = oio_url_get(meta2_filter_ctx_get_url(ctx), OIOURL_NS);
if (!backend || !backend->ns_name[0]) {
GRID_DEBUG("Missing information for namespace checking");
meta2_filter_ctx_set_error(ctx, NEWERROR(CODE_INTERNAL_ERROR,
"Missing backend information, cannot check namespace"));
return FILTER_KO;
}
if (!req_ns) {
if (optional)
return FILTER_OK;
GRID_DEBUG("Missing namespace name in request");
meta2_filter_ctx_set_error(ctx, NEWERROR(CODE_BAD_REQUEST,
"Bad Request: Missing namespace name information"));
return FILTER_KO;
}
if (0 != g_ascii_strcasecmp(backend->ns_name, req_ns)) {
meta2_filter_ctx_set_error(ctx, NEWERROR(CODE_BAD_REQUEST,
"Request namespace [%s] does not match server namespace [%s]",
req_ns, backend->ns_name));
return FILTER_KO;
}
return FILTER_OK;
}
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;
}
GError *
network_server_run(struct network_server_s *srv)
{
struct endpoint_s **pu, *u;
time_t now, last_update;
GError *err = NULL;
/* Sanity checks */
EXTRA_ASSERT(srv != NULL);
for (pu=srv->endpointv; (u = *pu) ;pu++) {
if (u->fd < 0)
return NEWERROR(EINVAL,
"DESIGN ERROR : some servers are not open");
}
if (!srv->flag_continue)
return NULL;
for (pu=srv->endpointv; srv->flag_continue && (u = *pu) ;pu++)
ARM_ENDPOINT(srv, u, EPOLL_CTL_ADD);
ARM_WAKER(srv, EPOLL_CTL_ADD);
_server_start_one_worker(srv, FALSE);
srv->thread_events = g_thread_new("events", _thread_cb_events, srv);
clock_gettime(CLOCK_MONOTONIC_COARSE, &srv->now);
last_update = network_server_bogonow(srv);
while (srv->flag_continue) {
now = network_server_bogonow(srv);
if (last_update < now) {
_server_update_main_stats(srv);
last_update = now;
}
usleep(_start_necessary_threads(srv) ? 50000 : 500000);
clock_gettime(CLOCK_MONOTONIC_COARSE, &srv->now);
}
network_server_close_servers(srv);
/* Wait for all the workers */
while (srv->workers_total) {
GRID_DEBUG("Waiting for %u workers to die", srv->workers_total);
usleep(200000);
clock_gettime(CLOCK_MONOTONIC_COARSE, &srv->now);
}
srv->thread_first_worker = NULL;
/* wait for the first event thread */
if (srv->thread_events) {
g_thread_join(srv->thread_events);
srv->thread_events = NULL;
}
ARM_WAKER(srv, EPOLL_CTL_DEL);
GRID_DEBUG("Server %p exiting its main loop", srv);
return err;
}
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;
}
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);
}
gs_error_t *
hc_list_contents(gs_grid_storage_t *hc, struct hc_url_s *url, int output_xml, int show_info,
char **result)
{
gs_error_t *e = NULL;
gs_container_t *c = NULL;
const gchar *snapshot = hc_url_get(url, HCURL_SNAPORVERS);
struct list_content_s lc;
c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE), NULL, 0, &e);
if (NULL != c) {
GRID_DEBUG("%s found\n", hc_url_get(url, HCURL_REFERENCE));
lc.nb_elts = 0;
lc.xml = output_xml;
lc.show_info = show_info;
lc.buffer = g_string_new("");
lc.listed = NULL;
if(output_xml) {
g_string_append_printf(lc.buffer,
"<Container>\n"
" <Name>%s</Name>\n"
" <Contents>\n",
hc_url_get(url, HCURL_REFERENCE));
} else {
g_string_append_printf(lc.buffer, "#Listing container=[%s]\n", hc_url_get(url, HCURL_REFERENCE));
}
if (!gs_list_container_snapshot(c, NULL, _my_content_filter, &lc,
snapshot, &e)) {
g_printerr("Cannot list %s\n", hc_url_get(url, HCURL_REFERENCE));
g_string_free(lc.buffer, TRUE);
} else {
_sort_listed(&lc);
GRID_DEBUG("%s listed\n", hc_url_get(url, HCURL_REFERENCE));
if(output_xml) {
lc.buffer = g_string_append(lc.buffer,
" </Contents>\n"
"</Container>\n");
} else {
g_string_append_printf(lc.buffer, "#Total in [%s]: %i elements\n",
hc_url_get(url, HCURL_REFERENCE), lc.nb_elts);
}
*result = g_string_free(lc.buffer, FALSE);
}
gs_container_free(c);
return e;
}
g_printerr("Cannot find %s\n", hc_url_get(url, HCURL_REFERENCE));
return e;
}
static gpointer
_thread_cb_worker(gpointer td)
{
struct grid_stats_holder_s *local_stats = NULL;
time_t last_update, last_not_idle;
struct network_server_s *srv = td;
metautils_ignore_signals();
_thread_maybe_become_first(srv);
last_update = last_not_idle = network_server_bogonow(srv);
local_stats = grid_stats_holder_init();
GRID_DEBUG("Thread starting for srv %p", srv);
while (srv->flag_continue || srv->cnx_clients > 0) {
struct network_client_s *clt = get_next_client(srv);
if (!clt) {
gboolean expired = network_server_bogonow(srv) >
(last_not_idle + srv->workers_max_idle_delay);
if (expired && _thread_can_die(srv)) {
GRID_DEBUG("Thread idle for too long, exiting!");
goto label_exit;
}
}
else { /* something happened */
EXTRA_ASSERT(clt->server == srv);
_thread_become_active(srv);
last_not_idle = network_server_bogonow(srv);
clt->local_stats = local_stats;
_work_on_client(srv, clt);
_thread_become_inactive(srv);
}
/* periodically merge the local stats in the main stats */
if (last_update < network_server_bogonow(srv)) {
grid_stats_holder_increment_merge(srv->stats, local_stats);
grid_stats_holder_zero(local_stats);
last_update = network_server_bogonow(srv);
}
}
/* thread exiting due to a server stop */
GRID_DEBUG("Thread exiting for srv %p", srv);
_thread_stop(srv);
label_exit:
if (local_stats) {
grid_stats_holder_increment_merge(srv->stats, local_stats);
grid_stats_holder_clean(local_stats);
}
return td;
}
static gboolean
__test_location(gchar *loc, GSList *used_loc, gint64 distance)
{
GRID_DEBUG("Required distance is %ld", distance);
GSList *l = NULL;
for (l = used_loc; l && l->data; l = l->next) {
gint64 d = distance_between_location(loc, (gchar*) l->data);
GRID_DEBUG("-> found distance %ld", d);
if(d < distance)
return FALSE;
}
return TRUE;
}
static service_info_t *
_find_matching_rawx(GSList *rawx, GSList *used_loc, gint64 distance,
const gchar *stg_class, GSList **rawx_garbage)
{
GRID_DEBUG("Searching rawx distant of %"G_GINT64_FORMAT
" with storage class '%s'", distance, stg_class);
GSList *l = NULL;
gchar loc[1024];
struct service_tag_s * loc_tag = NULL;
GRID_DEBUG("Checking for an available rawx in a list of %d elements",
g_slist_length(rawx));
for (l = rawx; l && l->data; l = l->next) {
GRID_DEBUG("Checking one rawx...");
/* ensure service score */
if(((service_info_t*)l->data)->score.value <= 0) {
GRID_DEBUG("Rawx score <= 0");
continue;
}
/* ensure not spotted as unreachable */
if(_is_rawx_in_garbage((service_info_t*)l->data, *rawx_garbage)) {
GRID_DEBUG("Rawx already in unreachable list");
continue;
}
/* check rawx reachable */
if(!is_rawx_reachable((service_info_t*)l->data)) {
GRID_DEBUG("Rawx unreachable");
*rawx_garbage = g_slist_prepend(*rawx_garbage, l->data);
continue;
}
/* check rawx has appropriate storage class (strictly) */
if (!service_info_check_storage_class(l->data, stg_class)) {
GRID_DEBUG(MSG_DONT_MATCH_CRITERIA, "storage class");
continue;
}
/* ensure distance match with our policy */
bzero(loc, sizeof(loc));
loc_tag = service_info_get_tag(((service_info_t*)l->data)->tags, NAME_TAGNAME_RAWX_LOC);
GRID_DEBUG("service tag extracted");
if(!loc_tag) {
if(distance > 1) {
continue;
}
return ((service_info_t*)l->data);
}
service_tag_get_value_string(loc_tag, loc, sizeof(loc), NULL);
if(__test_location(loc, used_loc, distance)) {
return ((service_info_t*)l->data);
} else {
GRID_DEBUG(MSG_DONT_MATCH_CRITERIA, "distance");
}
}
return NULL;
}
GError *
meta2_filter_ctx_get_error(const struct gridd_filter_ctx_s *ctx)
{
if(!ctx || !ctx->output_data) {
GRID_DEBUG("uninitialized pointer : %p", ctx);
return NULL;
}
if(NULL != ctx->output_data->error) {
GRID_DEBUG("ctx error : %d, %s", ctx->output_data->error->code, ctx->output_data->error->message);
} else {
GRID_DEBUG("No error found in context");
}
return ctx->output_data->error;
}
gs_error_t *
hc_delete_content(gs_grid_storage_t *hc, struct hc_url_s *url)
{
gs_error_t *e = NULL;
gs_container_t *c = NULL;
gs_content_t *content = NULL;
c = gs_get_storage_container(hc, hc_url_get(url, HCURL_REFERENCE),NULL, 0, &e);
if(NULL != c) {
const gchar *version = hc_url_get(url, HCURL_VERSION);
// First try
content = gs_get_content_from_path_and_version (c, hc_url_get(url, HCURL_PATH), version, &e);
if (content == NULL && e != NULL && e->code == CODE_CONTENT_NOTFOUND && !version) {
// Last version is probably marked deleted, so a "get" without
// version fails. We need to specify we want the latest, even
// if it's deleted, so we can undelete it.
version = HCURL_LATEST_VERSION;
gs_error_free(e);
e = NULL;
// Second try
content = gs_get_content_from_path_and_version (c, hc_url_get(url, HCURL_PATH), version, &e);
}
if (NULL != content) {
if(gs_destroy_content (content, &e)) {
GRID_DEBUG("Content %s deleted\n", hc_url_get(url, HCURL_PATH));
}
gs_content_free(content);
}
gs_container_free(c);
}
return e;
}
static int
_open_destination(const char *local_path, int force, int *out)
{
/* Allow everything except execution (umask will apply) */
mode_t file_perms = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IWOTH|S_IROTH;
if (!local_path || !g_ascii_strcasecmp(local_path, "-")) {
*out = 1;
}
else {
*out = open(local_path, O_WRONLY | O_CREAT | (force ? O_TRUNC : O_EXCL),
file_perms);
if (-1 == *out) {
if (errno == ENOENT) {
*out = open(local_path, O_WRONLY | O_CREAT | O_EXCL, file_perms);
if (-1 == *out) {
g_printerr("Cannot create and open the local file %s (%s)\n", local_path,
strerror(errno));
return 0;
} else {
g_printerr("Local path %s created\n", local_path);
}
} else {
g_printerr("Cannot open the local file %s (%s)\n", local_path, strerror(errno));
return 0;
}
} else {
GRID_DEBUG("Local path %s opened\n", local_path);
}
}
return 1;
}
GError*
meta1_backend_services_config(struct meta1_backend_s *m1,
struct oio_url_s *url, const char *packedurl)
{
struct meta1_service_url_s *m1url;
if (!(m1url = meta1_unpack_url(packedurl)))
return NEWERROR(CODE_BAD_REQUEST, "Invalid URL");
GRID_DEBUG("About to reconfigure [%s] [%"G_GINT64_FORMAT"] [%s] [%s]",
m1url->srvtype, m1url->seq, m1url->host, m1url->args);
struct sqlx_sqlite3_s *sq3 = NULL;
GError *err = _open_and_lock(m1, url, M1V2_OPENBASE_MASTERONLY, &sq3);
if (err) {
g_free(m1url);
return err;
}
struct sqlx_repctx_s *repctx = NULL;
if (!(err = sqlx_transaction_begin(sq3, &repctx))) {
if (!(err = __info_user(sq3, url, FALSE, NULL)))
err = __configure_service(sq3, url, m1url);
if (!(err = sqlx_transaction_end(repctx, err)))
__notify_services_by_cid(m1, sq3, url);
}
sqlx_repository_unlock_and_close_noerror(sq3);
g_free(m1url);
return err;
}
/* Clear lines. This just frees and truncates the lines. */
void
grid_clear_lines(struct grid *gd, u_int py, u_int ny)
{
struct grid_line *gl;
u_int yy;
GRID_DEBUG(gd, "py=%u, ny=%u", py, ny);
if (ny == 0)
return;
if (grid_check_y(gd, py) != 0)
return;
if (grid_check_y(gd, py + ny - 1) != 0)
return;
for (yy = py; yy < py + ny; yy++) {
gl = &gd->linedata[yy];
if (gl->celldata != NULL)
xfree(gl->celldata);
if (gl->utf8data != NULL)
xfree(gl->utf8data);
memset(gl, 0, sizeof *gl);
}
}
static struct meta1_service_url_s *
__poll_services(struct meta1_backend_s *m1, guint replicas,
struct compound_type_s *ct, guint seq,
struct meta1_service_url_s **used, GError **err)
{
GRID_DEBUG("Polling %u [%s]", replicas, ct->fulltype);
// ----------------------------------------------------------------------
GPtrArray *ids = g_ptr_array_new_with_free_func(g_free);
oio_location_t *avoid = __locations_from_m1srvurl(used);
oio_location_t *known = NULL;
if (ct->req.k && !strcmp(ct->req.k, NAME_TAGNAME_USER_IS_SERVICE)) {
gchar srvurl[64] = {0};
g_snprintf(srvurl, sizeof(srvurl), "1||%s|", ct->req.v);
struct meta1_service_url_s *inplace[2] = {
meta1_unpack_url(srvurl), NULL
};
/* If ct->req.v is not an addr, known will contain NULL */
// FIXME: this should be in `avoid` instead of `known`
// but avoids are compared without the location mask
known = __locations_from_m1srvurl(inplace);
meta1_service_url_clean(inplace[0]);
}
void _on_id(oio_location_t loc, const char *id)
{
(void)loc;
g_ptr_array_add(ids, g_strdup(id));
}
static GError *
_create_on_meta2(const gchar *srv, const gchar *vns, const gchar *cname,
container_id_t cid, struct addr_info_s *m2addr)
{
gboolean rc;
GError *err = NULL;
GRID_DEBUG("Creation attempt on META2 at [%s]", srv);
if (!srv_to_addr(srv, m2addr))
return g_error_new(gquark_log, 500, "Invalid address (%d %s)",
errno, strerror(errno));
rc = vns && *vns
? meta2_remote_container_create_v2(m2addr, 30000, &err, cid, cname, vns)
: meta2_remote_container_create(m2addr, 30000, &err, cid, cname);
if (!rc) {
if (!err)
return g_error_new(gquark_log, 502,
"Unknown error when contacting META2");
g_prefix_error(&err, "META2 error : ");
return err;
}
return NULL;
}
GError*
sqlx_remote_execute_DESTROY_many(gchar **targets, GByteArray *sid,
struct sqlx_name_s *name)
{
(void) sid;
GError *err = NULL;
GByteArray *req = sqlx_pack_DESTROY(name, TRUE);
struct gridd_client_s **clients = gridd_client_create_many(targets, req,
NULL, NULL);
metautils_gba_unref(req);
req = NULL;
if (clients == NULL) {
err = NEWERROR(0, "Failed to create gridd clients");
return err;
}
gridd_clients_start(clients);
err = gridd_clients_loop(clients);
for (struct gridd_client_s **p = clients; !err && p && *p ;p++) {
if (!(err = gridd_client_error(*p)))
continue;
GRID_DEBUG("Database destruction attempts failed: (%d) %s",
err->code, err->message);
if (err->code == CODE_CONTAINER_NOTFOUND || err->code == 404) {
g_clear_error(&err);
continue;
}
}
gridd_clients_free(clients);
return err;
}
static gint
do_queryv(struct meta1_service_url_s *surl)
{
gint rc;
gchar **pq;
struct gridd_client_s *client;
GRID_DEBUG("Contacting SHARD[%"G_GINT64_FORMAT"] at [%s][%s]",
surl->seq, surl->host, surl->args);
client = gridd_client_create_idle(surl->host);
gridd_client_set_keepalive(client, TRUE);
gridd_client_start(client);
rc = 1;
for (pq=query; *pq ;pq++) {
if (!do_query(client, surl, *pq)) {
rc = 0;
break;
}
}
gridd_client_free(client);
return rc;
}
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();
}
/* Scroll a region up, moving the top line into the history. */
void
grid_scroll_history_region(struct grid *gd, u_int upper, u_int lower)
{
struct grid_line *gl_history, *gl_upper, *gl_lower;
u_int yy;
GRID_DEBUG(gd, "upper=%u, lower=%u", upper, lower);
/* Create a space for a new line. */
yy = gd->hsize + gd->sy;
gd->linedata = xrealloc(gd->linedata, yy + 1, sizeof *gd->linedata);
/* Move the entire screen down to free a space for this line. */
gl_history = &gd->linedata[gd->hsize];
memmove(gl_history + 1, gl_history, gd->sy * sizeof *gl_history);
/* Adjust the region and find its start and end. */
upper++;
gl_upper = &gd->linedata[upper];
lower++;
gl_lower = &gd->linedata[lower];
/* Move the line into the history. */
memcpy(gl_history, gl_upper, sizeof *gl_history);
/* Then move the region up and clear the bottom line. */
memmove(gl_upper, gl_upper + 1, (lower - upper) * sizeof *gl_upper);
memset(gl_lower, 0, sizeof *gl_lower);
/* Move the history offset down over the line. */
gd->hsize++;
}
/* Clear area. */
void
grid_clear(struct grid *gd, u_int px, u_int py, u_int nx, u_int ny)
{
u_int xx, yy;
GRID_DEBUG(gd, "px=%u, py=%u, nx=%u, ny=%u", px, py, nx, ny);
if (nx == 0 || ny == 0)
return;
if (px == 0 && nx == gd->sx) {
grid_clear_lines(gd, py, ny);
return;
}
if (grid_check_y(gd, py) != 0)
return;
if (grid_check_y(gd, py + ny - 1) != 0)
return;
for (yy = py; yy < py + ny; yy++) {
if (px >= gd->linedata[yy].cellsize)
continue;
if (px + nx >= gd->linedata[yy].cellsize) {
gd->linedata[yy].cellsize = px;
continue;
}
for (xx = px; xx < px + nx; xx++) {
if (xx >= gd->linedata[yy].cellsize)
break;
grid_put_cell(gd, xx, yy, &grid_default_cell);
}
}
}
int meta2_filter_action_purge_container(struct gridd_filter_ctx_s *ctx,
struct gridd_reply_ctx_s *reply)
{
(void) reply;
SRVSTUB_PRINTF("packet received...PURGE");
// M2V2_MODE_DRYRUN, ...
guint32 flags = 0;
const char *fstr = NULL;
if (NULL != fstr)
flags = (guint32) g_ascii_strtoull(fstr, NULL, 10);
GSList* del_chunks_list = NULL;
if (NULL != g_err) {
GRID_DEBUG("Container purge failed (%d) : %s", g_err->code, g_err->message);
//meta2_filter_ctx_set_error(ctx, err);
return FILTER_KO;
}
reply->add_body(bean_sequence_marshall(g_responsedata));
reply->send_reply(200, "OK");
_bean_cleanl2(del_chunks_list);
return FILTER_OK;
}
/* Move a group of cells. */
void
grid_move_cells(struct grid *gd, u_int dx, u_int px, u_int py, u_int nx)
{
struct grid_line *gl;
u_int xx;
GRID_DEBUG(gd, "dx=%u, px=%u, py=%u, nx=%u", dx, px, py, nx);
if (nx == 0 || px == dx)
return;
if (grid_check_y(gd, py) != 0)
return;
gl = &gd->linedata[py];
grid_expand_line(gd, py, px + nx);
grid_expand_line(gd, py, dx + nx);
memmove(
&gl->celldata[dx], &gl->celldata[px], nx * sizeof *gl->celldata);
if (gl->utf8data != NULL) {
grid_expand_line_utf8(gd, py, px + nx);
grid_expand_line_utf8(gd, py, dx + nx);
memmove(&gl->utf8data[dx],
&gl->utf8data[px], nx * sizeof *gl->utf8data);
}
/* Wipe any cells that have been moved. */
for (xx = px; xx < px + nx; xx++) {
if (xx >= dx && xx < dx + nx)
continue;
grid_put_cell(gd, xx, py, &grid_default_cell);
}
}
static int
_list_NORMAL(struct gridd_filter_ctx_s *ctx, struct gridd_reply_ctx_s *reply,
struct list_params_s *lp)
{
GError *e = NULL;
struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);
struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);
struct on_bean_ctx_s *obc = _on_bean_ctx_init(ctx, reply);
if (hc_url_has(url, HCURL_SNAPSHOT)) {
lp->snapshot_name = hc_url_get(url, HCURL_SNAPSHOT);
} else if (hc_url_has(url, HCURL_VERSION)) {
lp->snapshot_name = hc_url_get(url, HCURL_VERSION);
}
e = meta2_backend_list_aliases(m2b, url, lp, _get_cb, obc);
if (NULL != e) {
GRID_DEBUG("Fail to return alias for url: %s",
hc_url_get(url, HCURL_WHOLE));
_on_bean_ctx_clean(obc);
meta2_filter_ctx_set_error(ctx, e);
return FILTER_KO;
}
_on_bean_ctx_send_list(obc, TRUE);
_on_bean_ctx_clean(obc);
return FILTER_OK;
}
