static int
asn1_error_handler( worker_t *worker, GError **error )
{
worker_t *original_worker;
TRACE_POSITION();
GSETERROR(error, "Failed to send the 'erroneous containers flush' order");
original_worker = asn1_worker_get_session_data(worker);
if (!original_worker) {
GSETERROR(error,"Failed due to invalid worker");
return 0;
}
__respond_error( original_worker, error?*error:NULL, NULL );
return 1;
}
int
agent_flush_erroneous_container(worker_t *worker, GError **error)
{
GError *error_local = NULL;
request_t *req = NULL;
struct namespace_data_s *ns_data = NULL;
char ns_name[LIMIT_LENGTH_NSNAME+1];
gsize req_param_length;
TRACE_POSITION();
memset(ns_name, 0x00, sizeof(ns_name));
/*parse the request args, find the namespace*/
req = (request_t*) worker->data.session;
req_param_length = req->arg ? strlen(req->arg) : 0;
if (req_param_length<=0 || req_param_length>=LIMIT_LENGTH_NSNAME)
return __respond_message(worker, 0, "Invalid REQUEST format", error);
g_memmove( ns_name, req->arg, req_param_length);
ns_data = get_namespace(ns_name, &error_local);
if (!ns_data || !ns_data->configured)
return __respond_message(worker, 0, "NAMESPACE not found/ready", error);
DEBUG("Flushing the broken elements on [%s]", ns_name);
/*free outgoing data*/
if (ns_data->list_broken) {
g_slist_foreach( ns_data->list_broken, g_free1, NULL);
g_slist_free( ns_data->list_broken);
ns_data->list_broken = NULL;
}
/* Ask a distant flush, on the conscience */
if (!create_sub_worker(ns_data, worker, &error_local)) {
GSETERROR(&error_local, "Failed to connect to the conscience");
return __respond_error(worker, error_local, error);
}
/*free incomed data*/
if (ns_data->conscience && ns_data->conscience->broken_elements)
broken_holder_flush( ns_data->conscience->broken_elements );
if (error_local)
g_clear_error(&error_local);
worker->func = agent_worker_default_func;
return 1;
}
int
agent_receive_event_worker(worker_t *worker, GError **error)
{
GError *error_local;
worker_data_t *data;
request_t *req;
gchar ns_name[LIMIT_LENGTH_NSNAME+1];
struct namespace_data_s *ns_data;
const char *encoded_event;
gsize ns_name_len, encoded_event_size;
TRACE_POSITION();
memset(ns_name, 0x00, sizeof(ns_name));
ns_name_len = encoded_event_size = 0;
error_local = NULL;
data = &(worker->data);
req = (request_t*)data->session;
/* Unpack the NAMESPACE name and the EVENT serialized form:
* format: NAMESPACE\e00<BUFFER>*/
g_memmove(ns_name, req->arg, MIN(sizeof(ns_name)-1,req->arg_size));
ns_name_len = strlen(ns_name);
encoded_event = req->arg + (ns_name_len+1);
encoded_event_size = req->arg_size - (ns_name_len+1);
/* Check namespace */
if (!*ns_name)
return __respond_message(worker, 0, "Invalid format", error);
DEBUG("[ns=%s] Received an event of %"G_GSIZE_FORMAT" bytes (from %d)", ns_name, encoded_event_size, req->arg_size);
if (!(ns_data = g_hash_table_lookup(namespaces, ns_name)))
return __respond_message(worker, 0, "Unknown namespace '%s'", error);
if (!event_enable_receive)
return __respond_message(worker, 0, "Events not managed on this host", error);
if (!save_event_bytes(ns_data, (guint8*)encoded_event, encoded_event_size, &error_local))
return __respond_error(worker, error_local, error);
return __respond_message(worker, 1, "OK, event saved", error);
}
int
services_worker_list_local(worker_t * worker, GError ** error)
{
GSList *services;
GByteArray *gba;
response_t response;
memset(&response, 0, sizeof(response_t));
services = build_local_service_info_list();
gba = service_info_marshall_gba(services, error);
g_slist_free(services);
if (!gba) {
GSETERROR(error, "service_info list serialization error");
return __respond_error(worker, error ? *error : NULL, NULL);
}
return __respond(worker, 1, gba, error);
}
