Add daemon recovery when daemon is reboot impl

Signed-off-by: Jihoon Jung <jh8801.jung@samsung.com>

diff --git a/src/mdg-manager/include/mdgd_context.h b/src/mdg-manager/include/mdgd_context.h
index 59f4cdf..6a699b3 100644 (file)
--- a/src/mdg-manager/include/mdgd_context.h
+++ b/src/mdg-manager/include/mdgd_context.h
@@ -45,6 +45,7 @@ typedef struct {
        GList *pairwise_list;
 
        bool monitor_started;
+       bool first_search;
 
        //sqlite3 db
        sqlite3 *db;

diff --git a/src/mdg-manager/include/mdgd_db.h b/src/mdg-manager/include/mdgd_db.h
index 1fbeea1..d5163de 100644 (file)
--- a/src/mdg-manager/include/mdgd_db.h
+++ b/src/mdg-manager/include/mdgd_db.h
@@ -18,13 +18,24 @@
 #ifndef __MDGD_DB_H__
 #define __MDGD_DB_H__
 
-#define MDGD_DB_FILE "/opt/usr/dbspace/.comp.db"
-#define MDGD_DB_TABLE "mdgd_group_information"
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define MDGD_DB_FILE "/opt/usr/dbspace/.mdgd.db"
+#define MDGD_DB_GROUP_TABLE "mdgd_group"
+#define MDGD_DB_DEVICE_TABLE "mdgd_device"
 
 int mdgd_db_init();
 int mdgd_db_deinit();
-int mdgd_db_insert(char *group_name, char *device_id);
-int mdgd_db_delete_group(char *group_name);
-int mdgd_db_delete_device(char *group_name, char *device_id);
+int mdgd_db_group_insert(const char *group_name);
+int mdgd_db_device_insert(const char *device_id, const char *group_name);
+int mdgd_db_group_delete(char *group_name);
+int mdgd_db_device_delete(char *device_id, char *group_name);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif

diff --git a/src/mdg-manager/include/mdgd_group.h b/src/mdg-manager/include/mdgd_group.h
index 88adbad..6adffe0 100644 (file)
--- a/src/mdg-manager/include/mdgd_group.h
+++ b/src/mdg-manager/include/mdgd_group.h
@@ -79,6 +79,11 @@ typedef struct {
        int count; /**< Count of successful post method */
 } mdgd_invited_device_t;
 
+typedef struct {
+       char *name; /**< Group name */
+       GList *device_list; /**< Remote device UUIDs. (char* type) */
+} mdgd_grp_t;
+
 /* Called when daemon is start. */
 int mdgd_group_initialize();
 
@@ -159,6 +164,7 @@ int mdgd_group_request_eject(char *uuid, char *group_name, char *target_uuid);
 int mdgd_group_request_delete_group(char *uuid, char *group_name);
 
 int mdgd_group_start_invited_device_monitor(int start);
+mdgd_mot_device_t *mdgd_group_check_device_in_mot_enb_dev_list(char *uuid);
 
 #ifdef __cplusplus
 }

diff --git a/src/mdg-manager/src/mdgd_context.c b/src/mdg-manager/src/mdgd_context.c
index 412df5e..2aa0376 100644 (file)
--- a/src/mdg-manager/src/mdgd_context.c
+++ b/src/mdg-manager/src/mdgd_context.c
@@ -28,6 +28,7 @@ int mdgd_context_create()
                return MDGD_ERROR_OUT_OF_MEMORY;
        }
        mdgd_ctx->mot_me = FALSE;
+       mdgd_ctx->first_search = TRUE;
 
        return MDGD_ERROR_NONE;
 }

diff --git a/src/mdg-manager/src/mdgd_db.c b/src/mdg-manager/src/mdgd_db.c
index fc8ba5e..a24db3d 100644 (file)
--- a/src/mdg-manager/src/mdgd_db.c
+++ b/src/mdg-manager/src/mdgd_db.c
@@ -65,7 +65,7 @@ static bool __is_table_existing(const char *table)
        return result;
 }
 
-static int __create_table()
+static int __create_group_table()
 {
        int ret = 0;
        int sql_ret;
@@ -79,8 +79,41 @@ static int __create_table()
                return -1;
        }
 
-       sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT, device_id TEXT);",
-               MDGD_DB_TABLE);
+       sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, group_name TEXT);",
+               MDGD_DB_GROUP_TABLE);
+
+       if (sql != NULL) {
+               sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
+               if (sql_ret != SQLITE_OK) {
+                       LOG_ERR("sqlite3_exec failed, %d, %s", sql_ret, error);
+                       ret = -1;
+                       sqlite3_free(error);
+               }
+               sqlite3_free(sql);
+       } else {
+               LOG_ERR("sql is NULL");
+               ret = -1;
+       }
+
+       return ret;
+}
+
+static int __create_device_table()
+{
+       int ret = 0;
+       int sql_ret;
+       char *sql = NULL;
+       char *error = NULL;
+
+       mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+       if (mdgd_ctx->db == NULL) {
+               LOG_ERR("mdgd_ctx->db is NULL");
+               return -1;
+       }
+
+       sql = sqlite3_mprintf("CREATE TABLE %s(id INTEGER PRIMARY KEY, device_id TEXT, group_name TEXT);",
+               MDGD_DB_DEVICE_TABLE);
 
        if (sql != NULL) {
                sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
@@ -100,8 +133,11 @@ static int __create_table()
 
 static void __prepare_table()
 {
-       if (__is_table_existing(MDGD_DB_TABLE) == false)
-               __create_table();
+       if (__is_table_existing(MDGD_DB_GROUP_TABLE) == false)
+               __create_group_table();
+
+       if (__is_table_existing(MDGD_DB_DEVICE_TABLE) == false)
+               __create_device_table();
 }
 
 static int __check_integrity()
@@ -124,7 +160,6 @@ static int __check_integrity()
                ret = sqlite3_step(stmt);
                if (ret == SQLITE_ROW) {
                        const char *ret_val = (const char *)sqlite3_column_text(stmt, 0);
-                       LOG_ERR("ret_val: %s", ret_val);
                        if (ret_val && !strncmp(ret_val, "ok", strlen("ok"))) {
                                result = 0;
                        } else {
@@ -180,10 +215,9 @@ int mdgd_db_init()
                __prepare_table();
        }
 
-       if (mdgd_ctx->db != NULL) {
-               //iot activity per each column
-               LOG_ERR("comp db init");
-               //mdgd_group_create(group_name);
+       if (mdgd_ctx->db == NULL) {
+               LOG_ERR("DB is NULL");
+               goto ERR;
        }
 
        return ret;
@@ -218,7 +252,7 @@ int mdgd_db_deinit()
        return ret;
 }
 
-int mdgd_db_insert(char *group_name, char *device_id)
+int mdgd_db_group_insert(const char *group_name)
 {
        int ret = 0;
        int sql_ret;
@@ -232,10 +266,44 @@ int mdgd_db_insert(char *group_name, char *device_id)
                return -1;
        }
 
-       sql = sqlite3_mprintf("INSERT INTO %s (group_name, device_id) values(%Q, %Q);",
-               MDGD_DB_TABLE,
-               group_name,
-               device_id);
+       sql = sqlite3_mprintf("INSERT INTO %s (group_name) values(%Q);",
+               MDGD_DB_GROUP_TABLE,
+               group_name);
+
+       if (sql != NULL) {
+               sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
+               if (sql_ret != SQLITE_OK) {
+                       LOG_ERR("sqlite3_exec failed, %d, %s", sql_ret, error);
+                       ret = -1;
+                       sqlite3_free(error);
+               }
+               sqlite3_free(sql);
+       } else {
+               LOG_ERR("sql is NULL");
+               ret = -1;
+       }
+
+       return ret;
+}
+
+int mdgd_db_device_insert(const char *device_id, const char *group_name)
+{
+       int ret = 0;
+       int sql_ret;
+       char *sql = NULL;
+       char *error = NULL;
+
+       mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+       if (mdgd_ctx->db == NULL) {
+               LOG_ERR("mtp_ctx->db is NULL");
+               return -1;
+       }
+
+       sql = sqlite3_mprintf("INSERT INTO %s (device_id, group_name) values(%Q, %Q);",
+               MDGD_DB_DEVICE_TABLE,
+               device_id,
+               group_name);
 
        if (sql != NULL) {
                sql_ret = sqlite3_exec(mdgd_ctx->db, sql, NULL, NULL, &error);
@@ -253,7 +321,7 @@ int mdgd_db_insert(char *group_name, char *device_id)
        return ret;
 }
 
-int mdgd_db_delete_group(char *group_name)
+int mdgd_db_group_delete(char *group_name)
 {
        int ret = 0;
        int sql_ret;
@@ -273,7 +341,7 @@ int mdgd_db_delete_group(char *group_name)
        }
 
        sql = sqlite3_mprintf("DELETE FROM %s WHERE group_name=%Q",
-               MDGD_DB_TABLE,
+               MDGD_DB_GROUP_TABLE,
                group_name);
 
        if (sql != NULL) {
@@ -292,7 +360,7 @@ int mdgd_db_delete_group(char *group_name)
        return ret;
 }
 
-int mdgd_db_delete_device(char *group_name, char *device_id)
+int mdgd_db_device_delete(char *device_id, char *group_name)
 {
        int ret = 0;
        int sql_ret;
@@ -317,7 +385,7 @@ int mdgd_db_delete_device(char *group_name, char *device_id)
        }
 
        sql = sqlite3_mprintf("DELETE FROM %s WHERE group_name=%Q and device_id=%Q",
-               MDGD_DB_TABLE,
+               MDGD_DB_DEVICE_TABLE,
                group_name,
                device_id);
 

diff --git a/src/mdg-manager/src/mdgd_gdbus_group.c b/src/mdg-manager/src/mdgd_gdbus_group.c
index b3224ff..6f26864 100644 (file)
--- a/src/mdg-manager/src/mdgd_gdbus_group.c
+++ b/src/mdg-manager/src/mdgd_gdbus_group.c
@@ -28,6 +28,8 @@ gboolean group_create(Group *group, GDBusMethodInvocation *invocation,
        LOG_DEBUG("group create called using dbus successful");
 
        result = mdgd_group_create(group_name);
+       if (result == 0)
+               mdgd_db_group_insert(group_name);
 
        group_complete_create(group, invocation, result);
 
@@ -143,6 +145,8 @@ gboolean group_invite(Group *group, GDBusMethodInvocation *invocation, gchar *gr
        LOG_DEBUG("group invite called using dbus successful");
 
        result = mdgd_group_invite(group_name, uuid, pin);
+       if (result == 0)
+               mdgd_db_device_insert(uuid, group_name);
 
        /* Now, for the sake of convenience, we change 'group_complete_invite' to 'group_complete_device_invite'. */
 #if 0

diff --git a/src/mdg-manager/src/mdgd_group.c b/src/mdg-manager/src/mdgd_group.c
index bf3e014..da8db5c 100644 (file)
--- a/src/mdg-manager/src/mdgd_group.c
+++ b/src/mdg-manager/src/mdgd_group.c
@@ -35,20 +35,43 @@ mdgd_mot_device_t *my_device = NULL;
 /* Called when daemon is start. */
 int mdgd_group_initialize()
 {
-       //Initialize memory of context
+       int sql_ret = SQLITE_OK;
+       char *sql = NULL;
+       sqlite3_stmt *stmt = NULL;
+
+       mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
        //1. group creation
-       //db select
+       sql = sqlite3_mprintf("SELECT group_name FROM %s;", MDGD_DB_GROUP_TABLE);
+       if (sql != NULL) {
+               sql_ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+               if (sql_ret != SQLITE_OK) {
+                       LOG_ERR("Error: %s", sqlite3_errmsg(mdgd_ctx->db));
+                       sqlite3_free(sql);
+                       return MDGD_ERROR_UNKNOWN;
+               }
+
+               do {
+                       sql_ret = sqlite3_step(stmt);
+                       if (sql_ret != SQLITE_ROW) {
+                               break;
+                       }
+
+                       char *group_name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+
+                       mdgd_group_create(group_name);
+               } while (sql_ret != SQLITE_DONE);
+
+               sqlite3_finalize(stmt);
+               sqlite3_free(sql);
+       }
+
        //2. device creation
-       //db select by group
+       mdgd_group_find_mot_enabled_devices(2);
 
        return MDGD_ERROR_NONE;
 }
 
-typedef struct {
-       char *name; /**< Group name */
-       GList *device_list; /**< Remote device UUIDs. (char* type) */
-} mdgd_grp_t;
-
 void __print_foreach_device(gpointer data, gpointer user_data)
 {
        char *uuid = (char *)data;
@@ -105,7 +128,6 @@ int mdgd_group_create(const char* name)
 
        mdgd_ctx->grp_list = g_list_append(mdgd_ctx->grp_list, grp);
 
-       mdgd_group_add_device_in_group(name, mdgd_ctx->device_uuid);
        mdgd_resource_print_list();
        __print_groups_information();
 
@@ -507,7 +529,7 @@ void mdgd_group_free_invite_info()
        }
 }
 
-static mdgd_mot_device_t *_check_device_in_mot_enb_dev_list(char *uuid)
+mdgd_mot_device_t *mdgd_group_check_device_in_mot_enb_dev_list(char *uuid)
 {
        mdgd_mot_device_t *device;
        GList *iter;
@@ -578,7 +600,7 @@ void mdgd_group_notify_group_invite(int ret)
 
                if (is_exist == FALSE) {
                        mdgd_mot_device_t *temp;
-                       temp = _check_device_in_mot_enb_dev_list(device->uuid);
+                       temp = mdgd_group_check_device_in_mot_enb_dev_list(device->uuid);
                        if (temp)
                                device->host = _addr2host(temp->addr, temp->secure_port);
 
@@ -657,7 +679,6 @@ int mdgd_group_add_device_in_group(const char *group_name, const char *uuid)
                        }
 
                        group->device_list = g_list_append(group->device_list, strdup(uuid));
-                       mdgd_db_insert(group_name, uuid);
 
                        __print_groups_information();
                        return 0;
@@ -750,7 +771,7 @@ int mdgd_group_remove_device_in_group(char *group_name, char *uuid)
 
                iter = g_list_next(iter);
        }
-       mdgd_db_delete_device(group_name, uuid);
+       mdgd_db_device_delete(uuid, group_name);
        __print_groups_information();
 
        return 0;
@@ -1137,7 +1158,7 @@ int mdgd_group_request_create_group(char *uuid, char *group_name)
        cmd->uuid = g_strdup(uuid);
        cmd->arg1 = g_strdup(group_name);
 
-       device = _check_device_in_mot_enb_dev_list(uuid);
+       device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
        if (device) {
                cmd->host = _addr2host(device->addr, device->secure_port);
                ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
@@ -1171,7 +1192,7 @@ int mdgd_group_request_invite(char *uuid, char *group_name, char *target_uuid, c
        cmd->arg2 = g_strdup(target_uuid);
        cmd->arg3 = g_strdup(PIN);
 
-       device = _check_device_in_mot_enb_dev_list(uuid);
+       device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
        if (device) {
                cmd->host = _addr2host(device->addr, device->secure_port);
                ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
@@ -1205,7 +1226,7 @@ int mdgd_group_request_eject(char *uuid, char *group_name, char *target_uuid)
        cmd->arg1 = g_strdup(group_name);
        cmd->arg2 = g_strdup(target_uuid);
 
-       device = _check_device_in_mot_enb_dev_list(uuid);
+       device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
        if (device) {
                cmd->host = _addr2host(device->addr, device->secure_port);
                ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);
@@ -1239,7 +1260,7 @@ int mdgd_group_request_delete_group(char *uuid, char *group_name)
        cmd->uuid = g_strdup(uuid);
        cmd->arg1 = g_strdup(group_name);
 
-       device = _check_device_in_mot_enb_dev_list(uuid);
+       device = mdgd_group_check_device_in_mot_enb_dev_list(uuid);
        if (device) {
                cmd->host = _addr2host(device->addr, device->secure_port);
                ret = mdgd_iot_send_data(MDGD_RESOURCE_TYPE_DATA, 5, cmd);

diff --git a/src/mdg-manager/src/mdgd_iot.cpp b/src/mdg-manager/src/mdgd_iot.cpp
index 402a07b..7eee321 100644 (file)
--- a/src/mdg-manager/src/mdgd_iot.cpp
+++ b/src/mdg-manager/src/mdgd_iot.cpp
@@ -38,6 +38,7 @@
 #include <mdgd_group.h>
 #include <mdgd_gdbus_group.h>
 #include <mdgd_mot_agent.h>
+#include <mdgd_db.h>
 
 #include "OCProvisioningManager.hpp"
 #include "OCPlatform.h"
@@ -501,6 +502,8 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
                                                if (rep.getValue("name", group_name)) {
                                                        LOG_DEBUG("group_name : %s", group_name.c_str());
                                                        result = mdgd_group_create(group_name.c_str());
+                                                       if (result == 0)
+                                                               mdgd_db_group_insert(group_name.c_str());
                                                        arg = (unsigned char *) g_strdup(group_name.c_str());
                                                        arg_len = strlen(group_name.c_str());
                                                }
@@ -518,6 +521,8 @@ OCEntityHandlerResult _request_handler(std::shared_ptr<OCResourceRequest> reques
 
                                                result = mdgd_group_invite(group_name.c_str(),
                                                                           uuid.c_str(), "12341234");
+                                               if (result == 0)
+                                                       mdgd_db_device_insert(uuid.c_str(), group_name.c_str());
                                                arg = (unsigned char *) g_strdup(uuid.c_str());
                                                arg_len = strlen(uuid.c_str());
                                                break;
@@ -1009,24 +1014,82 @@ static bool _found_resource(std::shared_ptr<OCResource> resource,
        return TRUE;
 }
 
+void __invite_device(gpointer data, gpointer user_data)
+{
+       int sql_ret = SQLITE_OK;
+       char *sql = NULL;
+       sqlite3_stmt *stmt = NULL;
+
+       mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+
+       mdgd_grp_t *grp = (mdgd_grp_t *)data;
+       LOG_DEBUG("Group name : %s", grp->name);
+
+       sql = sqlite3_mprintf("SELECT device_id FROM %s WHERE group_name=%Q;",
+                               MDGD_DB_DEVICE_TABLE, grp->name);
+
+       if (sql != NULL) {
+               sql_ret = sqlite3_prepare_v2(mdgd_ctx->db, sql, strlen(sql), &stmt, NULL);
+               if (sql_ret != SQLITE_OK) {
+                       LOG_ERR("Error: %s", sqlite3_errmsg(mdgd_ctx->db));
+                       sqlite3_free(sql);
+                       return;
+               }
+
+               do {
+                       sql_ret = sqlite3_step(stmt);
+                       if (sql_ret != SQLITE_ROW) {
+                               break;
+                       }
+
+                       char *device_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+                       mdgd_mot_device_t *device = mdgd_group_check_device_in_mot_enb_dev_list(device_id);
+
+                       if (device != NULL)
+                               mdgd_group_add_device_in_group(grp->name, device_id);
+               } while (sql_ret != SQLITE_DONE);
+
+               sqlite3_finalize(stmt);
+               sqlite3_free(sql);
+       }
+}
+
 static gboolean _timeout_cb(gpointer data)
 {
-       int ret = MDGD_ERROR_NONE;
+       int ret = -1;
        mdgd_command_t *cmd = (mdgd_command_t *)data;
 
        if (cmd->resource_type == MDGD_RESOURCE_TYPE_GROUP) {
+               if (found_group_count > 0)
+                       ret = 0;
+
                notify_group_find_finish(ret);
+
        } else if (cmd->resource_type == MDGD_RESOURCE_TYPE_DATA) {
                if (cmd->command != MDGD_REQ_KEEP_ALIVE)
                        notify_send_data_finish("RESP_DATA", last_get_result);
        } else if (cmd->resource_type == MDGD_RESOURCE_TYPE_DEVICE) {
                if (!strncmp(cmd->arg1, "disc_mot_enb_devs_done", strlen(cmd->arg1))) {
                        LOG_DEBUG("Device Find Done. notified");
-                       mdgd_group_notify_mot_enable_device_done();
-                       notify_device_find_finish(ret);
+                       if (mdgd_group_get_mot_device_count() > 0)
+                               ret = 0;
+
+                       mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
+                       if (mdgd_ctx->first_search == true) {
+                               if (ret == 0)
+                                       g_list_foreach(mdgd_ctx->grp_list, __invite_device, NULL);
+                               mdgd_ctx->first_search = false;
+                       } else {
+                               mdgd_group_notify_mot_enable_device_done();
+                               notify_device_find_finish(ret);
+                       }
                } else {
                        LOG_DEBUG("MOT Device Find Done. notified");
                        mdgd_group_notify_mowned_device_find_done();
+
+                       if (mdgd_group_get_mowned_device_count() > 0)
+                               ret = 0;
+
                        notify_mowned_device_find_finish(ret);
                }
        }

diff --git a/src/mdg-manager/src/mdgd_manager.c b/src/mdg-manager/src/mdgd_manager.c
index 93976d1..c62b1d4 100644 (file)
--- a/src/mdg-manager/src/mdgd_manager.c
+++ b/src/mdg-manager/src/mdgd_manager.c
@@ -52,16 +52,6 @@ int main(int argc, char *argv[])
                goto EXIT;
        }
 
-       //5. Make TX interface
-
-       //example code
-       //6. group mgr initialize
-       ret = mdgd_group_initialize();
-       if (ret != MDGD_ERROR_NONE) {
-               LOG_ERR("COMP group initialize failed : %s", mdgd_log_get_error_string(ret));
-               goto EXIT;
-       }
-
        //7. operation mgr initialize
        ret = agent_dbus_start();
        if (ret != MDGD_ERROR_NONE) {
@@ -71,6 +61,14 @@ int main(int argc, char *argv[])
        }
        agent_enable();
 
+       //example code
+       //6. group mgr initialize
+       ret = mdgd_group_initialize();
+       if (ret != MDGD_ERROR_NONE) {
+               LOG_ERR("COMP group initialize failed : %s", mdgd_log_get_error_string(ret));
+               goto EXIT;
+       }
+
        //8. g main loop run
        mdgd_context_t *mdgd_ctx = mdgd_context_get_context();
        mdgd_check_null_ret_error("mdgd_ctx", mdgd_ctx, MDGD_ERROR_INVALID_PARAMETER);