/**
* FIXME TODO XXX file load duplicated at cluster/lib/gridcluster.c : gba_read()
*/
static int
cpu_stat_task_worker(gpointer udata, GError ** error)
{
char end_of_buffer = '\0';
int fd = 0;
ssize_t rl;
char *procstat = NULL;
GByteArray *buffer = NULL;
char buff[DEFAULT_BUFFER_SIZE];
proc_stat_t pstat;
(void)udata;
fd = open(PROC_STAT, O_RDONLY);
if (fd < 0) {
GSETERROR(error, "Failed to open file [%s] : %s", PROC_STAT, strerror(errno));
task_done(TASK_ID);
return 0;
}
buffer = g_byte_array_new();
while ((rl = read(fd, buff, DEFAULT_BUFFER_SIZE)) > 0)
buffer = g_byte_array_append(buffer, (guint8*)buff, rl);
metautils_pclose(&fd);
if (rl < 0) {
GSETERROR(error, "Read file [%s] failed with error : %s", PROC_STAT, strerror(errno));
g_byte_array_free(buffer, TRUE);
task_done(TASK_ID);
return 0;
}
/*ensure the statistics string is NULL-terminated */
g_byte_array_append(buffer, (guint8*)&end_of_buffer, sizeof(end_of_buffer));
procstat = (char*)g_byte_array_free(buffer, FALSE);
memset(&pstat, 0, sizeof(proc_stat_t));
if (sscanf(procstat, "cpu %llu %llu %llu %llu %llu %llu %llu",
&(pstat.user), &(pstat.nice), &(pstat.system), &(pstat.idle),
&(pstat.io_wait), &(pstat.irq), &(pstat.soft_irq)) == 7) {
memcpy(&(cpu_stat.previous), &(cpu_stat.current), sizeof(proc_stat_t));
memcpy(&(cpu_stat.current), &pstat, sizeof(proc_stat_t));
nb_loops++;
}
else {
WARN("Failed to scan cpu in string [%s]", procstat);
}
g_free(procstat);
task_done(TASK_ID);
return (1);
}
/* Task 2 Binary Search Tree -- search */
void task_3(){
//start_Task3:
//puts("task3\n");
//search_node(s_search_tree, 5);
//search_node(s_search_tree, 6);
//search_node(s_search_tree, 12);
/*putchar(10);*/
// CLI
putchar('C');
// STI
for(int i=0;i<5;i++){
int dest0 = reverse_integer(123456789);
int dest1 = reverse_integer(-123456789);
int dest2 = reverse_integer(0);
int dest3 = reverse_integer(1000);
int dest4 = reverse_integer(-1000);
}
/*putchar('w');*/
/*putchar(10);*/
if(wait_after_done){
task_done(s_processor);
// goto start_Task3;
while (1)
{
/* putchar('C');*/
/*putchar(10);*/
}
}
}
static gboolean
task_starter(gpointer udata, GError **error)
{
gpointer ns_k, ns_v;
GHashTableIter ns_iterator;
task_t *task;
gchar ns_id[sizeof(TASK_ID)+1+LIMIT_LENGTH_NSNAME];
namespace_data_t *ns_data;
(void)udata;
g_hash_table_iter_init(&ns_iterator, namespaces);
while (g_hash_table_iter_next(&ns_iterator,&ns_k,&ns_v)) {
ns_data = ns_v;
g_snprintf(ns_id,sizeof(ns_id),TASK_ID".%s",ns_data->name);
if (!namespace_is_available(ns_data)) {
if (!is_task_scheduled(ns_id)) {
task = create_task(period_get_ns, ns_id);
task = set_task_callbacks(task, task_worker, g_free, g_strdup(ns_data->name));
if (!add_task_to_schedule(task, error)) {
ERROR("[task_id="TASK_ID"] Failed to start a sub worker for namespace '%s'", (gchar*)ns_k);
g_free(task);
}
else
INFO("[task_id="TASK_ID"] subtask started [%s]", ns_id);
}
}
}
task_done(TASK_ID);
return 1;
}
static void
session_data_cleaner(gpointer p)
{
gchar task_id[sizeof(TASK_ID)+1+LIMIT_LENGTH_NSNAME];
if (!p)
return;
g_snprintf(task_id, sizeof(task_id), TASK_ID".%s", (gchar*)p);
task_done(task_id);
g_free(p);
}
void reboot(void)
{
task_done();
#ifdef CONFIG_DEBUG
log(LF_OTHER, LVL_DEBUG, "Rebooting the system");
#endif
arch_reboot();
halt();
}
void reboot(void)
{
task_done();
#ifdef CONFIG_DEBUG
printf("Rebooting the system\n");
#endif
arch_reboot();
halt();
}
static int
final_handler(worker_t *worker, GError **error)
{
gchar *ns_name;
gchar task_id[sizeof(TASK_ID)+1+LIMIT_LENGTH_NSNAME];
(void)error;
ns_name = asn1_worker_get_session_data(worker);
g_snprintf(task_id, sizeof(task_id), TASK_ID".%s", ns_name);
task_done(task_id);
return 1;
}
static int
error_handler(worker_t *worker, GError **error)
{
gchar *ns_name;
gchar task_id[sizeof(TASK_ID)+1+LIMIT_LENGTH_NSNAME];
ns_name = asn1_worker_get_session_data(worker);
if (ns_name)
GSETERROR(error, "[task_id=%s.%s] Failed to request namespace info", TASK_ID, ns_name);
else
GSETERROR(error, "[task_id=%s.?] Failed to request namespace info", TASK_ID);
g_snprintf(task_id, sizeof(task_id), TASK_ID".%s", ns_name);
task_done(task_id);
return(1);
}
static void
_check_tcp_service_worker_cleaner(worker_t *worker)
{
struct workerdata_checksrv_s *wdata;
wdata = worker->data.session;
task_done(wdata->task_name);
if (wdata->flag_connected) {
_mark_service_state(wdata->ns_name, wdata->srv_key, TRUE);
DEBUG("Connection attempt successful to [%s/%s]", wdata->ns_name, wdata->srv_key);
}
else {
_mark_service_state(wdata->ns_name, wdata->srv_key, FALSE);
WARN("Connection attempt failed to [%s/%s]", wdata->ns_name, wdata->srv_key);
}
g_free(wdata);
}
/**
* Starts a
*/
static int
allservices_check_starter(gpointer udata, GError **error)
{
GHashTableIter iter_ns;
gpointer k, v;
(void) udata;
(void) error;
/*ensure there is a task started for each services locally registered*/
g_hash_table_iter_init(&iter_ns, namespaces);
while (g_hash_table_iter_next(&iter_ns, &k, &v)) {
struct namespace_data_s *ns_data = v;
TRACE("Checking NS=[%s]", (gchar*)k);
allservice_check_start_HT(ns_data, ns_data->local_services);
allservice_check_start_HT(ns_data, ns_data->down_services);
_detect_obsolete_services(ns_data);
}
task_done(TASK_ID);
return 1;
}
/* Task 1 Reverse Integer */
void task_1() {
//start_Task1:
if(wait_after_done==0){
/*puts("task1 start\n");*/
/* putchar(10);*/
/*putchar('1');*/
/*putchar('s');*/
/*putchar(10);*/
}
// CLI
__asm__("j7 7");
putchar('A');
//
int dest0 = reverse_integer(123456789);
int dest1 = reverse_integer(-123456789);
int dest2 = reverse_integer(0);
putchar('a');
int dest3 = reverse_integer(1000);
int dest4 = reverse_integer(-1000);
// putchar('a');
if(wait_after_done==1){
task_done(s_processor);
// goto start_Task1;
while (1)
{
// CLI
/* putchar('A');*/
/*putchar(10);*/
// STI
}
}else{
/*puts("task1 done\n");*/
/* putchar('1');*/
/*putchar('e');*/
/*putchar(10);*/
}
}
/* Task 2 Binary Search Tree -- insert & delete */
void task_2(){
//start_Task2:
//puts("task2\n");
//insert(s_search_tree, 14);
//insert(s_search_tree, 15);
//insert(s_search_tree, 2);
//delete(s_search_tree, 14);
//delete(s_search_tree, 15);
//delete(s_search_tree, 2);
// CLI
putchar('B');
// STI
for(int i=0;i<3;i++){
int dest0 = reverse_integer(123456789);
int dest1 = reverse_integer(-123456789);
int dest2 = reverse_integer(0);
int dest3 = reverse_integer(1000);
int dest4 = reverse_integer(-1000);
}
putchar('b');
if(wait_after_done){
task_done(s_processor);
// goto start_Task2;
while (1)
{
// CLI
/* putchar('B');*/
/*putchar(10);*/
// STI
}
}
}
/**
* Check the service still exists and start a worker that will
* just perform a TCP-connect test.
*/
static int
_check_tcp_service_task(gpointer udata, GError **error)
{
struct service_info_s *si;
struct namespace_data_s *ns_data;
struct taskdata_checksrv_s *task_data;
task_data = udata;
ns_data = g_hash_table_lookup(namespaces, task_data->ns_name);
if (!ns_data) {
task_done(task_data->task_name);
GSETERROR(error, "Namespace unavailable");
return 0;
}
/* if the service does not exists, the task itself is de-scheduled */
if (!(si=g_hash_table_lookup(ns_data->local_services, task_data->srv_key))
&& !(si=g_hash_table_lookup(ns_data->down_services, task_data->srv_key))) {
task_done(task_data->task_name);
task_stop(task_data->task_name);
INFO("Service [%s] does not exist, stopping task [%s]", task_data->srv_key, task_data->task_name);
return 1;
}
/* Now start a worker for this service. The worker has its own session_data,
* without hard reference to the task_t or the namespace_data_t */
do {
int fd = addrinfo_connect_nopoll(&(si->addr), 1000, error);
if (0 > fd) {
GSETERROR(error, "Connection to gridd server failed : (%d) %s",
errno, strerror(errno));
return 0;
}
sock_set_linger(fd, 1, 0);
struct workerdata_checksrv_s *wdata = g_malloc0(sizeof(*wdata));
g_strlcpy(wdata->task_name, task_data->task_name, sizeof(wdata->task_name)-1);
g_strlcpy(wdata->ns_name, task_data->ns_name, sizeof(wdata->ns_name)-1);
g_strlcpy(wdata->srv_key, task_data->srv_key, sizeof(wdata->srv_key)-1);
worker_t *worker = g_malloc0(sizeof(worker_t));
worker->func = _check_tcp_service_worker_func;
worker->clean = _check_tcp_service_worker_cleaner;
worker->timeout.startup = 1000;
worker->timeout.activity = 1000;
worker->data.sock_timeout = 1000;
worker->data.fd = fd;
worker->data.session = wdata;
if (!add_fd_to_io_scheduler(worker, EPOLLOUT, error)) {
_mark_service_state(task_data->ns_name, wdata->srv_key, FALSE);
task_done(task_data->task_name);
g_free(worker);
g_free(wdata);
GSETERROR(error, "Failed to add socket fd=%d to io_scheduler : %s", fd, strerror(errno));
return 0;
}
TRACE("TCP-connect tried to [%s] for [%s] (fd=%d)", task_data->srv_key, task_data->task_name, fd);
} while (0);
return 1;
}
