Bug fix of IPC communication with Media Server. And user common protocol in media...

Change-Id: Ifaeb611ee73e71b8ec2b14dde4925aaebe9b3985

diff --git a/include/DcmIpcUtils.h b/include/DcmIpcUtils.h
index ccf5466e9bc22c8d804bc7a0114d15c025266e25..46ca0929a9bf764e7bec7226eb5357a8825dad22 100755 (executable)
--- a/include/DcmIpcUtils.h
+++ b/include/DcmIpcUtils.h
@@ -27,9 +27,9 @@ namespace DcmIpcUtils {
        int createSocket(int *socket_fd, DcmIpcPortType port);
        int acceptSocket(int serv_sock, int *client_sock);
        int receiveSocketMsg(int client_sock, dcmMsg *recv_msg);
-       int sendSocketMsg(DcmIpcMsgType msg_type, uid_t uid, const char *msg, DcmIpcPortType port);
-       int sendCompleteMsg(DcmIpcMsgType msg_type, const unsigned int count, const char *msg, DcmIpcPortType port);
-       int sendClientSocketMsg(int socket_fd, DcmIpcMsgType msg_type, unsigned int result, const char *msg, DcmIpcPortType port);
+       int sendSocketMsg(ms_dcm_msg_type_e msg_type, uid_t uid, const char *msg, DcmIpcPortType port);
+       int sendCompleteMsg(ms_dcm_msg_type_e msg_type, const unsigned int count, const char *msg, DcmIpcPortType port);
+       int sendClientSocketMsg(int socket_fd, ms_dcm_msg_type_e msg_type, unsigned int result, const char *msg, DcmIpcPortType port);
        int closeSocket(int socket_fd);
 }
 

diff --git a/include/DcmTypes.h b/include/DcmTypes.h
index ad606b35263b4c791101cca6f063d0d6b51c3f92..dbdf3aa110b8492657fcb99c62a5012f304a0c0d 100755 (executable)
--- a/include/DcmTypes.h
+++ b/include/DcmTypes.h
@@ -54,20 +54,6 @@ typedef enum {
        DCM_ERROR_DUPLICATED_DATA,
 } DcmErrorType;
 
-typedef enum {
-       DCM_IPC_MSG_SCAN_SINGLE,
-       DCM_IPC_MSG_SCAN_ALL,
-       DCM_IPC_MSG_CANCEL,
-       DCM_IPC_MSG_CANCEL_ALL,
-       DCM_IPC_MSG_KILL_SERVICE,
-       DCM_IPC_MSG_SCAN_READY,
-       DCM_IPC_MSG_SCAN_COMPLETED,
-       DCM_IPC_MSG_SCAN_TERMINATED,
-       DCM_IPC_MSG_SERVICE_READY = 20,
-       DCM_IPC_MSG_SERVICE_COMPLETED,
-       DCM_IPC_MSG_MAX,
-} DcmIpcMsgType;
-
 typedef enum {
        DCM_IPC_PORT_SCAN_RECV = 0,
        DCM_IPC_PORT_DCM_RECV,

diff --git a/packaging/dcm-service.spec b/packaging/dcm-service.spec
index 2a0179978e873ddf67eb5bd7cd746a1dddd7a28e..60edb61d2bbe659af4e6fb054d34c3135f94bce6 100755 (executable)
--- a/packaging/dcm-service.spec
+++ b/packaging/dcm-service.spec
@@ -1,6 +1,6 @@
 Name:       dcm-service
 Summary:    A media DCM(Digital Contents Management) Service
-Version:    0.0.17
+Version:    0.0.18
 Release:    0
 Group:      Multimedia/Service
 License:    Apache-2.0

diff --git a/src/DcmIpcUtils.cpp b/src/DcmIpcUtils.cpp
index 72a6d3902ebad45ba5a2cb5e2d5585e5133dbd3d..6b512d2f4e7c03a96ee0a7f497f1794d827b2b4c 100755 (executable)
--- a/src/DcmIpcUtils.cpp
+++ b/src/DcmIpcUtils.cpp
@@ -54,7 +54,7 @@ int DcmIpcUtils::receiveSocketMsg(int client_sock, dcmMsg *recv_msg)
        }
        dcm_sec_debug("[receive msg] type: %d, pid: %d, uid: %d, msg: %s, msg_size: %d", recv_msg->msg_type, recv_msg->pid, recv_msg->uid, (recv_msg->msg)?recv_msg->msg:"NULL", recv_msg->msg_size);
 
-       if (!(recv_msg->msg_type >= 0 && recv_msg->msg_type < DCM_IPC_MSG_MAX)) {
+       if (!(recv_msg->msg_type >= 0 && recv_msg->msg_type < DCM_MSG_MAX)) {
                dcm_error("IPC message is wrong!");
                return DCM_ERROR_IPC_INVALID_MSG;
        }
@@ -134,7 +134,7 @@ int DcmIpcUtils::createSocket(int *socket_fd, DcmIpcPortType port)
        return DCM_SUCCESS;
 }
 
-int DcmIpcUtils::sendClientSocketMsg(int socket_fd, DcmIpcMsgType msg_type, unsigned int result, const char *msg, DcmIpcPortType port)
+int DcmIpcUtils::sendClientSocketMsg(int socket_fd, ms_dcm_msg_type_e msg_type, unsigned int result, const char *msg, DcmIpcPortType port)
 {
        if (port < 0 || port >= DCM_IPC_PORT_MAX) {
                dcm_error("Invalid port! Stop sending message...");
@@ -203,12 +203,15 @@ int DcmIpcUtils::sendClientSocketMsg(int socket_fd, DcmIpcMsgType msg_type, unsi
        return DCM_SUCCESS;
 }
 
-int DcmIpcUtils::sendSocketMsg(DcmIpcMsgType msg_type, uid_t uid, const char *msg, DcmIpcPortType port)
+int DcmIpcUtils::sendSocketMsg(ms_dcm_msg_type_e msg_type, uid_t uid, const char *msg, DcmIpcPortType port)
 {
        if (port < 0 || port >= DCM_IPC_PORT_MAX) {
                dcm_error("Invalid port! Stop sending message...");
                return DCM_ERROR_INVALID_PARAMETER;
        }
+
+       dcm_debug_fenter();
+
        dcm_debug("Send message type: %d", msg_type);
 
        int socket_fd = -1;
@@ -256,15 +259,21 @@ int DcmIpcUtils::sendSocketMsg(DcmIpcMsgType msg_type, uid_t uid, const char *ms
        }
 
        close(socket_fd);
+
+       dcm_debug_fleave();
+
        return DCM_SUCCESS;
 }
 
-int DcmIpcUtils::sendCompleteMsg(DcmIpcMsgType msg_type, const unsigned int count, const char *msg, DcmIpcPortType port)
+int DcmIpcUtils::sendCompleteMsg(ms_dcm_msg_type_e msg_type, const unsigned int count, const char *msg, DcmIpcPortType port)
 {
        if (port < 0 || port >= DCM_IPC_PORT_MAX) {
                dcm_error("Invalid port! Stop sending message...");
                return DCM_ERROR_INVALID_PARAMETER;
        }
+
+       dcm_debug_fenter();
+
        dcm_debug("Send message type: %d", msg_type);
 
        int socket_fd = -1;
@@ -312,6 +321,9 @@ int DcmIpcUtils::sendCompleteMsg(DcmIpcMsgType msg_type, const unsigned int coun
        }
 
        close(socket_fd);
+
+       dcm_debug_fleave();
+
        return DCM_SUCCESS;
 }
 

diff --git a/src/DcmScanSvc.cpp b/src/DcmScanSvc.cpp
index 16d3b14114df873bf267bc5d2e541ec63247e12b..65abeaf353f8726d3a1b39c28d357b8e2e9aab85 100755 (executable)
--- a/src/DcmScanSvc.cpp
+++ b/src/DcmScanSvc.cpp
@@ -106,7 +106,7 @@ gboolean DcmScanCallback::quitTimerAtScanThread(gpointer data)
 
        DCM_CHECK_FALSE(data);
 
-       ret = DcmIpcUtils::sendSocketMsg(DCM_IPC_MSG_SCAN_TERMINATED, 0, NULL, DCM_IPC_PORT_DCM_RECV);
+       ret = DcmIpcUtils::sendSocketMsg(DCM_MSG_SCAN_TERMINATED, 0, NULL, DCM_IPC_PORT_DCM_RECV);
        if (ret != DCM_SUCCESS) {
                dcm_error("send to terminated messge to DCM Main");
        }
@@ -279,7 +279,7 @@ int DcmScanSvc::sendCompletedMsg(const char *msg, const unsigned int count, DcmI
 {
        if ((scan_all_item_list == NULL) && (scan_single_item_list == NULL)) {
                dcm_debug("Send completed message");
-               DcmIpcUtils::sendCompleteMsg(DCM_IPC_MSG_SCAN_COMPLETED, count, msg, port);
+               DcmIpcUtils::sendCompleteMsg(DCM_MSG_SCAN_COMPLETED, count, msg, port);
        } else {
                if (scan_all_item_list)
                        dcm_warn("scan_all_item_list");
@@ -600,7 +600,7 @@ int DcmScanSvc::receiveMsg(dcmMsg *recv_msg)
 
        dcm_debug("msg_type: %d", recv_msg->msg_type);
 
-       if (recv_msg->msg_type == DCM_IPC_MSG_KILL_SERVICE)
+       if (recv_msg->msg_type == DCM_MSG_REQUEST_KILL_SERVER)
        {
                /* Destroy scan idles, and quit scan thread main loop */
                ret = terminateScanOperations();
@@ -610,7 +610,7 @@ int DcmScanSvc::receiveMsg(dcmMsg *recv_msg)
                }
                return ret;
        }
-       else if (recv_msg->msg_type == DCM_IPC_MSG_SCAN_ALL)
+       else if (recv_msg->msg_type == DCM_MSG_REQUEST_ALL_MEDIA)
        {
                /* Use timer to scan all unscanned images */
                ret = dcmDBUtils->_dcm_svc_db_connect(recv_msg->uid);
@@ -620,32 +620,6 @@ int DcmScanSvc::receiveMsg(dcmMsg *recv_msg)
                ScanAllItems();
                ret = dcmDBUtils->_dcm_svc_db_disconnect();
        }
-       else if (recv_msg->msg_type == DCM_IPC_MSG_SCAN_SINGLE)
-       {
-               ret = dcmDBUtils->_dcm_svc_db_connect(recv_msg->uid);
-               if (ret != DCM_SUCCESS) {
-                       dcm_error("Failed to connect db! err: %d", ret);
-               }
-               /* Create a scan idle if not exist, and scan single image of which file path is reveived from tcp socket */
-               if (recv_msg->msg_size > 0 && recv_msg->msg_size < DCM_IPC_MSG_MAX_SIZE) {
-                       char *file_path = NULL;
-                       file_path = strdup(recv_msg->msg);
-                       if (file_path != NULL) {
-                               ScanSingleItem((const char *) file_path);
-                               DCM_SAFE_FREE(file_path);
-                       } else {
-                               dcm_error("Failed to copy message!");
-                               ret = DCM_ERROR_OUT_OF_MEMORY;
-                       }
-               } else {
-                       dcm_error("Invalid receive message!");
-                       ret = DCM_ERROR_IPC_INVALID_MSG;
-               }
-               ret = dcmDBUtils->_dcm_svc_db_disconnect();
-               if (ret != DCM_SUCCESS) {
-                       dcm_error("Failed to disconnect db! err: %d", ret);
-               }
-       }
        else {
                dcm_error("Invalid message type(%d)!", recv_msg->msg_type);
                ret = DCM_ERROR_IPC_INVALID_MSG;
@@ -716,7 +690,8 @@ gboolean DcmScanCallback::readyScanThreadIdle(gpointer data)
                dcm_error("memory allocation failed");
                return FALSE;
        }
-       async_queue_msg->msg_type = DCM_IPC_MSG_SCAN_READY;
+
+       async_queue_msg->msg_type = DCM_MSG_SCAN_READY;
 
        dcm_debug("scan thread ready : %p", ad->scan_thread_ready);
        dcm_debug("async_queue_msg : %d", async_queue_msg->msg_type);

diff --git a/svc/DcmMainSvc.cpp b/svc/DcmMainSvc.cpp
index 123c0d2f20b814566a2041f46bdd1518907190d6..ba8a0fd87cb588c5984d8a974ae2f184e1a7f22b 100755 (executable)
--- a/svc/DcmMainSvc.cpp
+++ b/svc/DcmMainSvc.cpp
@@ -63,7 +63,7 @@ void DcmMainSvc::dcmServiceStartjobs(void)
        }
 
        /* Send ready response to dcm launcher */
-       if (DcmIpcUtils::sendSocketMsg(DCM_IPC_MSG_SERVICE_READY, 0, NULL, DCM_IPC_PORT_MS_RECV) != DCM_SUCCESS) {
+       if (DcmIpcUtils::sendSocketMsg(DCM_MSG_SERVER_READY, 0, NULL, DCM_IPC_PORT_MS_RECV) != DCM_SUCCESS) {
                dcm_error("Failed to send ready message");
        }
 }
@@ -86,7 +86,7 @@ int DcmMainSvc::waitScanThreadReady()
        }
 
        /* Check if scan thread is created */
-       if (async_queue_msg->msg_type == DCM_IPC_MSG_SCAN_READY) {
+       if (async_queue_msg->msg_type == DCM_MSG_SCAN_READY) {
                dcm_warn("DCM scan thread is ready!");
                g_async_queue_unref(scan_thread_ready);
                scan_thread_ready = NULL;
@@ -180,32 +180,32 @@ gboolean DcmMainSvcCallBack::readMsg(GIOChannel *src, GIOCondition condition, gp
                dcm_debug("scan thread is already running!");
        }
 
-       if (recv_msg.msg_type == DCM_IPC_MSG_SCAN_TERMINATED) {
+       if (recv_msg.msg_type == DCM_MSG_SCAN_TERMINATED) {
                dcm_debug("Scan terminated!");
                dcmSvc->scan_thread_working = false;
                dcmSvc->createQuitTimerMainLoop();
-       } else if (recv_msg.msg_type == DCM_IPC_MSG_SCAN_COMPLETED) {
+       } else if (recv_msg.msg_type == DCM_MSG_SCAN_COMPLETED) {
                dcm_debug("Scan completed!");
-               ret = DcmIpcUtils::sendClientSocketMsg(-1, DCM_IPC_MSG_SERVICE_COMPLETED, recv_msg.result, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
-       } else if (recv_msg.msg_type == DCM_IPC_MSG_KILL_SERVICE) {
+               ret = DcmIpcUtils::sendClientSocketMsg(-1, DCM_MSG_EXTRACT_ALL_DONE, recv_msg.result, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
+       } else if (recv_msg.msg_type == DCM_MSG_REQUEST_KILL_SERVER) {
                dcm_warn("Quit dcm-svc main loop!");
-               ret = DcmIpcUtils::sendSocketMsg(DCM_IPC_MSG_KILL_SERVICE, recv_msg.uid, recv_msg.msg, DCM_IPC_PORT_SCAN_RECV);
-       } else if (recv_msg.msg_type == DCM_IPC_MSG_SCAN_ALL) {
-               ret = DcmIpcUtils::sendSocketMsg(DCM_IPC_MSG_SCAN_ALL, recv_msg.uid, NULL, DCM_IPC_PORT_SCAN_RECV);
+               ret = DcmIpcUtils::sendSocketMsg(DCM_MSG_REQUEST_KILL_SERVER, recv_msg.uid, recv_msg.msg, DCM_IPC_PORT_SCAN_RECV);
+       } else if (recv_msg.msg_type == DCM_MSG_REQUEST_ALL_MEDIA) {
+               ret = DcmIpcUtils::sendSocketMsg(DCM_MSG_REQUEST_ALL_MEDIA, recv_msg.uid, NULL, DCM_IPC_PORT_SCAN_RECV);
                if (ret == DCM_SUCCESS) {
-                       ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_IPC_MSG_SCAN_ALL, recv_msg.uid, NULL, DCM_IPC_PORT_DCM_RECV);
+                       ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_MSG_REQUEST_ALL_MEDIA, recv_msg.uid, NULL, DCM_IPC_PORT_DCM_RECV);
                }
-       } else if (recv_msg.msg_type == DCM_IPC_MSG_SCAN_SINGLE) {
+       } else if (recv_msg.msg_type == DCM_MSG_REQUEST_MEDIA) {
                dcm_debug("Scan single");
                ret = DcmScanMain::ScanSingle(recv_msg.msg, recv_msg.uid, &face_count);
                dcm_debug("Scan single result: %d (%d)", ret, face_count);
                if (ret == DCM_SUCCESS) {
-                       ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_IPC_MSG_SCAN_SINGLE, face_count, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
+                       ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_MSG_REQUEST_MEDIA, face_count, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
                        if (ret != DCM_SUCCESS) {
                                dcm_error("Failed to sendClientSocketMsg! err: %d", ret);
                        }
                } else {
-                       ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_IPC_MSG_SCAN_SINGLE, ret, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
+                       ret = DcmIpcUtils::sendClientSocketMsg(client_sock, DCM_MSG_REQUEST_MEDIA, ret, recv_msg.msg, DCM_IPC_PORT_MS_RECV);
                        if (ret != DCM_SUCCESS) {
                                dcm_error("Failed to sendClientSocketMsg! err: %d", ret);
                        }