1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "resource_node_pool.h" 17 18 #include <mutex> 19 #include <set> 20 #include <unordered_map> 21 22 #include <singleton.h> 23 24 #include "iam_logger.h" 25 26 #define LOG_LABEL UserIam::Common::LABEL_USER_AUTH_SA 27 28 namespace OHOS { 29 namespace UserIam { 30 namespace UserAuth { 31 class ResourceNodePoolImpl final : public ResourceNodePool, public Singleton<ResourceNodePoolImpl> { 32 public: 33 bool Insert(const std::shared_ptr<ResourceNode> &resource) override; 34 bool Delete(uint64_t executorIndex) override; 35 void DeleteAll() override; 36 std::weak_ptr<ResourceNode> Select(uint64_t executorIndex) const override; 37 uint32_t GetPoolSize() const override; 38 void Enumerate(std::function<void(const std::weak_ptr<ResourceNode> &)> action) const override; 39 bool RegisterResourceNodePoolListener(const std::shared_ptr<ResourceNodePoolListener> &listener) override; 40 bool DeregisterResourceNodePoolListener(const std::shared_ptr<ResourceNodePoolListener> &listener) override; 41 42 private: 43 mutable std::mutex poolMutex_; 44 std::unordered_map<uint64_t, std::shared_ptr<ResourceNode>> resourceNodeMap_; 45 std::set<std::shared_ptr<ResourceNodePoolListener>> listenerSet_; 46 }; 47 Insert(const std::shared_ptr<ResourceNode> & resource)48bool ResourceNodePoolImpl::Insert(const std::shared_ptr<ResourceNode> &resource) 49 { 50 if (resource == nullptr) { 51 IAM_LOGE("resource is nullptr"); 52 return false; 53 } 54 std::lock_guard<std::mutex> lock(poolMutex_); 55 uint64_t executorIndex = resource->GetExecutorIndex(); 56 57 auto iter = resourceNodeMap_.find(executorIndex); 58 if (iter != resourceNodeMap_.end() && iter->second != nullptr) { 59 iter->second->Detach(); 60 } 61 62 auto result = resourceNodeMap_.insert_or_assign(executorIndex, resource); 63 if (result.second) { 64 for (const auto &listener : listenerSet_) { 65 if (listener != nullptr) { 66 listener->OnResourceNodePoolInsert(resource); 67 } 68 } 69 } else { 70 for (const auto &listener : listenerSet_) { 71 if (listener != nullptr) { 72 listener->OnResourceNodePoolUpdate(resource); 73 } 74 } 75 } 76 return true; 77 } 78 Delete(uint64_t executorIndex)79bool ResourceNodePoolImpl::Delete(uint64_t executorIndex) 80 { 81 std::lock_guard<std::mutex> lock(poolMutex_); 82 auto iter = resourceNodeMap_.find(executorIndex); 83 if (iter == resourceNodeMap_.end()) { 84 IAM_LOGE("executor not found"); 85 return false; 86 } 87 auto tempResource = iter->second; 88 resourceNodeMap_.erase(iter); 89 for (const auto &listener : listenerSet_) { 90 if (listener != nullptr) { 91 listener->OnResourceNodePoolDelete(tempResource); 92 } 93 } 94 return true; 95 } 96 DeleteAll()97void ResourceNodePoolImpl::DeleteAll() 98 { 99 std::lock_guard<std::mutex> lock(poolMutex_); 100 auto tempMap = resourceNodeMap_; 101 resourceNodeMap_.clear(); 102 for (auto &node : tempMap) { 103 for (const auto &listener : listenerSet_) { 104 if (listener != nullptr) { 105 listener->OnResourceNodePoolDelete(node.second); 106 } 107 } 108 } 109 } 110 Select(uint64_t executorIndex) const111std::weak_ptr<ResourceNode> ResourceNodePoolImpl::Select(uint64_t executorIndex) const 112 { 113 std::lock_guard<std::mutex> lock(poolMutex_); 114 std::weak_ptr<ResourceNode> result; 115 auto iter = resourceNodeMap_.find(executorIndex); 116 if (iter != resourceNodeMap_.end()) { 117 result = iter->second; 118 } 119 return result; 120 } 121 Enumerate(std::function<void (const std::weak_ptr<ResourceNode> &)> action) const122void ResourceNodePoolImpl::Enumerate(std::function<void(const std::weak_ptr<ResourceNode> &)> action) const 123 { 124 if (action == nullptr) { 125 IAM_LOGE("action is nullptr"); 126 return; 127 } 128 std::lock_guard<std::mutex> lock(poolMutex_); 129 for (auto &node : resourceNodeMap_) { 130 action(node.second); 131 } 132 } 133 GetPoolSize() const134uint32_t ResourceNodePoolImpl::GetPoolSize() const 135 { 136 std::lock_guard<std::mutex> lock(poolMutex_); 137 return resourceNodeMap_.size(); 138 } 139 RegisterResourceNodePoolListener(const std::shared_ptr<ResourceNodePoolListener> & listener)140bool ResourceNodePoolImpl::RegisterResourceNodePoolListener(const std::shared_ptr<ResourceNodePoolListener> &listener) 141 { 142 if (listener == nullptr) { 143 IAM_LOGE("listener is nullptr"); 144 return false; 145 } 146 std::lock_guard<std::mutex> lock(poolMutex_); 147 listenerSet_.insert(listener); 148 return true; 149 } 150 DeregisterResourceNodePoolListener(const std::shared_ptr<ResourceNodePoolListener> & listener)151bool ResourceNodePoolImpl::DeregisterResourceNodePoolListener(const std::shared_ptr<ResourceNodePoolListener> &listener) 152 { 153 std::lock_guard<std::mutex> lock(poolMutex_); 154 return listenerSet_.erase(listener) == 1; 155 } 156 Instance()157ResourceNodePool &ResourceNodePool::Instance() 158 { 159 return ResourceNodePoolImpl::GetInstance(); 160 } 161 } // namespace UserAuth 162 } // namespace UserIam 163 } // namespace OHOS 164