email-core/email-core-task-manager.c

   1 /*
   2 *  email-service
   3 *
   4 * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5 *
   6 * Contact: Kyuho Jo <kyuho.jo@samsung.com>, Sunghyun Kwon <sh0701.kwon@samsung.com>
   7 *
   8 * Licensed under the Apache License, Version 2.0 (the "License");
   9 * you may not use this file except in compliance with the License.
  10 * You may obtain a copy of the License at
  11 *
  12 * http://www.apache.org/licenses/LICENSE-2.0
  13 *
  14 * Unless required by applicable law or agreed to in writing, software
  15 * distributed under the License is distributed on an "AS IS" BASIS,
  16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * See the License for the specific language governing permissions and
  18 * limitations under the License.
  19 *
  20 */
  21
  22 /*
  23  * email-core-task-manager.c
  24  *
  25  *  Created on: 2012. 11. 1.
  26  *      Author: kyuho.jo@samsung.com
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <pthread.h>
  32 #include <dbus/dbus.h>
  33
  34 #include "email-internal-types.h"
  35 #include "email-utilities.h"
  36 #include "email-core-tasks.h"
  37 #include "email-core-task-manager.h"
  38 #include "email-core-signal.h"
  39 #include "email-core-global.h"
  40 #include "email-core-utils.h"
  41 #include "email-debug-log.h"
  42
  43 /* TODO : implement a function for removing a task from task pool */
  44 /* TODO : after fetching a task from DB, update status of the task. */
  45
  46
  47 #define REGISTER_TASK_BINDER(TASK_NAME) emcore_register_task_handler(TASK_NAME, task_handler_##TASK_NAME, email_encode_task_parameter_##TASK_NAME, email_decode_task_parameter_##TASK_NAME)
  48
  49 /*- variables - begin --------------------------------------------------------*/
  50 static pthread_cond_t  _task_available_signal   = PTHREAD_COND_INITIALIZER;
  51 static pthread_mutex_t _task_available_lock     = PTHREAD_MUTEX_INITIALIZER;
  52 static pthread_mutex_t _task_manager_loop_lock  = PTHREAD_MUTEX_INITIALIZER;
  53 static pthread_mutex_t _active_task_pool_lock   = PTHREAD_MUTEX_INITIALIZER;
  54
  55 static email_active_task_t _active_task_pool[MAX_ACTIVE_TASK];
  56 static thread_t            _thread_task_manager_loop;
  57 static int                 _task_manager_loop_availability = 1;
  58 /*- variables - end ----------------------------------------------------------*/
  59 static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id);
  60 static int emcore_remove_task_from_active_task_pool(int input_task_id);
  61 static int emcore_find_available_slot_in_active_task_pool(int *result_index);
  62 static int emcore_update_task_status_on_task_table(char *multi_user_name, int input_task_id, email_task_status_type_t task_status);
  63 static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler);
  64
  65 /*- task handlers helpers - begin --------------------------------------------*/
  66 static int emcore_initialize_async_task_handler(email_task_t *input_task)
  67 {
  68         EM_DEBUG_FUNC_BEGIN("input_task [%p]", input_task);
  69         int err = EMAIL_ERROR_NONE;
  70
  71         if(input_task == NULL) {
  72                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
  73                 err = EMAIL_ERROR_INVALID_PARAM;
  74                 goto FINISH_OFF;
  75         }
  76
  77         /* insert task to _active_task_pool */
  78         emcore_insert_task_to_active_task_pool(input_task->active_task_id
  79                         , input_task->task_id
  80                         , input_task->task_type
  81                         , THREAD_SELF());
  82
  83         /* send notification for 'task start */
  84         if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, EMAIL_TASK_STATUS_STARTED, EMAIL_ERROR_NONE, 0)) != EMAIL_ERROR_NONE) {
  85                 EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err);
  86                 goto FINISH_OFF;
  87         }
  88
  89 FINISH_OFF:
  90
  91         EM_DEBUG_FUNC_END("err [%d]", err);
  92         return err;
  93 }
  94
  95 static int emcore_finalize_async_task_handler(email_task_t *input_task, int input_error_code)
  96 {
  97         EM_DEBUG_FUNC_BEGIN("input_task [%p] input_error_code [%d]",input_task ,input_error_code);
  98         int err = EMAIL_ERROR_NONE;
  99         email_task_status_type_t task_status = EMAIL_TASK_STATUS_FINISHED;
 100
 101         if(input_task == NULL) {
 102                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 103                 err = EMAIL_ERROR_INVALID_PARAM;
 104                 goto FINISH_OFF;
 105         }
 106
 107         if(input_error_code != EMAIL_ERROR_NONE) {
 108                 task_status = EMAIL_TASK_STATUS_FAILED;
 109         }
 110
 111         /* remove task from task table */
 112         if( (err = emcore_remove_task_from_task_table(NULL, input_task->task_id)) != EMAIL_ERROR_NONE) {
 113                 EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err);
 114                 goto FINISH_OFF;
 115         }
 116
 117         /* remove task id from active task id array */
 118         if( (err = emcore_remove_task_from_active_task_pool(input_task->task_id)) != EMAIL_ERROR_NONE) {
 119                 EM_DEBUG_EXCEPTION("emcore_remove_task_from_active_task_pool failed [%d]", err);
 120                 goto FINISH_OFF;
 121         }
 122
 123         /* send signal for 'task finish or failure */
 124         if( (err = emcore_send_task_status_signal(input_task->task_type, input_task->task_id, task_status, input_error_code, 0)) != EMAIL_ERROR_NONE) {
 125                 EM_DEBUG_EXCEPTION("emcore_send_task_status_signal failed [%d]", err);
 126                 goto FINISH_OFF;
 127         }
 128
 129         ENTER_CRITICAL_SECTION(_task_available_lock);
 130         WAKE_CONDITION_VARIABLE(_task_available_signal);
 131         LEAVE_CRITICAL_SECTION(_task_available_lock);
 132
 133 FINISH_OFF:
 134         EM_DEBUG_FUNC_END("err [%d]", err);
 135         return err;
 136 }
 137
 138 INTERNAL_FUNC void* emcore_default_async_task_handler(void *input_param)
 139 {
 140         EM_DEBUG_FUNC_BEGIN("intput_param [%p]", input_param);
 141         int err = EMAIL_ERROR_NONE;
 142         email_task_t *task = input_param;
 143         email_task_handler_t *task_handler = NULL;
 144         void *decoded_task_parameter = NULL;
 145
 146         if((err = emcore_initialize_async_task_handler(task)) != EMAIL_ERROR_NONE) {
 147                 EM_DEBUG_EXCEPTION("emcore_initialize_async_task_handler failed. [%d]", err);
 148                 goto FINISH_OFF;
 149         }
 150
 151         /* create a thread to do this task */
 152         if ((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) {
 153                 EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err);
 154         }
 155         else {
 156                 /* Decode parameter */
 157                 emcore_decode_task_parameter(task->task_type,
 158                                                                         task->task_parameter,
 159                                                                         task->task_parameter_length,
 160                                                                         &decoded_task_parameter);
 161
 162                 task_handler->task_handler_function(decoded_task_parameter);
 163         }
 164
 165 FINISH_OFF:
 166         emcore_finalize_async_task_handler(task, err);
 167
 168         EM_SAFE_FREE(decoded_task_parameter);
 169
 170         EM_DEBUG_FUNC_END("err [%d]", err);
 171         return NULL;
 172 }
 173
 174 INTERNAL_FUNC int emcore_default_sync_task_handler(void *intput_param)
 175 {
 176         EM_DEBUG_FUNC_BEGIN("intput_param [%p]", intput_param);
 177         int err = EMAIL_ERROR_NONE;
 178         int *return_err = NULL;
 179         email_task_t *task = intput_param;
 180         email_task_handler_t *task_handler = NULL;
 181         void *decoded_task_parameter = NULL;
 182
 183         /* create a thread to do this task */
 184         if ((err = emcore_get_task_handler_reference(task->task_type, &task_handler)) != EMAIL_ERROR_NONE) {
 185                 EM_DEBUG_LOG("emcore_get_task_handler_reference returns [%d]", err);
 186         } else {
 187                 /* Decode parameter */
 188                 emcore_decode_task_parameter(task->task_type,
 189                                                                         task->task_parameter,
 190                                                                         task->task_parameter_length,
 191                                                                         &decoded_task_parameter);
 192
 193                 return_err = (int *)task_handler->task_handler_function(decoded_task_parameter);
 194         }
 195
 196         if (return_err) {
 197                 err = *return_err;
 198                 free(return_err);
 199         }
 200
 201         EM_SAFE_FREE(decoded_task_parameter);
 202
 203         EM_DEBUG_FUNC_END("err [%d]", err);
 204         return err;
 205 }
 206 /*- task handlers helpers - end   --------------------------------------------*/
 207
 208 int                   _task_handler_array_size;
 209 email_task_handler_t **_task_handler_array;
 210
 211 static int emcore_register_task_handler(email_task_type_t input_task_type,
 212                                                                                 void* (*input_task_handler)(void *),
 213                                                                                 int (*input_task_parameter_encoder)(void*,char**,int*),
 214                                                                                 int (*input_task_parameter_decoder)(char*,int,void**))
 215 {
 216         EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_handler [%p] "
 217                                                 "input_task_parameter_encoder [%p] input_task_parameter_decoder [%p]",
 218                                                 input_task_type, input_task_handler,
 219                                                 input_task_parameter_encoder, input_task_parameter_decoder);
 220
 221         int err = EMAIL_ERROR_NONE;
 222         email_task_handler_t *new_task_handler = NULL;
 223
 224         new_task_handler = malloc(sizeof(email_task_handler_t));
 225
 226         if (new_task_handler == NULL) {
 227                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 228                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_OUT_OF_MEMORY");
 229                 goto FINISH_OFF;
 230         }
 231
 232         new_task_handler->task_type              = input_task_type;
 233         new_task_handler->task_handler_function  = input_task_handler;
 234         new_task_handler->task_parameter_encoder = input_task_parameter_encoder;
 235         new_task_handler->task_parameter_decoder = input_task_parameter_decoder;
 236
 237         _task_handler_array_size++;
 238
 239         if (_task_handler_array) {
 240                 _task_handler_array = realloc(_task_handler_array, sizeof(email_task_handler_t*) * _task_handler_array_size);
 241         }
 242         else {
 243                 _task_handler_array = malloc(sizeof(email_task_handler_t*) * _task_handler_array_size);
 244         }
 245
 246         if (_task_handler_array == NULL) {
 247                 err = EMAIL_ERROR_OUT_OF_MEMORY;
 248         EM_SAFE_FREE(new_task_handler);
 249                 goto FINISH_OFF;
 250         }
 251
 252         _task_handler_array[_task_handler_array_size - 1] = new_task_handler;
 253
 254 FINISH_OFF:
 255
 256         EM_DEBUG_FUNC_END("err [%d]", err);
 257         return err;
 258 }
 259
 260 INTERNAL_FUNC int emcore_init_task_handler_array()
 261 {
 262         EM_DEBUG_FUNC_BEGIN();
 263
 264         if (_task_handler_array == NULL) {
 265                 _task_handler_array = NULL;
 266                 _task_handler_array_size = 0;
 267
 268                 REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_MOVE_MAILS_TO_MAILBOX_OF_ANOTHER_ACCOUNT);
 269                 REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_DELETE_MAILBOX_EX);
 270                 REGISTER_TASK_BINDER(EMAIL_ASYNC_TASK_SEND_MAIL_WITH_DOWNLOADING_ATTACHMENT_OF_ORIGINAL_MAIL);
 271                 REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_SCHEDULE_SENDING_MAIL);
 272                 REGISTER_TASK_BINDER(EMAIL_SYNC_TASK_UPDATE_ATTRIBUTE);
 273         }
 274
 275         EM_DEBUG_FUNC_END();
 276         return EMAIL_ERROR_NONE;
 277 }
 278
 279 INTERNAL_FUNC int emcore_free_task_handler_array()
 280 {
 281         EM_DEBUG_FUNC_BEGIN();
 282
 283         int i = 0;
 284
 285         for(i = 0; i < _task_handler_array_size; i++) {
 286                 EM_SAFE_FREE (_task_handler_array[i]);
 287         }
 288
 289         EM_SAFE_FREE (_task_handler_array);
 290         _task_handler_array_size = 0;
 291
 292         EM_DEBUG_FUNC_END();
 293         return EMAIL_ERROR_NONE;
 294 }
 295
 296 static int emcore_get_task_handler_reference(email_task_type_t input_task_type, email_task_handler_t **output_task_handler)
 297 {
 298         EM_DEBUG_FUNC_BEGIN("input_task_type [%d] output_task_handler [%p]", input_task_type, output_task_handler);
 299         int i = 0;
 300         int err = EMAIL_ERROR_NONE;
 301
 302         if (output_task_handler == NULL) {
 303                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 304                 err = EMAIL_ERROR_INVALID_PARAM;
 305                 goto FINISH_OFF;
 306         }
 307
 308         *output_task_handler = NULL;
 309         for (i = 0; i < _task_handler_array_size; i++) {
 310                 if (_task_handler_array[i]->task_type == input_task_type) {
 311                         *output_task_handler = _task_handler_array[i];
 312                         break;
 313                 }
 314         }
 315
 316         if (*output_task_handler == NULL) {
 317                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_TASK_BINDER_NOT_FOUND");
 318                 err = EMAIL_ERROR_TASK_BINDER_NOT_FOUND;
 319                 goto FINISH_OFF;
 320         }
 321
 322 FINISH_OFF:
 323         EM_DEBUG_FUNC_END("err [%d]", err);
 324         return err;
 325 }
 326
 327 INTERNAL_FUNC int  emcore_encode_task_parameter(email_task_type_t input_task_type, void *input_task_parameter_struct, char **output_byte_stream, int *output_stream_size)
 328 {
 329         EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_parameter_struct [%p] output_byte_stream [%p] output_stream_size [%p]", input_task_type, input_task_parameter_struct, output_byte_stream, output_stream_size);
 330         int err = EMAIL_ERROR_NONE;
 331         email_task_handler_t *task_handler = NULL;
 332         int (*task_parameter_encoder)(void*, char**, int*);
 333
 334         if (input_task_parameter_struct == NULL || output_byte_stream == NULL || output_stream_size == NULL) {
 335                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 336                 err = EMAIL_ERROR_INVALID_PARAM;
 337                 goto FINISH_OFF;
 338         }
 339
 340         if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) {
 341                 EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err);
 342                 goto FINISH_OFF;
 343         }
 344
 345         task_parameter_encoder = task_handler->task_parameter_encoder;
 346
 347         if ((err = task_parameter_encoder(input_task_parameter_struct, output_byte_stream, output_stream_size)) != EMAIL_ERROR_NONE) {
 348                 EM_DEBUG_EXCEPTION("task_parameter_encoder failed [%d]", err);
 349                 goto FINISH_OFF;
 350         }
 351
 352 FINISH_OFF:
 353         EM_DEBUG_FUNC_END("err [%d]", err);
 354         return err;
 355 }
 356
 357 INTERNAL_FUNC int  emcore_decode_task_parameter(email_task_type_t input_task_type, char *input_byte_stream, int input_stream_size, void **output_task_parameter_struct)
 358 {
 359         EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_byte_stream [%p] input_stream_size [%d] output_task_parameter_struct [%p]", input_task_type, input_byte_stream, input_stream_size, output_task_parameter_struct);
 360         int err = EMAIL_ERROR_NONE;
 361         email_task_handler_t *task_handler = NULL;
 362         int (*task_parameter_decoder)(char*, int, void**);
 363
 364         if (input_byte_stream == NULL || output_task_parameter_struct == NULL) {
 365                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 366                 err = EMAIL_ERROR_INVALID_PARAM;
 367                 goto FINISH_OFF;
 368         }
 369
 370         if ((err = emcore_get_task_handler_reference(input_task_type, &task_handler)) != EMAIL_ERROR_NONE) {
 371                 EM_DEBUG_EXCEPTION("emcore_get_task_handler_reference failed [%d]", err);
 372                 goto FINISH_OFF;
 373         }
 374
 375         task_parameter_decoder = task_handler->task_parameter_decoder;
 376
 377         if ((err = task_parameter_decoder(input_byte_stream,
 378                                                                         input_stream_size,
 379                                                                         output_task_parameter_struct)) != EMAIL_ERROR_NONE) {
 380                 EM_DEBUG_EXCEPTION("task_parameter_decoder failed [%d]", err);
 381                 goto FINISH_OFF;
 382         }
 383
 384 FINISH_OFF:
 385         EM_DEBUG_FUNC_END("err [%d]", err);
 386         return err;
 387 }
 388
 389 int emcore_fetch_task_from_task_pool(email_task_t **output_task)
 390 {
 391         EM_DEBUG_FUNC_BEGIN("output_task [%p]", output_task);
 392         int err = EMAIL_ERROR_NONE;
 393         int output_task_count;
 394
 395         if ((err = emstorage_query_task(NULL,
 396                                                                         "WHERE task_status == 1",
 397                                                                         "ORDER BY date_time ASC, task_priority ASC LIMIT 0, 1",
 398                                                                         output_task,
 399                                                                         &output_task_count)) != EMAIL_ERROR_NONE) {
 400                 EM_DEBUG_EXCEPTION("emstorage_query_task failed [%d]", err);
 401                 goto FINISH_OFF;
 402         }
 403
 404 FINISH_OFF:
 405
 406         EM_DEBUG_FUNC_END("err [%d]", err);
 407         return err;
 408 }
 409
 410
 411 /*-Task manager loop - begin -------------------------------------------------------------*/
 412
 413
 414 static int emcore_insert_task_to_active_task_pool(int input_task_slot_index, int input_task_id, email_task_type_t input_task_type, thread_t input_thread_id)
 415 {
 416         EM_DEBUG_FUNC_BEGIN("input_task_slot_index [%d] input_task_id [%d] input_task_type [%d] input_thread_id [%d]", input_task_slot_index, input_task_id, input_task_type, input_thread_id);
 417         int err = EMAIL_ERROR_NONE;
 418
 419         ENTER_CRITICAL_SECTION(_active_task_pool_lock);
 420         _active_task_pool[input_task_slot_index].task_id    = input_task_id;
 421         _active_task_pool[input_task_slot_index].task_type  = input_task_type;
 422         _active_task_pool[input_task_slot_index].thread_id  = input_thread_id;
 423         LEAVE_CRITICAL_SECTION(_active_task_pool_lock);
 424
 425         EM_DEBUG_LOG("_active_task_pool[%d].task_id [%d]", input_task_slot_index, _active_task_pool[input_task_slot_index].task_id);
 426
 427         EM_DEBUG_FUNC_END("err [%d]", err);
 428         return err;
 429 }
 430
 431 static int emcore_remove_task_from_active_task_pool(int input_task_id)
 432 {
 433         EM_DEBUG_FUNC_BEGIN(" input_task_id [%d]", input_task_id);
 434         int err = EMAIL_ERROR_NONE;
 435         int i = 0;
 436
 437         ENTER_CRITICAL_SECTION(_active_task_pool_lock);
 438         for(i = 0; i < MAX_ACTIVE_TASK; i++) {
 439                 if(_active_task_pool[i].task_id == input_task_id) {
 440                         _active_task_pool[i].task_id    = 0;
 441                         _active_task_pool[i].task_type  = 0;
 442                         _active_task_pool[i].thread_id  = 0;
 443                         break;
 444                 }
 445         }
 446         LEAVE_CRITICAL_SECTION(_active_task_pool_lock);
 447
 448         if(i >= MAX_ACTIVE_TASK) {
 449                 EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_task_id);
 450                 err = EMAIL_ERROR_TASK_NOT_FOUND;
 451         }
 452
 453         EM_DEBUG_FUNC_END("err [%d]", err);
 454         return err;
 455 }
 456
 457 INTERNAL_FUNC int emcore_get_active_task_by_thread_id(thread_t input_thread_id, email_active_task_t **output_active_task)
 458 {
 459         EM_DEBUG_FUNC_BEGIN(" input_thread_id [%d] output_active_task [%p]", input_thread_id, output_active_task);
 460         int err = EMAIL_ERROR_NONE;
 461         int i = 0;
 462
 463         if (output_active_task == NULL) {
 464                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 465                 err = EMAIL_ERROR_INVALID_PARAM;
 466                 goto FINISH_OFF;
 467         }
 468
 469         for(i = 0; i < MAX_ACTIVE_TASK; i++) {
 470                 if(_active_task_pool[i].thread_id == input_thread_id) {
 471                         *output_active_task = _active_task_pool + i;
 472                         break;
 473                 }
 474         }
 475
 476         if(i >= MAX_ACTIVE_TASK) {
 477                 EM_DEBUG_LOG("couldn't find proper task in active task pool [%d]", input_thread_id);
 478                 err = EMAIL_ERROR_TASK_NOT_FOUND;
 479         }
 480
 481 FINISH_OFF:
 482
 483         EM_DEBUG_FUNC_END("err [%d]", err);
 484         return err;
 485 }
 486
 487
 488 static int emcore_find_available_slot_in_active_task_pool(int *result_index)
 489 {
 490         EM_DEBUG_FUNC_BEGIN("result_index [%p]", result_index);
 491         int i = 0;
 492         int err = EMAIL_ERROR_NONE;
 493
 494         if (result_index == NULL) {
 495                 EM_DEBUG_EXCEPTION("EMAIL_ERROR_INVALID_PARAM");
 496                 err = EMAIL_ERROR_INVALID_PARAM;
 497                 goto FINISH_OFF;
 498         }
 499
 500         ENTER_CRITICAL_SECTION(_active_task_pool_lock);
 501         for(i = 0; i < MAX_ACTIVE_TASK; i++) {
 502                 if(_active_task_pool[i].task_id == 0) {
 503                         break;
 504                 }
 505         }
 506
 507         if(i >= MAX_ACTIVE_TASK) {
 508                 EM_DEBUG_EXCEPTION("There is no available task slot");
 509                 err = EMAIL_NO_AVAILABLE_TASK_SLOT;
 510         }
 511         else {
 512                 _active_task_pool[i].task_id = -1;
 513                 *result_index = i;
 514         }
 515         LEAVE_CRITICAL_SECTION(_active_task_pool_lock);
 516
 517 FINISH_OFF :
 518         EM_DEBUG_FUNC_END("err [%d]", err);
 519         return err;
 520 }
 521
 522 void* thread_func_task_manager_loop(void *arg)
 523 {
 524         EM_DEBUG_FUNC_BEGIN();
 525         int err = EMAIL_ERROR_NONE;
 526         int thread_error;
 527         int available_slot_index = 0;
 528         email_task_t *new_task = NULL;
 529
 530         /* while loop */
 531         while (_task_manager_loop_availability) {
 532                 /* fetch task from DB */
 533                 if( ((err = emcore_fetch_task_from_task_pool(&new_task)) == EMAIL_ERROR_NONE) &&
 534                         ((err = emcore_find_available_slot_in_active_task_pool(&available_slot_index)) == EMAIL_ERROR_NONE)     ) {
 535
 536                         /* update task status as STARTED */
 537                         if((err = emcore_update_task_status_on_task_table(NULL, new_task->task_id, EMAIL_TASK_STATUS_STARTED)) != EMAIL_ERROR_NONE) {
 538                                 EM_DEBUG_EXCEPTION("emcore_update_task_status_on_task_table failed [%d]", err);
 539                         }
 540                         new_task->active_task_id = available_slot_index;
 541
 542                         /* create a thread to do this task */
 543                         THREAD_CREATE(new_task->thread_id, emcore_default_async_task_handler, new_task, thread_error);
 544                         EM_DEBUG_LOG("pthread_create returns [%d]", thread_error);
 545
 546                         /* new_task and task_parameter will be free in task handler. */
 547                         EM_SAFE_FREE(new_task->task_parameter);
 548                         EM_SAFE_FREE(new_task);
 549                 }
 550                 else {
 551                         /* If there is no task or no available slot, sleep until someone wake you up. */
 552                         /* Wake up case 1 : by emcore_add_task_to_task_table */
 553                         /* Wake up case 2 : when some task terminated */
 554                         ENTER_CRITICAL_SECTION(_task_available_lock);
 555                         SLEEP_CONDITION_VARIABLE(_task_available_signal, _task_available_lock);
 556                         LEAVE_CRITICAL_SECTION(_task_available_lock);
 557                         EM_DEBUG_LOG("thread_func_task_manager_loop wake up!");
 558                 }
 559         }
 560
 561         EM_DEBUG_FUNC_END();
 562         return NULL;
 563 }
 564
 565 INTERNAL_FUNC int emcore_start_task_manager_loop()
 566 {
 567     EM_DEBUG_FUNC_BEGIN();
 568         int thread_error;
 569         int err = EMAIL_ERROR_NONE;
 570
 571         memset(&_active_task_pool, 0, sizeof(email_active_task_t) * MAX_ACTIVE_TASK);
 572
 573         if (_thread_task_manager_loop) {
 574                 EM_DEBUG_EXCEPTION("service thread is already running...");
 575                 err = EMAIL_ERROR_ALREADY_INITIALIZED;
 576                 goto FINISH_OFF;
 577         }
 578
 579         _task_manager_loop_availability = 10;
 580
 581     /* create thread */
 582         THREAD_CREATE(_thread_task_manager_loop, thread_func_task_manager_loop, NULL, thread_error);
 583
 584         if (thread_error != 0) {
 585         EM_DEBUG_EXCEPTION("cannot create thread [%d]", thread_error);
 586         err = EMAIL_ERROR_SYSTEM_FAILURE;
 587         goto FINISH_OFF;
 588     }
 589
 590 FINISH_OFF :
 591         EM_DEBUG_FUNC_END("err [%d]", err);
 592     return err;
 593 }
 594
 595 INTERNAL_FUNC int emcore_stop_task_manager_loop()
 596 {
 597         EM_DEBUG_FUNC_BEGIN();
 598
 599         int err = EMAIL_ERROR_NONE;
 600
 601         if (!_thread_task_manager_loop) {
 602                 EM_DEBUG_LOG("_thread_task_manager_loop is NULL ");
 603                 err = EMAIL_ERROR_UNKNOWN;
 604                 return err;
 605         }
 606
 607         /* TODO : cancel tasks */
 608
 609         /* stop event_data loop */
 610         _task_manager_loop_availability = 0;
 611
 612         ENTER_CRITICAL_SECTION(_task_manager_loop_lock);
 613         WAKE_CONDITION_VARIABLE(_task_available_signal);
 614         LEAVE_CRITICAL_SECTION(_task_manager_loop_lock);
 615
 616         /* wait for thread finished */
 617         THREAD_JOIN(_thread_task_manager_loop);
 618
 619         _thread_task_manager_loop = 0;
 620
 621         DELETE_CRITICAL_SECTION(_task_manager_loop_lock);
 622         DELETE_CONDITION_VARIABLE(_task_available_signal);
 623
 624         /* Free _active_task_pool */
 625
 626         //FINISH_OFF :
 627
 628         EM_DEBUG_FUNC_END("err [%d]", err);
 629         return err;
 630 }
 631
 632 INTERNAL_FUNC int emcore_add_task_to_task_table(char *multi_user_name, email_task_type_t input_task_type, email_task_priority_t input_task_priority, char *input_task_parameter, int input_task_parameter_length, int *output_task_id)
 633 {
 634         EM_DEBUG_FUNC_BEGIN("input_task_type [%d] input_task_priority [%d] input_task_parameter [%p] input_task_parameter_length [%d] output_task_id [%p]", input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, output_task_id);
 635         int err = EMAIL_ERROR_NONE;
 636
 637         if((err = emstorage_add_task(multi_user_name, input_task_type, input_task_priority, input_task_parameter, input_task_parameter_length, false, output_task_id)) != EMAIL_ERROR_NONE) {
 638                 EM_DEBUG_EXCEPTION("emstorage_add_task failed [%d]", err);
 639                 goto FINISH_OFF;
 640         }
 641
 642         ENTER_CRITICAL_SECTION(_task_available_lock);
 643         WAKE_CONDITION_VARIABLE(_task_available_signal);
 644         LEAVE_CRITICAL_SECTION(_task_available_lock);
 645
 646 FINISH_OFF:
 647         EM_DEBUG_FUNC_END("err [%d]", err);
 648         return err;
 649 }
 650
 651 INTERNAL_FUNC int emcore_remove_task_from_task_table(char *multi_user_name, int input_task_id)
 652 {
 653         EM_DEBUG_FUNC_BEGIN("input_task_id [%d]", input_task_id);
 654         int err = EMAIL_ERROR_NONE;
 655
 656         if((err = emstorage_delete_task(multi_user_name, input_task_id, true)) != EMAIL_ERROR_NONE) {
 657                 EM_DEBUG_EXCEPTION("emstorage_delete_task failed [%d]", err);
 658                 goto FINISH_OFF;
 659         }
 660
 661 FINISH_OFF:
 662         EM_DEBUG_FUNC_END("err [%d]", err);
 663         return err;
 664 }
 665
 666 static int emcore_update_task_status_on_task_table(char *multi_user_name, int input_task_id, email_task_status_type_t task_status)
 667 {
 668         EM_DEBUG_FUNC_BEGIN("input_task_id [%d] task_status [%d]", input_task_id, task_status);
 669         int err = EMAIL_ERROR_NONE;
 670
 671         if((err = emstorage_update_task_status(multi_user_name, input_task_id, task_status, true)) != EMAIL_ERROR_NONE) {
 672                 EM_DEBUG_EXCEPTION("emstorage_update_task_status failed [%d]", err);
 673                 goto FINISH_OFF;
 674         }
 675
 676 FINISH_OFF:
 677         EM_DEBUG_FUNC_END("err [%d]", err);
 678         return err;
 679 }
 680
 681 /*-Task manager loop - end-------------------------------------------------------------*/