path: root/src/task-factory.c

/*
     * Copyright (c) 2018 Samsung Electronics Co., Ltd.
 *
 * Licensed under the Flora License, Version 1.1 (the License);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://floralicense.org/license/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <glib.h>
#include <stdlib.h>
#include "task-factory.h"
#include "config.h"
#include "report-generator.h"
#include "report-json-serializer.h"
#include "log.h"
#include "err-check.h"
#include "macros.h"
#include "ipc.h"

static task_t *create_system_report_task(config_options_e options);
static task_t *create_load_avg_report_task();
static task_t *create_app_report_task(config_options_e options, const char *regex);
static task_t *create_top_report_task(struct config_data_top options);

static void execute_scan_system_memory(task_t *task);
static void execute_scan_system_cpu(task_t *task);
static void execute_scan_load_avg(task_t *task);
static void execute_scan_app_memory(task_t *task);
static void execute_scan_apps_cpu(task_t *task);
static void execute_scan_top_cpu(task_t *task);
static void execute_scan_top_memory(task_t *task);

static void release_system_task(task_t *task);
static void release_app_task(task_t *task);
static void release_top_task(task_t *task);

task_t *task_factory_create_task(const config_t *config)
{
    switch(config->scope)
    {
        case SYSTEM:
            return create_system_report_task(config->data.system.options);
        case LOAD_AVG:
            return create_load_avg_report_task();
        case APPS:
            return create_app_report_task(config->data.apps.options, config->data.apps.app_id);
        case TOP:
            return create_top_report_task(config->data.top);
        default:
            return NULL;
    }
}

static task_t *create_system_report_task(config_options_e options)
{
    system_task_t *_system_task = (system_task_t *)g_malloc(sizeof(system_task_t));

    _system_task->task.release = release_system_task;
    _system_task->report_generator = report_generator_new_system_report_generator();

    switch (options)
    {
        case OBSERVE_CPU:
            _system_task->task.execute = execute_scan_system_cpu;
            break;
        case OBSERVE_MEMORY:
            _system_task->task.execute = execute_scan_system_memory;
            break;
        default:
            report_generator_free_system_generator(_system_task->report_generator);
            g_free(_system_task);
            return NULL;
    }

    return &_system_task->task;
}

static task_t *create_load_avg_report_task()
{
    task_t *_load_avg_task = (task_t *)g_malloc(sizeof(task_t));

    _load_avg_task->execute = execute_scan_load_avg;
    _load_avg_task->release = NULL;

    return _load_avg_task;
}

static task_t *create_app_report_task(config_options_e options, const char *app_id)
{
    app_task_t *_app_task = (app_task_t *)g_malloc(sizeof(app_task_t));

    _app_task->task.release = release_app_task;
    _app_task->report_generator = report_generator_new_app_report_generator(app_id);

    switch (options)
    {
        case OBSERVE_CPU:
            _app_task->task.execute = execute_scan_apps_cpu;
            break;
        case OBSERVE_MEMORY:
            _app_task->task.execute = execute_scan_app_memory;
            break;
        default:
            report_generator_free_app_generator(_app_task->report_generator);
            g_free(_app_task);
            return NULL;
    }

    return &_app_task->task;
}

static void execute_scan_system_memory(task_t *task)
{
    ON_NULL_RETURN(task);

    system_task_t *_system_task = container_of(task, system_task_t, task);

    struct system_memory_usage_report report;

    int ret = report_generator_generate_system_memory_usage_report(_system_task->report_generator, &report);
    ON_TRUE_RETURN(ret != 0);

    char *json_report = report_json_serializer_serialize_system_memory_usage_report(&report);
    ipc_send_report(json_report);
    g_free(json_report);
}

static void execute_scan_system_cpu(task_t *task)
{
    ON_NULL_RETURN(task);

    system_task_t *_system_task = container_of(task, system_task_t, task);

    struct system_cpu_usage_report report;

    int ret = report_generator_generate_system_cpu_usage_report(_system_task->report_generator, 0, &report);
    ON_TRUE_RETURN(ret != 0);

    char *json_report = report_json_serializer_serialize_system_cpu_usage_report(&report);
    ipc_send_report(json_report);
    g_free(json_report);
}

static void execute_scan_load_avg(task_t *task)
{
    ON_NULL_RETURN(task);

    struct system_load_average_report report;

    int ret = report_generator_generate_load_average_report(&report);
    ON_TRUE_RETURN(ret != 0);

    char *json_report = report_json_serializer_serialize_system_load_average_report(&report);
    ipc_send_report(json_report);
    g_free(json_report);
}

static void execute_scan_app_memory(task_t *task)
{
    ON_NULL_RETURN(task);

    app_task_t *_app_task = container_of(task, app_task_t, task);

    struct app_memory_usage_report report;

    report_generator_generate_app_memory_usage_report(_app_task->report_generator, &report);

    char *json_report = report_json_serializer_serialize_apps_memory_usage_report(&report);
    ipc_send_report(json_report);
    g_free(json_report);
}

static void execute_scan_apps_cpu(task_t *task)
{
    ON_NULL_RETURN(task);

    app_task_t *_app_task = container_of(task, app_task_t, task);

    struct app_cpu_usage_report reports;

    report_generator_generate_app_cpu_usage_report(_app_task->report_generator, 0, &reports);

    char *json_report = report_json_serializer_serialize_apps_cpu_usage_report(&reports);
    ipc_send_report(json_report);
    g_free(json_report);
}

static void release_system_task(task_t *task)
{
    ON_NULL_RETURN(task);

    system_task_t *_system_task = container_of(task, system_task_t, task);

    report_generator_free_system_generator(_system_task->report_generator);
    g_free(_system_task);
}

static void release_app_task(task_t *task)
{
    ON_NULL_RETURN(task);

    app_task_t *_app_task = container_of(task, app_task_t, task);

    report_generator_free_app_generator(_app_task->report_generator);
    g_free(_app_task);
}

static task_t *create_top_report_task(struct config_data_top options)
{
    top_task_t *_top_task;
    report_generator_top_type_e type;
    task_execute_cb execute;

    switch (options.subject) {
       case TOP_SUBJECT_APPS:
          type = REPORT_GENERATOR_TOP_TYPE_APPS;
          break;
       case TOP_SUBJECT_ALL:
          type = REPORT_GENERATOR_TOP_TYPE_ALL;
          break;
       default:
          return NULL;
    }

    switch (options.options) {
       case OBSERVE_CPU:
            execute = execute_scan_top_cpu;
          break;
       case OBSERVE_MEMORY:
            execute = execute_scan_top_memory;
          break;
       default:
          return NULL;
    }

    _top_task = (top_task_t *)g_malloc(sizeof(top_task_t));
    _top_task->task.execute = execute;
    _top_task->task.release = release_top_task;
    _top_task->report_generator = report_generator_new_top_report_generator(type, options.top);
    if (!_top_task->report_generator) {
         g_free(_top_task);
         return NULL;
    }

    return &_top_task->task;
}

static void release_top_task(task_t *task)
{
    ON_NULL_RETURN(task);

    top_task_t *_top_task = container_of(task, top_task_t, task);

    report_generator_free_top_generator(_top_task->report_generator);
    g_free(_top_task);
}

static void execute_scan_top_cpu(task_t *task)
{
    ON_NULL_RETURN(task);
    top_task_t *_top_task = container_of(task, top_task_t, task);

    struct app_cpu_usage_report *reports;
    int n_reports;

    report_generator_generate_top_cpu_report(_top_task->report_generator, &reports, &n_reports);

    char *json_report = report_json_serializer_serialize_top_cpu_usage_reports(reports, n_reports);
    ipc_send_report(json_report);
    g_free(json_report);
    free(reports);
}

static void execute_scan_top_memory(task_t *task)
{
    ON_NULL_RETURN(task);
    top_task_t *_top_task = container_of(task, top_task_t, task);

    struct app_memory_usage_report *reports;
    int n_reports;

    report_generator_generate_top_memory_report(_top_task->report_generator, &reports, &n_reports);

    char *json_report = report_json_serializer_serialize_top_memory_usage_reports(reports, n_reports);
    ipc_send_report(json_report);
    g_free(json_report);
    free(reports);
}