src/server/runner.cc

   1 /*
   2  * Copyright (c) 2021 - 2022 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <cpu-boosting.h>
  18 #include <fcntl.h>
  19 #include <glib-unix.h>
  20 #include <stdlib.h>
  21 #include <vconf.h>
  22
  23 #include <algorithm>
  24 #include <string>
  25
  26 #include "cache_flag.hh"
  27 #include "create_cache_request.hh"
  28 #include "cynara_checker.hh"
  29 #include "pkg_request.hh"
  30 #include "runner.hh"
  31 #include "utils/logging.hh"
  32
  33 #include "pkgmgrinfo_debug.h"
  34 #include "pkgmgrinfo_private.h"
  35
  36 #ifdef LOG_TAG
  37 #undef LOG_TAG
  38 #endif
  39 #define LOG_TAG "PKGMGR_INFO"
  40
  41 namespace pkgmgr_server {
  42 namespace {
  43
  44 static const std::string SOCK_PATH = "/run/pkgmgr-info-server";
  45 constexpr const char PRIVILEGE_PACKAGE_MANAGER_ADMIN[] =
  46     "http://tizen.org/privilege/packagemanager.admin";
  47 constexpr const char DEST_PROCESS_NAME[] = "pkgmgr-info";
  48
  49 }  // namespace
  50
  51 Runner::Runner(unsigned int thread_num) {
  52   /* thread_num_ <= hardware_concurrency */
  53   thread_num_ = std::min(thread_num, std::thread::hardware_concurrency());
  54   CynaraChecker::GetInst().Init();
  55   server_ = std::make_unique<pkgmgr_common::socket::ServerSocket>(SOCK_PATH);
  56   thread_pool_ = std::make_unique<WorkerThread>(thread_num_);
  57   SetCPUInheritance();
  58   auto condition = static_cast<GIOCondition>(G_IO_IN);
  59   sid_ = g_unix_fd_add(server_->GetFd(), condition, OnReceiveRequest, this);
  60   default_uid_ = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
  61   pkgmgr_common::SystemLocale::GetInst().RegisterEvent(this);
  62   thread_pool_->SetLocale(pkgmgr_common::SystemLocale::GetInst().Get());
  63
  64   if (CacheFlag::SetPreparing())
  65     QueueRequest(std::make_shared<CreateCacheRequest>(default_uid_, this));
  66
  67   LOGI("Start Runner");
  68 }
  69
  70 Runner::~Runner() {
  71   g_source_remove(sid_);
  72   CynaraChecker::GetInst().Fini();
  73   pkgmgr_common::SystemLocale::GetInst().UnRegisterEvent();
  74 }
  75
  76 int Runner::OnReceiveRequest(int fd, GIOCondition cond, void* user_data) {
  77   auto runner = static_cast<Runner*>(user_data);
  78   int client_fd = runner->server_->Accept();
  79   if (client_fd < 0) {
  80     LOG(ERROR) << "Failed to Accept. errno:" << errno;
  81     return G_SOURCE_CONTINUE;
  82   }
  83
  84   auto req = std::make_shared<PkgRequest>(client_fd);
  85
  86   if (CacheFlag::SetPreparing()) {
  87     runner->QueueRequest(
  88         std::make_shared<CreateCacheRequest>(runner->default_uid_, runner));
  89   }
  90   runner->QueueRequest(std::move(req));
  91
  92   return G_SOURCE_CONTINUE;
  93 }
  94
  95 void Runner::OnChanged(const std::string& locale) {
  96   thread_pool_->SetLocale(locale);
  97 }
  98
  99 bool Runner::QueueRequest(std::shared_ptr<PkgRequest> req) {
 100   thread_pool_->PushQueue(std::move(req));
 101   return true;
 102 }
 103
 104 void Runner::OnCreateCacheDone(bool success) {
 105   static bool ready = false;
 106   if (success && !ready) {
 107     ready = true;
 108     LOG(WARNING) << "pkginfo-server is ready";
 109     g_idle_add(
 110         [](gpointer data) -> gboolean {
 111           int fd = creat("/run/.pkginfo_server_ready",
 112                          S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 113           if (fd != -1)
 114             close(fd);
 115
 116           return G_SOURCE_REMOVE;
 117         },
 118         nullptr);
 119   }
 120 }
 121
 122 void Runner::SetCPUInheritance() {
 123   int ret;
 124   resource_pid_t resource_st = { 0, };
 125   resource_st.pid = getpid();
 126
 127   ret = resource_register_cpu_inheritance_destination(
 128       DEST_PROCESS_NAME, resource_st);
 129   if (ret != 0)
 130     LOG(ERROR) << "Fail to register cpu inheritance destination ret : " << ret;
 131 }
 132
 133 }  // namespace pkgmgr_server