Remove the BackendQueue from Servertizen

This patch is to reduce the dependency between structs

Change-Id: If041a8fb52b0b22fb01f5f70693a7cb8a56329f7
Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>

11 files changed, 133 insertions, 164 deletions

diff --git a/src/main.rs b/src/main.rs
index a2365a0..bd6d929 100755
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,7 @@ mod pkgmgr;
 use std::process::Command;
 
 fn main() {
-    let server = pkgmgr::server::Server::new();
+    let mut server = pkgmgr::server::Server::new();
 
-    pkgmgr::server::Server::run(server);
+    pkgmgr::server::Server::run(&mut server);
 }
\ No newline at end of file
diff --git a/src/pkgmgr/server/admin_service.rs b/src/pkgmgr/server/admin_service.rs
index f75ff28..d731429 100755
--- a/src/pkgmgr/server/admin_service.rs
+++ b/src/pkgmgr/server/admin_service.rs
@@ -302,7 +302,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_create_cb(
     user_data: *mut c_void,
 ) {
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    Server::update_timeout(&service.server);
+    BackendQueue::update_timeout(&service.backend_queue);
 }
 
 #[allow(non_snake_case)]
@@ -405,8 +405,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_Install_cb(
     }
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let backend_path = match queue.get_backend_path(&pkg_type) {
         Some(s) => s.clone(),
         None => return PKGMGR_RETURN_VALUE::ERROR as i32,
@@ -510,8 +509,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_InstallPkgs_cb(
     vec.append(&mut extra_args);
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::INSTALL,
@@ -564,8 +562,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_Reinstall_cb(
     };
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let backend_path = match queue.get_backend_path(&pkg_type) {
         Some(s) => s.clone(),
         None => return PKGMGR_RETURN_VALUE::ERROR as i32,
@@ -681,8 +678,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_MountInstall_cb(
     }
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let backend_path = match queue.get_backend_path(&pkg_type) {
         Some(s) => s.clone(),
         None => return PKGMGR_RETURN_VALUE::ERROR as i32,
@@ -766,8 +762,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_MountInstallPkgs_cb(
     vec.append(&mut pkg_paths);
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::MOUNT_INSTALL,
@@ -820,8 +815,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_Uninstall_cb(
     };
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let backend_path = match queue.get_backend_path(&pkg_type) {
         Some(s) => s.clone(),
         None => return PKGMGR_RETURN_VALUE::ERROR as i32,
@@ -903,8 +897,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_UninstallPkgs_cb(
     vec.append(&mut pkgids);
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::UNINSTALL,
@@ -958,8 +951,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_Move_cb(
     };
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let backend_path = match queue.get_backend_path(&pkg_type) {
         Some(s) => s.clone(),
         None => return PKGMGR_RETURN_VALUE::ERROR as i32,
@@ -1033,8 +1025,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_EnablePkgs_cb(
             let pkg_id = c_str.to_string_lossy().into_owned();
             let pkg_type = Util::GetPackageType(c_char_ptr, uid as u32);
             let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-            let mut server = service.server.borrow_mut();
-            let mut queue = server.get_backend_queue();
+            let mut queue = service.backend_queue.borrow_mut();
             let backend_path = match queue.get_backend_path(&pkg_type) {
                 Some(s) => s.clone(),
                 None => return PKGMGR_RETURN_VALUE::ERROR as i32,
@@ -1119,8 +1110,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_DisablePkgs_cb(
             debug!("push disable pkg {pkg_id}");
 
             let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-            let mut server = service.server.borrow_mut();
-            let mut queue = server.get_backend_queue();
+            let mut queue = service.backend_queue.borrow_mut();
             let backend_path = match queue.get_backend_path(&pkg_type) {
                 Some(s) => s.clone(),
                 None => return PKGMGR_RETURN_VALUE::ERROR as i32,
@@ -1199,8 +1189,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_RegisterPkgUpdateInfo_cb(
 
     let pkg_id = CString::from(unsafe { CStr::from_ptr(pkg_id) });
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::REGISTER_PKG_UPDATE_INFO,
@@ -1258,8 +1247,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_UnregisterPkgUpdateInfo_cb(
 
     let pkg_id = CString::from(unsafe { CStr::from_ptr(pkg_id) });
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::UNREGISTER_PKG_UPDATE_INFO,
@@ -1308,8 +1296,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_UnregisterAllPkgUpdateInfo_cb(
     };
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::UNREGISTER_ALL_PKG_UPDATE_INFO,
@@ -1562,8 +1549,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_EnableApp_cb(
         };
 
         let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-        let mut server = service.server.borrow_mut();
-        let mut queue = server.get_backend_queue();
+        let mut queue = service.backend_queue.borrow_mut();
 
         let app_id = match CString::new(app_id_str) {
             Ok(s) => s,
@@ -1616,8 +1602,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_DisableApp_cb(
         };
 
         let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-        let mut server = service.server.borrow_mut();
-        let mut queue = server.get_backend_queue();
+        let mut queue = service.backend_queue.borrow_mut();
 
         let app_id = match CString::new(app_id_str) {
             Ok(s) => s,
@@ -1674,8 +1659,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_EnableApps_cb(
         }
 
         let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-        let mut server = service.server.borrow_mut();
-        let mut queue = server.get_backend_queue();
+        let mut queue = service.backend_queue.borrow_mut();
 
         for i in 0..size {
             let c_char_ptr = *value.offset(i as isize);
@@ -1737,8 +1721,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_DisableApps_cb(
         }
 
         let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-        let mut server = service.server.borrow_mut();
-        let mut queue = server.get_backend_queue();
+        let mut queue = service.backend_queue.borrow_mut();
 
         for i in 0..size {
             let c_char_ptr = *value.offset(i as isize);
@@ -1796,8 +1779,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_EnableGlobalAppForUid_cb(
         };
 
         let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-        let mut server = service.server.borrow_mut();
-        let mut queue = server.get_backend_queue();
+        let mut queue = service.backend_queue.borrow_mut();
 
         let app_id = match CString::new(app_id_str) {
             Ok(s) => s,
@@ -1850,8 +1832,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_DisableGlobalAppForUid_cb(
         };
 
         let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-        let mut server = service.server.borrow_mut();
-        let mut queue = server.get_backend_queue();
+        let mut queue = service.backend_queue.borrow_mut();
 
         let app_id = match CString::new(app_id_str) {
             Ok(s) => s,
@@ -1919,8 +1900,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_GenerateLicenseRequest_cb(
 
     let resp_data = CString::from(unsafe { CStr::from_ptr(resp_data) });
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let mut backend_context = BackendContext::new(
         RequestType::GENERATE_LICENSE_REQUEST,
         "default".to_string(),
@@ -1978,8 +1958,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_GetGenerateLicenseResult_cb(
     };
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     match queue.get_generate_license_result(&req_key) {
         Some((ret, req_data_c, license_url_c)) => {
@@ -2033,8 +2012,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_RegisterLicense_cb(
 
     let resp_data = CString::from(unsafe { CStr::from_ptr(resp_data) });
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let mut backend_context = BackendContext::new(
         RequestType::REGISTER_LICENSE,
         "default".to_string(),
@@ -2085,8 +2063,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_DecryptPackage_cb(
     let drm_file_path = CString::from(unsafe { CStr::from_ptr(drm_file_path) });
     let decrypted_file_path = CString::from(unsafe { CStr::from_ptr(decrypted_file_path) });
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let mut backend_context = BackendContext::new(
         RequestType::DECRYPT_PACKAGE,
         "default".to_string(),
@@ -2156,8 +2133,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_SetAppLabel_cb(
     let app_id = CString::from(unsafe { CStr::from_ptr(app_id) });
     let label = CString::from(unsafe { CStr::from_ptr(label) });
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let mut backend_context = BackendContext::new(
         RequestType::SET_APP_LABEL,
         "pkgmgr".to_string(),
@@ -2207,8 +2183,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_SetAppIcon_cb(
     let app_id = CString::from(unsafe { CStr::from_ptr(app_id) });
     let icon_path = CString::from(unsafe { CStr::from_ptr(icon_path) });
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
     let mut backend_context = BackendContext::new(
         RequestType::SET_APP_ICON,
         "pkgmgr".to_string(),
@@ -2388,8 +2363,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_ResCopy_cb(
     }
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::RESOURCE_SHARE_COPY,
@@ -2459,8 +2433,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_ResCreateDir_cb(
     }
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::RESOURCE_SHARE_CREATE_DIR,
@@ -2530,8 +2503,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_ResRemove_cb(
     }
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::RESOURCE_SHARE_REMOVE,
@@ -2579,8 +2551,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_ResUninstall_cb(
             "-d".to_string(), pkg_id.to_string()];
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::RESOURCE_SHARE_UNINSTALL,
@@ -2625,8 +2596,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_ClearData_cb(
             "-u".to_string(), uid.to_string()];
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::CLEARDATA,
@@ -2685,8 +2655,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrAdmin_ClearDataWithPath_cb(
             "-f".to_string(), file_path];
 
     let service: &mut AdminService = unsafe { &mut *(user_data as *mut AdminService) };
-    let mut server = service.server.borrow_mut();
-    let mut queue = server.get_backend_queue();
+    let mut queue = service.backend_queue.borrow_mut();
 
     let mut backend_context = BackendContext::new(
         RequestType::REMOVE_FILE,
@@ -2741,14 +2710,14 @@ extern "C" {
 }
 
 pub struct AdminService {
-    server: Rc<RefCell<Server>>,
+    backend_queue: Rc<RefCell<BackendQueue>>,
     callbacks: rpc_port_stub_PkgMgrAdmin_callback,
 }
 
 impl AdminService {
-    pub fn new(server: Rc<RefCell<Server>>) -> Self {
+    pub fn new(backend_queue: Rc<RefCell<BackendQueue>>) -> Self {
         Self {
-            server,
+            backend_queue,
             callbacks: rpc_port_stub_PkgMgrAdmin_callback {
                 rpc_port_stub_PkgMgrAdmin_create_cb: impl_rpc_port_stub_PkgMgrAdmin_create_cb,
                 rpc_port_stub_PkgMgrAdmin_terminate_cb: impl_rpc_port_stub_PkgMgrAdmin_terminate_cb,
diff --git a/src/pkgmgr/server/backend_queue.rs b/src/pkgmgr/server/backend_queue.rs
index 4be5e95..982f9dd 100755
--- a/src/pkgmgr/server/backend_queue.rs
+++ b/src/pkgmgr/server/backend_queue.rs
@@ -2,6 +2,7 @@ extern crate libc;
 extern crate glib_sys;
 use super::backend_context::BackendContext;
 use super::request_result::RequestResult;
+use super::util::*;
 use std::collections::{VecDeque, HashMap, HashSet};
 use std::cell::RefCell;
 use std::ffi::{c_int, c_void, CString};
@@ -12,6 +13,8 @@ use std::path::Path;
 
 use pkgmgr::dlog_wrapper::*;
 
+use self::glib_sys::*;
+
 type GIOChannel = *mut c_void;
 type GIOCondition = c_int;
 
@@ -20,6 +23,7 @@ use self::libc::*;
 const G_IO_STATUS_NORMAL: c_int = 1;
 const G_SOURCE_CONTINUE: c_int = 1;
 const G_SOURCE_REMOVE: c_int = 0;
+const PKGMGR_SERVER_TIMEOUT: c_uint = 15;
 
 extern "C" fn queue_job(data: *mut c_void) -> c_int {
     debug!("queue job start");
@@ -64,6 +68,22 @@ extern "C" fn signal_handler_cb(io: *mut glib_sys::GIOChannel,
     1
 }
 
+extern "C" fn exit_server(data: *mut c_void) -> glib_sys::gboolean {
+    error!("exit_server Start");
+
+    let queue: &Rc<RefCell<BackendQueue>> = unsafe { &mut *(data as *mut Rc<RefCell<BackendQueue>>) };
+    let mut mut_queue = queue.borrow_mut();
+
+    if (mut_queue.is_queue_empty()) {
+        unsafe {
+            g_main_loop_quit(mut_queue.mainloop);
+            release_power_lock();
+        }
+        return G_SOURCE_REMOVE;
+    }
+    return G_SOURCE_CONTINUE;
+}
+
 struct Backend {
     path: String,
     context_: VecDeque<BackendContext>,
@@ -150,11 +170,13 @@ pub struct BackendQueue {
     delayed_result_: HashMap<String, i32>,
     get_size_sync_result_: HashMap<String, (i32, i64)>,
     generate_license_result_: HashMap<String, (i32, CString, CString)>,
+    mainloop: *mut GMainLoop,
+    timer: c_uint
 }
 
 impl BackendQueue {
-    pub fn new() -> Self {
-        Self {
+    pub fn new(mainloop: *mut GMainLoop) -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Self {
             prepared_contexts_: Backend::init(),
             running_contexts_: HashMap::new(),
             sio_: std::ptr::null_mut() as *mut glib_sys::GIOChannel,
@@ -162,8 +184,10 @@ impl BackendQueue {
             exclusive_running_: false,
             delayed_result_: HashMap::new(),
             get_size_sync_result_: HashMap::new(),
-            generate_license_result_: HashMap::new()
-        }
+            generate_license_result_: HashMap::new(),
+            mainloop: mainloop,
+            timer: 0
+        }))
     }
 
     pub fn push(&mut self, mut context: BackendContext) -> i32 {
@@ -343,4 +367,17 @@ impl BackendQueue {
 
         return true;
     }
+
+    pub fn update_timeout(queue: &Rc<RefCell<Self>>) {
+        unsafe {
+            let mut mut_queue = queue.borrow_mut();
+            if mut_queue.timer > 0 {
+                g_source_remove(mut_queue.timer);
+            }
+
+            mut_queue.timer = g_timeout_add_seconds_full(
+                    G_PRIORITY_LOW, PKGMGR_SERVER_TIMEOUT, Some(exit_server),
+                    queue as *const _ as *mut c_void, None);
+        }
+    }
 }
diff --git a/src/pkgmgr/server/cache_service.rs b/src/pkgmgr/server/cache_service.rs
index 9ff4c4f..322f6f2 100755
--- a/src/pkgmgr/server/cache_service.rs
+++ b/src/pkgmgr/server/cache_service.rs
@@ -34,7 +34,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrForClearCache_create_cb(
     user_data: *mut c_void,
 ) {
     let service: &mut CacheService = unsafe { &mut *(user_data as *mut CacheService) };
-    Server::update_timeout(&service.server);
+    BackendQueue::update_timeout(&service.backend_queue);
 }
 
 #[allow(non_snake_case)]
@@ -91,7 +91,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgrForClearCache_ClearCache_cb(
     );
 
     debug!("push");
-    service.server.borrow_mut().get_backend_queue().push(backend_context);
+    service.backend_queue.borrow_mut().push(backend_context);
     0
 }
 
@@ -111,14 +111,14 @@ extern "C" {
 }
 
 pub struct CacheService {
-    server: Rc<RefCell<Server>>,
+    backend_queue: Rc<RefCell<BackendQueue>>,
     callbacks: rpc_port_stub_PkgMgrForClearCache_callback,
 }
 
 impl CacheService {
-    pub fn new(server: Rc<RefCell<Server>>) -> CacheService {
+    pub fn new(backend_queue: Rc<RefCell<BackendQueue>>) -> CacheService {
         CacheService {
-            server,
+            backend_queue,
             callbacks: rpc_port_stub_PkgMgrForClearCache_callback {
                 rpc_port_stub_PkgMgrForClearCache_create_cb:
                     impl_rpc_port_stub_PkgMgrForClearCache_create_cb,
diff --git a/src/pkgmgr/server/delayed_service.rs b/src/pkgmgr/server/delayed_service.rs
index 8369d91..d5df46f 100755
--- a/src/pkgmgr/server/delayed_service.rs
+++ b/src/pkgmgr/server/delayed_service.rs
@@ -35,7 +35,7 @@ pub extern "C" fn impl_rpc_port_stub_DelayedResult_create_cb(
     user_data: *mut c_void,
 ) {
     let service: &mut DelayedService = unsafe { &mut *(user_data as *mut DelayedService) };
-    Server::update_timeout(&service.server);
+    BackendQueue::update_timeout(&service.backend_queue);
 }
 
 #[allow(non_snake_case)]
@@ -66,7 +66,7 @@ pub extern "C" fn impl_rpc_port_stub_DelayedResult_GetResult_cb(
     };
 
     let service: &mut DelayedService = unsafe { &mut *(user_data as *mut DelayedService) };
-    match service.server.borrow_mut().get_backend_queue().get_delayed_result(&req_key) {
+    match service.backend_queue.borrow_mut().get_delayed_result(&req_key) {
         Some(s) => unsafe { *result = s },
         None => return PKGMGR_RETURN_VALUE::ERROR as i32
     };
@@ -84,14 +84,14 @@ extern "C" {
 }
 
 pub struct DelayedService {
-    server: Rc<RefCell<Server>>,
+    backend_queue: Rc<RefCell<BackendQueue>>,
     callbacks: rpc_port_stub_DelayedResult_callback,
 }
 
 impl DelayedService {
-    pub fn new(server: Rc<RefCell<Server>>) -> DelayedService {
+    pub fn new(backend_queue: Rc<RefCell<BackendQueue>>) -> DelayedService {
         DelayedService {
-            server,
+            backend_queue,
             callbacks: rpc_port_stub_DelayedResult_callback {
                 rpc_port_stub_DelayedResult_create_cb:
                     impl_rpc_port_stub_DelayedResult_create_cb,
diff --git a/src/pkgmgr/server/info_service.rs b/src/pkgmgr/server/info_service.rs
index 22b35f1..c4847f7 100755
--- a/src/pkgmgr/server/info_service.rs
+++ b/src/pkgmgr/server/info_service.rs
@@ -46,7 +46,7 @@ pub struct rpc_port_stub_PkgMgr_callback {
 
 pub extern "C" fn impl_rpc_port_stub_PkgMgr_create_cb(context: *mut c_void, user_data: *mut c_void) {
     let service: &mut InfoService = unsafe { &mut *(user_data as *mut InfoService) };
-    Server::update_timeout(&service.server);
+    BackendQueue::update_timeout(&service.backend_queue);
 }
 
 pub extern "C" fn impl_rpc_port_stub_PkgMgr_terminate_cb(context: *mut c_void, user_data: *mut c_void) {
@@ -108,7 +108,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgr_GetSize_cb(
     );
 
     debug!("push");
-    service.server.borrow_mut().get_backend_queue().push(backend_context);
+    service.backend_queue.borrow_mut().push(backend_context);
 
     0
 }
@@ -159,7 +159,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgr_GetSizeSync_cb(
             "--sync".to_string()];
 
     let service: &mut InfoService = unsafe { &mut *(user_data as *mut InfoService) };
-    let boxed_server = service.server.clone();
+    let boxed_queue = service.backend_queue.clone();
 
     let mut backend_context = BackendContext::new(
         RequestType::GETSIZE_SYNC,
@@ -180,7 +180,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgr_GetSizeSync_cb(
             }
 
             let func = Box::new(move |req_key, result, size_result| {
-                boxed_server.borrow_mut().get_backend_queue()
+                boxed_queue.borrow_mut()
                         .insert_get_size_sync_result(req_key, result, size_result);
             });
 
@@ -190,7 +190,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgr_GetSizeSync_cb(
         })
     );
 
-    service.server.borrow_mut().get_backend_queue().push(backend_context);
+    service.backend_queue.borrow_mut().push(backend_context);
 
     PKGMGR_RETURN_VALUE::OK as i32
 }
@@ -213,9 +213,7 @@ pub extern "C" fn impl_rpc_port_stub_PkgMgr_GetResultSizeSync_cb(
     };
 
     let service: &mut InfoService = unsafe { &mut *(user_data as *mut InfoService) };
-    let mut queue = service.server.borrow_mut().get_backend_queue();
-
-    match service.server.borrow_mut().get_backend_queue()
+    match service.backend_queue.borrow_mut()
             .get_result_of_get_size_sync(&req_key) {
         Some((ret, size_result)) => unsafe { *result = ret; *size_info = size_result },
         None => return PKGMGR_RETURN_VALUE::ERROR as i32
@@ -251,14 +249,14 @@ extern "C" {
 }
 
 pub struct InfoService {
-    server: Rc<RefCell<Server>>,
+    backend_queue: Rc<RefCell<BackendQueue>>,
     callbacks : rpc_port_stub_PkgMgr_callback
 }
 
 impl InfoService {
-    pub fn new(server: Rc<RefCell<Server>>) -> InfoService {
+    pub fn new(backend_queue: Rc<RefCell<BackendQueue>>) -> InfoService {
         InfoService {
-            server,
+            backend_queue,
             callbacks : rpc_port_stub_PkgMgr_callback {
                 rpc_port_stub_PkgMgr_create_cb: impl_rpc_port_stub_PkgMgr_create_cb,
                 rpc_port_stub_PkgMgr_terminate_cb: impl_rpc_port_stub_PkgMgr_terminate_cb,
diff --git a/src/pkgmgr/server/mod.rs b/src/pkgmgr/server/mod.rs
index ff4a0d6..ce21b2f 100755
--- a/src/pkgmgr/server/mod.rs
+++ b/src/pkgmgr/server/mod.rs
@@ -30,7 +30,6 @@ use self::glib_sys::*;
 use std::rc::Rc;
 
 const SD_LISTEN_FDS_START: i32 = 3;
-const PKGMGR_SERVER_TIMEOUT: c_uint = 15;
 
 #[link(name = "aul")]
 extern "C" {
@@ -63,38 +62,21 @@ enum AUL_RETURN_VALUE {
     AUL_R_OK = 0,                //< General success
 }
 
-extern "C" fn exit_server(data: *mut c_void) -> glib_sys::gboolean {
-    error!("exit_server Start");
-
-    let server: &Rc<RefCell<Server>> = unsafe { &mut *(data as *mut Rc<RefCell<Server>>) };
-
-    if (server.borrow_mut().backend_queue.is_queue_empty()) {
-        unsafe {
-            g_main_loop_quit(server.borrow_mut().mainloop);
-            util::release_power_lock();
-        }
-        return G_SOURCE_REMOVE;
-    }
-    return G_SOURCE_CONTINUE;
-}
-
 pub struct Server {
     mainloop: *mut GMainLoop,
-    backend_queue: BackendQueue,
     timer: c_uint
 }
 
 impl Server {
-    pub fn new() -> Rc<RefCell<Self>> {
-        Rc::new(RefCell::new(Self {
+    pub fn new() -> Self {
+        Self {
             mainloop: std::ptr::null_mut() as *mut GMainLoop,
-            backend_queue: BackendQueue::new(),
             timer: 0
-        }))
+        }
     }
 
-    pub fn run(server: Rc<RefCell<Self>>) -> Result<(), ()> {
-        server.borrow_mut().mainloop = unsafe {
+    pub fn run(&mut self) -> Result<(), ()> {
+        self.mainloop = unsafe {
             g_main_loop_new(g_main_context_default(), false as gboolean)
         };
 
@@ -102,28 +84,28 @@ impl Server {
             if aul_proc_register("d::org.tizen.appfw.pkgmgr\0".as_ptr(), std::ptr::null_mut())
                 != AUL_RETURN_VALUE::AUL_R_OK as i32
             {
-                g_main_loop_unref(server.borrow_mut().mainloop);
-                server.borrow_mut().mainloop = std::ptr::null_mut();
+                g_main_loop_unref(self.mainloop);
+                self.mainloop = std::ptr::null_mut();
                 return Err(());
             }
         }
 
-        server.borrow_mut().backend_queue.register_signal_handler();
+        let mut backend_queue = BackendQueue::new(self.mainloop);
+        backend_queue.borrow_mut().register_signal_handler();
 
-        let mut admin_service = AdminService::new(server.clone());
+        let mut admin_service = AdminService::new(backend_queue.clone());
         admin_service.run();
-        let mut cache_service = CacheService::new(server.clone());
+        let mut cache_service = CacheService::new(backend_queue.clone());
         cache_service.run();
-        let mut info_service = InfoService::new(server.clone());
+        let mut info_service = InfoService::new(backend_queue.clone());
         info_service.run();
-        let mut delayed_result_service = DelayedService::new(server.clone());
+        let mut delayed_result_service = DelayedService::new(backend_queue.clone());
         delayed_result_service.run();
 
         unsafe {
             sd_notify(0, "READY=1\0".as_ptr() as *const c_char);
-            Server::update_timeout(&server);
-            let main_loop = server.borrow_mut().mainloop;
-            g_main_loop_run(main_loop);
+            BackendQueue::update_timeout(&backend_queue);
+            g_main_loop_run(self.mainloop);
 
             sd_notify(0, "STOPPING=1\0".as_ptr() as *const c_char);
         }
@@ -134,26 +116,9 @@ impl Server {
         delayed_result_service.stop();
 
         unsafe {
-            g_main_loop_unref(server.borrow_mut().mainloop);
+            g_main_loop_unref(self.mainloop);
         }
 
         Ok(())
     }
-
-    pub fn get_backend_queue(&mut self) -> &mut BackendQueue {
-        &mut self.backend_queue
-    }
-
-    pub fn update_timeout(server: &Rc<RefCell<Self>>) {
-        unsafe {
-            let mut mut_server = server.borrow_mut();
-            if mut_server.timer > 0 {
-                g_source_remove(mut_server.timer);
-            }
-
-            mut_server.timer = g_timeout_add_seconds_full(
-                    G_PRIORITY_LOW, PKGMGR_SERVER_TIMEOUT, Some(exit_server),
-                    server as *const _ as *mut c_void, None);
-        }
-    }
 }
diff --git a/src/pkgmgr/server/test/admin_service_tests.rs b/src/pkgmgr/server/test/admin_service_tests.rs
index 849ed90..54fdbe2 100755
--- a/src/pkgmgr/server/test/admin_service_tests.rs
+++ b/src/pkgmgr/server/test/admin_service_tests.rs
@@ -1,17 +1,17 @@
-use super::super::Server;
+use super::super::super::server::backend_queue::BackendQueue;
 use super::super::super::server::admin_service::AdminService;
 use super::super::super::server::service::Service;
 
 #[test]
 fn run_test() {
-    let server = Server::new();
-    let mut admin_service = AdminService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut admin_service = AdminService::new(backend_queue.clone());
     assert_eq!(Ok(()), admin_service.run());
 }
 
 #[test]
 fn stop_test() {
-    let server = Server::new();
-    let mut admin_service = AdminService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut admin_service = AdminService::new(backend_queue.clone());
     assert_eq!(Ok(()), admin_service.stop());
 }
\ No newline at end of file
diff --git a/src/pkgmgr/server/test/cache_service_tests.rs b/src/pkgmgr/server/test/cache_service_tests.rs
index 2ce781e..63b7bcc 100755
--- a/src/pkgmgr/server/test/cache_service_tests.rs
+++ b/src/pkgmgr/server/test/cache_service_tests.rs
@@ -1,17 +1,17 @@
-use super::super::Server;
+use super::super::super::server::backend_queue::BackendQueue;
 use super::super::super::server::cache_service::CacheService;
 use super::super::super::server::service::Service;
 
 #[test]
 fn run_test() {
-    let server = Server::new();
-    let mut cache_service = CacheService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut cache_service = CacheService::new(backend_queue.clone());
     assert_eq!(Ok(()), cache_service.run());
 }
 
 #[test]
 fn stop_test() {
-    let server = Server::new();
-    let mut cache_service = CacheService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut cache_service = CacheService::new(backend_queue.clone());
     assert_eq!(Ok(()), cache_service.stop());
 }
diff --git a/src/pkgmgr/server/test/delayed_service_tests.rs b/src/pkgmgr/server/test/delayed_service_tests.rs
index 5fc96ad..6456242 100755
--- a/src/pkgmgr/server/test/delayed_service_tests.rs
+++ b/src/pkgmgr/server/test/delayed_service_tests.rs
@@ -1,17 +1,17 @@
-use super::super::Server;
+use super::super::super::server::backend_queue::BackendQueue;
 use super::super::super::server::delayed_service::DelayedService;
 use super::super::super::server::service::Service;
 
 #[test]
 fn run_test() {
-    let server = Server::new();
-    let mut delayed_service = DelayedService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut delayed_service = DelayedService::new(backend_queue.clone());
     assert_eq!(Ok(()), delayed_service.run());
 }
 
 #[test]
 fn stop_test() {
-    let server = Server::new();
-    let mut delayed_service = DelayedService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut delayed_service = DelayedService::new(backend_queue.clone());
     assert_eq!(Ok(()), delayed_service.stop());
 }
\ No newline at end of file
diff --git a/src/pkgmgr/server/test/info_service_tests.rs b/src/pkgmgr/server/test/info_service_tests.rs
index c747e50..919d316 100755
--- a/src/pkgmgr/server/test/info_service_tests.rs
+++ b/src/pkgmgr/server/test/info_service_tests.rs
@@ -1,17 +1,17 @@
-use super::super::Server;
+use super::super::super::server::backend_queue::BackendQueue;
 use super::super::super::server::info_service::InfoService;
 use super::super::super::server::service::Service;
 
 #[test]
 fn run_test() {
-    let server = Server::new();
-    let mut info_service = InfoService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut info_service = InfoService::new(backend_queue.clone());
     assert_eq!(Ok(()), info_service.run());
 }
 
 #[test]
 fn stop_test() {
-    let server = Server::new();
-    let mut info_service = InfoService::new(server.clone());
+    let mut backend_queue = BackendQueue::new(std::ptr::null_mut());
+    let mut info_service = InfoService::new(backend_queue.clone());
     assert_eq!(Ok(()), info_service.stop());
 }
\ No newline at end of file