src/task-factory.c

   1 /*
   2      * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <glib.h>
  18 #include <stdlib.h>
  19 #include "task-factory.h"
  20 #include "config.h"
  21 #include "report-generator.h"
  22 #include "report-json-serializer.h"
  23 #include "log.h"
  24 #include "err-check.h"
  25 #include "macros.h"
  26
  27 static task_t *create_system_report_task(config_options_e options);
  28 static task_t *create_load_avg_report_task();
  29 static task_t *create_app_report_task(config_options_e options, const char *regex);
  30
  31 static void execute_scan_system_memory(task_t *task);
  32 static void execute_scan_system_cpu(task_t *task);
  33 static void execute_scan_load_avg(task_t *task);
  34 static void execute_scan_app_memory(task_t *task);
  35 static void execute_scan_apps_cpu(task_t *task);
  36
  37 static void send_report(char *report);
  38
  39 static void release_system_task(task_t *task);
  40 static void release_app_task(task_t *task);
  41
  42 task_t *task_factory_create_single(const config_t *config)
  43 {
  44     switch(config->scope)
  45     {
  46         case SYSTEM:
  47             return create_system_report_task(config->data.system.options);
  48         case LOAD_AVG:
  49             return create_load_avg_report_task();
  50         case APPS:
  51             return create_app_report_task(config->data.apps.options, config->data.apps.app_id);
  52         case TOP:
  53         default:
  54             return NULL;
  55     }
  56 }
  57
  58 static task_t *create_system_report_task(config_options_e options)
  59 {
  60     system_task_t *_system_task = (system_task_t *)g_malloc(sizeof(system_task_t));
  61
  62     _system_task->task.release = release_system_task;
  63     _system_task->report_generator = report_generator_new_system_report_generator();
  64
  65     switch (options)
  66     {
  67         case OBSERVE_CPU:
  68             _system_task->task.execute = execute_scan_system_cpu;
  69             break;
  70         case OBSERVE_MEMORY:
  71             _system_task->task.execute = execute_scan_system_memory;
  72             break;
  73         default:
  74             report_generator_free_system_generator(_system_task->report_generator);
  75             g_free(_system_task);
  76             return NULL;
  77     }
  78
  79     return &_system_task->task;
  80 }
  81
  82 static task_t *create_load_avg_report_task()
  83 {
  84     task_t *_load_avg_task = (task_t *)g_malloc(sizeof(task_t));
  85
  86     _load_avg_task->execute = execute_scan_load_avg;
  87     _load_avg_task->release = NULL;
  88
  89     return _load_avg_task;
  90 }
  91
  92 static task_t *create_app_report_task(config_options_e options, const char *app_id)
  93 {
  94     app_task_t *_app_task = (app_task_t *)g_malloc(sizeof(app_task_t));
  95
  96     _app_task->task.release = release_app_task;
  97     _app_task->report_generator = report_generator_new_app_report_generator(app_id);
  98
  99     switch (options)
 100     {
 101         case OBSERVE_CPU:
 102             _app_task->task.execute = execute_scan_apps_cpu;
 103             break;
 104         case OBSERVE_MEMORY:
 105             _app_task->task.execute = execute_scan_app_memory;
 106             break;
 107         default:
 108             report_generator_free_app_generator(_app_task->report_generator);
 109             g_free(_app_task);
 110             return NULL;
 111     }
 112
 113     return &_app_task->task;
 114 }
 115
 116 static void execute_scan_system_memory(task_t *task)
 117 {
 118     ON_NULL_RETURN(task);
 119
 120     system_task_t *_system_task = container_of(task, system_task_t, task);
 121
 122     struct system_memory_usage_report report;
 123
 124     int ret = report_generator_generate_system_memory_usage_report(_system_task->report_generator, &report);
 125     ON_TRUE_RETURN(ret != 0);
 126
 127     char *json_report = report_json_serializer_serialize_system_memory_usage_report(&report);
 128     send_report(json_report);
 129     g_free(json_report);
 130 }
 131
 132 static void execute_scan_system_cpu(task_t *task)
 133 {
 134     ON_NULL_RETURN(task);
 135
 136     system_task_t *_system_task = container_of(task, system_task_t, task);
 137
 138     struct system_cpu_usage_report report;
 139
 140     int ret = report_generator_generate_system_cpu_usage_report(_system_task->report_generator, 0, &report);
 141     ON_TRUE_RETURN(ret != 0);
 142
 143     char *json_report = report_json_serializer_serialize_system_cpu_usage_report(&report);
 144     send_report(json_report);
 145     g_free(json_report);
 146 }
 147
 148 static void execute_scan_load_avg(task_t *task)
 149 {
 150     ON_NULL_RETURN(task);
 151
 152     struct system_load_average_report report;
 153
 154     int ret = report_generator_generate_load_average_report(&report);
 155     ON_TRUE_RETURN(ret != 0);
 156
 157     char *json_report = report_json_serializer_serialize_system_load_average_report(&report);
 158     send_report(json_report);
 159     g_free(json_report);
 160 }
 161
 162 static void execute_scan_app_memory(task_t *task)
 163 {
 164     ON_NULL_RETURN(task);
 165
 166     app_task_t *_app_task = container_of(task, app_task_t, task);
 167
 168     struct app_memory_usage_report reports;
 169
 170     report_generator_generate_app_memory_usage_report(_app_task->report_generator, &reports);
 171
 172     char *json_report = report_json_serializer_serialize_apps_memory_usage_report(&reports);
 173     send_report(json_report);
 174     g_free(json_report);
 175 }
 176
 177 static void execute_scan_apps_cpu(task_t *task)
 178 {
 179     ON_NULL_RETURN(task);
 180
 181     app_task_t *_app_task = container_of(task, app_task_t, task);
 182
 183     struct app_cpu_usage_report reports;
 184
 185     report_generator_generate_app_cpu_usage_report(_app_task->report_generator, 0, &reports);
 186
 187     char *json_report = report_json_serializer_serialize_apps_cpu_usage_report(&reports);
 188     send_report(json_report);
 189     g_free(json_report);
 190 }
 191
 192 static void send_report(char *report)
 193 {
 194     //TODO send report here
 195 }
 196
 197 static void release_system_task(task_t *task)
 198 {
 199     ON_NULL_RETURN(task);
 200
 201     system_task_t *_system_task = container_of(task, system_task_t, task);
 202
 203     report_generator_free_system_generator(_system_task->report_generator);
 204     g_free(_system_task);
 205 }
 206
 207 static void release_app_task(task_t *task)
 208 {
 209     ON_NULL_RETURN(task);
 210
 211     app_task_t *_app_task = container_of(task, app_task_t, task);
 212
 213     report_generator_free_app_generator(_app_task->report_generator);
 214     g_free(_app_task);
 215 }