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; }
GError * peer_restore(const gchar *target, struct sqlx_name_s *name, GByteArray *dump) { GError *err = NULL; if (!target) { g_byte_array_unref(dump); return NULL; } GByteArray *encoded = _pack_RESTORE(name, dump); struct gridd_client_s *client = gridd_client_create(target, encoded, NULL, NULL); g_byte_array_unref(encoded); if (!client) return NEWERROR(CODE_INTERNAL_ERROR, "Failed to create client to [%s], bad address?", target); gridd_client_set_timeout(client, SQLX_RESYNC_TIMEOUT); gridd_client_start(client); if (!(err = gridd_client_loop(client))) err = gridd_client_error(client); gridd_client_free(client); return err; }
GError* sqlx_remote_execute_RESTORE_many(gchar **targets, GByteArray *sid, struct sqlx_name_s *name, GByteArray *dump) { (void) sid; GError *err = NULL; GByteArray *req = sqlx_pack_RESTORE(name, dump->data, dump->len); struct 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 client_s **p = clients; !err && p && *p; p++) { err = gridd_client_error(*p); } gridd_clients_free(clients); return err; }
GError* sqlx_remote_execute_ADMGET(const gchar *target, GByteArray *sid, struct sqlx_name_s *name, const gchar *k, gchar **v) { (void) sid; GError *err = NULL; GByteArray *encoded = sqlx_pack_ADMGET(name, k); GByteArray *gba_buf = g_byte_array_new(); struct client_s *client = gridd_client_create(target, encoded, gba_buf, on_reply_gba); g_byte_array_unref(encoded); gridd_client_start(client); if (!(err = gridd_client_loop(client))) { if (!(err = gridd_client_error(client))) { gchar *buf = g_malloc0(gba_buf->len + 1); metautils_gba_data_to_string(gba_buf, buf, gba_buf->len + 1); *v = buf; } } gridd_client_free(client); metautils_gba_unref(gba_buf); return err; }
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); } }
GError* m2v2_remote_execute_DESTROY_many(gchar **targets, struct oio_url_s *url, guint32 flags) { if (!targets) return NEWERROR(CODE_INTERNAL_ERROR, "invalid target array (NULL)"); // TODO: factorize with sqlx_remote_execute_DESTROY_many GByteArray *req = m2v2_remote_pack_DESTROY(url, flags | M2V2_DESTROY_LOCAL); struct gridd_client_s **clients = gridd_client_create_many(targets, req, NULL, NULL); metautils_gba_unref(req); req = NULL; if (clients == NULL) return NEWERROR(0, "Failed to create gridd clients"); gridd_clients_start(clients); GError *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 == CODE_NOT_FOUND) { g_clear_error(&err); continue; } } gridd_clients_free(clients); return err; }
GError* sqlx_remote_execute_packed_DESTROY_many(gchar **targets, GByteArray *sid, GByteArray *req) { (void) sid; GError *err = NULL, *local_err = NULL; GPtrArray *targets_ok = g_ptr_array_new(); struct 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 (gchar **cursor = targets; cursor && *cursor; cursor++) { metautils_str_clean(cursor); } if (err) goto end; for (struct client_s **p = clients; p && *p; p++) { if (!(local_err = gridd_client_error(*p))) { g_ptr_array_add(targets_ok, g_strdup(gridd_client_url(*p))); continue; } if (local_err->code == CODE_CONTAINER_NOTFOUND || local_err->code == CODE_NOT_FOUND) { g_clear_error(&local_err); g_ptr_array_add(targets_ok, g_strdup(gridd_client_url(*p))); continue; } GRID_DEBUG("Database destruction attempts failed: (%d) %s", local_err->code, local_err->message); if (!err) g_propagate_prefixed_error(&err, local_err, "Failed to destroy base on %s: ", gridd_client_url(*p)); else g_clear_error(&local_err); } for (guint i = 0; i < targets_ok->len; i++) { targets[i] = g_ptr_array_index(targets_ok, i); } end: g_ptr_array_free(targets_ok, TRUE); gridd_clients_free(clients); return err; }
GError * gridd_clients_error(struct client_s **clients) { if (NULL != clients) { struct client_s *c; for (; (c = *clients) ;clients++) { GError *e = gridd_client_error(c); if (e != NULL) return e; } } return NULL; }
GError * gridd_client_run (struct gridd_client_s *self) { if (!self) return NEWERROR(CODE_INTERNAL_ERROR, "creation error"); if (!gridd_client_start(self)) return NEWERROR(CODE_INTERNAL_ERROR, "starting error"); GError *err; if (NULL != (err = gridd_client_loop (self))) return err; if (NULL != (err = gridd_client_error (self))) return err; return NULL; }
GError* sqlx_remote_execute_ADMSET(const gchar *target, GByteArray *sid, struct sqlx_name_s *name, const gchar *k, const gchar *v) { (void) sid; GError *err = NULL; GByteArray *encoded = sqlx_pack_ADMSET(name, k, v); struct client_s *client = gridd_client_create(target, encoded, NULL, NULL); g_byte_array_unref(encoded); gridd_client_start(client); if (!(err = gridd_client_loop(client))) err = gridd_client_error(client); gridd_client_free(client); return err; }
void gridd_clients_start(struct client_s **clients) { if (unlikely(NULL == clients)) return; for (; *clients ;++clients) { if (gridd_client_start(*clients)) continue; GError *err = gridd_client_error(*clients); GRID_WARN("STARTUP failed fd=%d [%s] : (%d) %s", gridd_client_fd(*clients), gridd_client_url(*clients), err ? err->code : 0, err ? err->message : "?"); if (err) g_clear_error(&err); } }
GError* sqlx_remote_execute_DESTROY(const gchar *target, GByteArray *sid, struct sqlx_name_s *name, gboolean local) { (void) sid; GError *err = NULL; GByteArray *req = sqlx_pack_DESTROY(name, local); struct gridd_client_s *client = gridd_client_create(target, req, NULL, NULL); g_byte_array_unref(req); gridd_client_start(client); if (!(err = gridd_client_loop(client))) { err = gridd_client_error(client); } gridd_client_free(client); return err; }
static gint do_query(struct gridd_client_s *client, struct meta1_service_url_s *surl, const gchar *Q) { gint rc = 0; GError *err; GByteArray *req; struct sqlx_name_mutable_s name; GRID_DEBUG("Querying [%s]", Q); sqlx_name_fill (&name, url, NAME_SRVTYPE_SQLX, surl->seq); req = sqlx_pack_QUERY_single(sqlx_name_mutable_to_const(&name), Q, FALSE); err = gridd_client_request(client, req, NULL, _on_reply); g_byte_array_unref(req); if (NULL != err) { g_printerr("Local error: (%d) %s\n", err->code, err->message); g_clear_error(&err); } else if (NULL != (err = gridd_client_loop(client))) { g_printerr("Local error: (%d) %s\n", err->code, err->message); g_clear_error(&err); } else { if (NULL != (err = gridd_client_error(client))) { g_printerr("SQLX error: (%d) %s\n", err->code, err->message); g_clear_error(&err); } else { GRID_DEBUG("SQLX query succeeded"); rc = 1; } } sqlx_name_clean (&name); return rc; }