1 /*
2 * Copyright (C) 2022 The Android Open Source Project
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 "host/commands/cvd/selector/instance_database.h"
18
19 #include <algorithm>
20 #include <regex>
21 #include <sstream>
22
23 #include <android-base/file.h>
24 #include <android-base/parseint.h>
25
26 #include "common/libs/utils/contains.h"
27 #include "common/libs/utils/files.h"
28 #include "host/commands/cvd/common_utils.h"
29 #include "host/commands/cvd/selector/instance_database_utils.h"
30 #include "host/commands/cvd/selector/selector_constants.h"
31
32 namespace cuttlefish {
33 namespace selector {
34
35 std::vector<std::unique_ptr<LocalInstanceGroup>>::iterator
FindIterator(const LocalInstanceGroup & group)36 InstanceDatabase::FindIterator(const LocalInstanceGroup& group) {
37 for (auto itr = local_instance_groups_.begin();
38 itr != local_instance_groups_.end(); itr++) {
39 if (itr->get() == std::addressof(group)) {
40 return itr;
41 }
42 }
43 // must not reach here
44 return local_instance_groups_.end();
45 }
46
Clear()47 void InstanceDatabase::Clear() { local_instance_groups_.clear(); }
48
AddInstanceGroup(const AddInstanceGroupParam & param)49 Result<ConstRef<LocalInstanceGroup>> InstanceDatabase::AddInstanceGroup(
50 const AddInstanceGroupParam& param) {
51 CF_EXPECT(IsValidGroupName(param.group_name),
52 "GroupName " << param.group_name << " is ill-formed.");
53 CF_EXPECT(EnsureDirectoryExistsAllTheWay(param.home_dir),
54 "HOME dir, " << param.home_dir << " does not exist");
55 CF_EXPECT(PotentiallyHostArtifactsPath(param.host_artifacts_path),
56 "ANDROID_HOST_OUT, " << param.host_artifacts_path
57 << " is not a tool dir");
58 std::vector<Query> queries = {{kHomeField, param.home_dir},
59 {kGroupNameField, param.group_name}};
60 for (const auto& query : queries) {
61 auto instance_groups =
62 CF_EXPECT(Find<LocalInstanceGroup>(query, group_handlers_));
63 std::stringstream err_msg;
64 err_msg << query.field_name_ << " : " << query.field_value_
65 << " is already taken.";
66 CF_EXPECT(instance_groups.empty(), err_msg.str());
67 }
68 auto new_group =
69 new LocalInstanceGroup({.group_name = param.group_name,
70 .home_dir = param.home_dir,
71 .host_artifacts_path = param.host_artifacts_path,
72 .product_out_path = param.product_out_path});
73 CF_EXPECT(new_group != nullptr);
74 local_instance_groups_.emplace_back(new_group);
75 const auto raw_ptr = local_instance_groups_.back().get();
76 ConstRef<LocalInstanceGroup> const_ref = *raw_ptr;
77 return {const_ref};
78 }
79
AddInstance(const std::string & group_name,const unsigned id,const std::string & instance_name)80 Result<void> InstanceDatabase::AddInstance(const std::string& group_name,
81 const unsigned id,
82 const std::string& instance_name) {
83 LocalInstanceGroup* group_ptr = CF_EXPECT(FindMutableGroup(group_name));
84 LocalInstanceGroup& group = *group_ptr;
85
86 CF_EXPECT(IsValidInstanceName(instance_name),
87 "instance_name " << instance_name << " is invalid.");
88 auto itr = FindIterator(group);
89 CF_EXPECT(
90 itr != local_instance_groups_.end() && *itr != nullptr,
91 "Adding instances to non-existing group " + group.InternalGroupName());
92
93 auto instances =
94 CF_EXPECT(FindInstances({kInstanceIdField, std::to_string(id)}));
95 if (instances.size() != 0) {
96 return CF_ERR("instance id " << id << " is taken");
97 }
98
99 auto instances_by_name = CF_EXPECT((*itr)->FindByInstanceName(instance_name));
100 if (!instances_by_name.empty()) {
101 return CF_ERR("instance name " << instance_name << " is taken");
102 }
103 return (*itr)->AddInstance(id, instance_name);
104 }
105
AddInstances(const std::string & group_name,const std::vector<InstanceInfo> & instances)106 Result<void> InstanceDatabase::AddInstances(
107 const std::string& group_name, const std::vector<InstanceInfo>& instances) {
108 for (const auto& instance_info : instances) {
109 CF_EXPECT(AddInstance(group_name, instance_info.id, instance_info.name));
110 }
111 return {};
112 }
113
SetBuildId(const std::string & group_name,const std::string & build_id)114 Result<void> InstanceDatabase::SetBuildId(const std::string& group_name,
115 const std::string& build_id) {
116 auto* group_ptr = CF_EXPECT(FindMutableGroup(group_name));
117 auto& group = *group_ptr;
118 group.SetBuildId(build_id);
119 return {};
120 }
121
FindMutableGroup(const std::string & group_name)122 Result<LocalInstanceGroup*> InstanceDatabase::FindMutableGroup(
123 const std::string& group_name) {
124 LocalInstanceGroup* group_ptr = nullptr;
125 for (auto& group_uniq_ptr : local_instance_groups_) {
126 if (group_uniq_ptr && group_uniq_ptr->GroupName() == group_name) {
127 group_ptr = group_uniq_ptr.get();
128 break;
129 }
130 }
131 CF_EXPECT(group_ptr != nullptr,
132 "Instance Group named as " << group_name << " is not found.");
133 return group_ptr;
134 }
135
RemoveInstanceGroup(const std::string & group_name)136 bool InstanceDatabase::RemoveInstanceGroup(const std::string& group_name) {
137 auto group_result = FindGroup({kGroupNameField, group_name});
138 if (!group_result.ok()) {
139 return false;
140 }
141 const LocalInstanceGroup& group = group_result->Get();
142 return RemoveInstanceGroup(group);
143 }
144
RemoveInstanceGroup(const LocalInstanceGroup & group)145 bool InstanceDatabase::RemoveInstanceGroup(const LocalInstanceGroup& group) {
146 auto itr = FindIterator(group);
147 // *itr is the reference to the unique pointer object
148 if (itr == local_instance_groups_.end() || !(*itr)) {
149 return false;
150 }
151 local_instance_groups_.erase(itr);
152 return true;
153 }
154
FindGroupsByHome(const std::string & home) const155 Result<Set<ConstRef<LocalInstanceGroup>>> InstanceDatabase::FindGroupsByHome(
156 const std::string& home) const {
157 auto subset = CollectToSet<LocalInstanceGroup>(
158 local_instance_groups_,
159 [&home](const std::unique_ptr<LocalInstanceGroup>& group) {
160 if (!group) {
161 return false;
162 }
163 if (group->HomeDir() == home) {
164 return true;
165 }
166 if (group->HomeDir().empty() || home.empty()) {
167 return false;
168 }
169 // The two paths must be an absolute path.
170 // this is guaranteed by the CreationAnalyzer
171 std::string home_realpath;
172 std::string group_home_realpath;
173 if (!android::base::Realpath(home, std::addressof(home_realpath))) {
174 return false;
175 }
176 if (!android::base::Realpath(group->HomeDir(),
177 std::addressof(group_home_realpath))) {
178 return false;
179 }
180 return home_realpath == group_home_realpath;
181 });
182 return AtMostOne(subset, GenerateTooManyInstancesErrorMsg(1, kHomeField));
183 }
184
185 Result<Set<ConstRef<LocalInstanceGroup>>>
FindGroupsByGroupName(const std::string & group_name) const186 InstanceDatabase::FindGroupsByGroupName(const std::string& group_name) const {
187 auto subset = CollectToSet<LocalInstanceGroup>(
188 local_instance_groups_,
189 [&group_name](const std::unique_ptr<LocalInstanceGroup>& group) {
190 return (group && group->GroupName() == group_name);
191 });
192 return AtMostOne(subset,
193 GenerateTooManyInstancesErrorMsg(1, kGroupNameField));
194 }
195
196 Result<Set<ConstRef<LocalInstanceGroup>>>
FindGroupsByInstanceName(const std::string & instance_name) const197 InstanceDatabase::FindGroupsByInstanceName(
198 const std::string& instance_name) const {
199 auto subset = CollectToSet<LocalInstanceGroup>(
200 local_instance_groups_,
201 [&instance_name](const std::unique_ptr<LocalInstanceGroup>& group) {
202 if (!group) {
203 return false;
204 }
205 auto instance_set_result = group->FindByInstanceName(instance_name);
206 return instance_set_result.ok() && (instance_set_result->size() == 1);
207 });
208 return subset;
209 }
210
FindInstancesById(const std::string & id) const211 Result<Set<ConstRef<LocalInstance>>> InstanceDatabase::FindInstancesById(
212 const std::string& id) const {
213 int parsed_int = 0;
214 if (!android::base::ParseInt(id, &parsed_int)) {
215 return CF_ERR(id << " cannot be converted to an integer");
216 }
217 auto collector =
218 [parsed_int](const std::unique_ptr<LocalInstanceGroup>& group)
219 -> Result<Set<ConstRef<LocalInstance>>> {
220 CF_EXPECT(group != nullptr);
221 return group->FindById(parsed_int);
222 };
223 auto subset = CollectAllElements<LocalInstance, LocalInstanceGroup>(
224 collector, local_instance_groups_);
225 CF_EXPECT(subset.ok());
226 return AtMostOne(*subset,
227 GenerateTooManyInstancesErrorMsg(1, kInstanceIdField));
228 }
229
230 Result<Set<ConstRef<LocalInstance>>>
FindInstancesByInstanceName(const Value & instance_specific_name) const231 InstanceDatabase::FindInstancesByInstanceName(
232 const Value& instance_specific_name) const {
233 auto collector = [&instance_specific_name](
234 const std::unique_ptr<LocalInstanceGroup>& group)
235 -> Result<Set<ConstRef<LocalInstance>>> {
236 CF_EXPECT(group != nullptr);
237 return (group->FindByInstanceName(instance_specific_name));
238 };
239 return CollectAllElements<LocalInstance, LocalInstanceGroup>(
240 collector, local_instance_groups_);
241 }
242
FindInstancesByGroupName(const Value & group_name) const243 Result<Set<ConstRef<LocalInstance>>> InstanceDatabase::FindInstancesByGroupName(
244 const Value& group_name) const {
245 auto collector =
246 [&group_name](const std::unique_ptr<LocalInstanceGroup>& group)
247 -> Result<Set<ConstRef<LocalInstance>>> {
248 CF_EXPECT(group != nullptr);
249 if (group->GroupName() != group_name) {
250 Set<ConstRef<LocalInstance>> empty_set;
251 return empty_set;
252 }
253 return (group->FindAllInstances());
254 };
255 return CollectAllElements<LocalInstance, LocalInstanceGroup>(
256 collector, local_instance_groups_);
257 }
258
Serialize() const259 Json::Value InstanceDatabase::Serialize() const {
260 Json::Value instance_db_json;
261 int i = 0;
262 Json::Value group_array;
263 for (const auto& local_instance_group : local_instance_groups_) {
264 group_array[i] = local_instance_group->Serialize();
265 ++i;
266 }
267 instance_db_json[kJsonGroups] = group_array;
268 return instance_db_json;
269 }
270
LoadGroupFromJson(const Json::Value & group_json)271 Result<void> InstanceDatabase::LoadGroupFromJson(
272 const Json::Value& group_json) {
273 const std::string group_name =
274 group_json[LocalInstanceGroup::kJsonGroupName].asString();
275 const std::string home_dir =
276 group_json[LocalInstanceGroup::kJsonHomeDir].asString();
277 const std::string host_artifacts_path =
278 group_json[LocalInstanceGroup::kJsonHostArtifactPath].asString();
279 const std::string product_out_path =
280 group_json[LocalInstanceGroup::kJsonProductOutPath].asString();
281 const std::string build_id_value =
282 group_json[LocalInstanceGroup::kJsonBuildId].asString();
283 std::optional<std::string> build_id;
284 if (build_id_value != LocalInstanceGroup::kJsonUnknownBuildId) {
285 build_id = build_id_value;
286 }
287 const auto new_group_ref =
288 CF_EXPECT(AddInstanceGroup({.group_name = group_name,
289 .home_dir = home_dir,
290 .host_artifacts_path = host_artifacts_path,
291 .product_out_path = product_out_path}));
292 if (build_id) {
293 CF_EXPECT(SetBuildId(group_name, *build_id));
294 }
295 const Json::Value& instances_json_array =
296 group_json[LocalInstanceGroup::kJsonInstances];
297 for (int i = 0; i < instances_json_array.size(); i++) {
298 const Json::Value& instance_json = instances_json_array[i];
299 const std::string instance_name =
300 instance_json[LocalInstance::kJsonInstanceName].asString();
301 const std::string instance_id =
302 instance_json[LocalInstance::kJsonInstanceId].asString();
303 int id;
304 auto parse_result =
305 android::base::ParseInt(instance_id, std::addressof(id));
306 if (!parse_result) {
307 CF_EXPECT(parse_result == true,
308 "Invalid instance ID in instance json: " << instance_id);
309 RemoveInstanceGroup(new_group_ref.Get());
310 }
311 auto add_instance_result = AddInstance(group_name, id, instance_name);
312 if (!add_instance_result.ok()) {
313 RemoveInstanceGroup(new_group_ref.Get());
314 CF_EXPECT(add_instance_result.ok(), add_instance_result.error().Trace());
315 }
316 }
317 return {};
318 }
319
LoadFromJson(const Json::Value & db_json)320 Result<void> InstanceDatabase::LoadFromJson(const Json::Value& db_json) {
321 const Json::Value& group_array = db_json[kJsonGroups];
322 int n_groups = group_array.size();
323 for (int i = 0; i < n_groups; i++) {
324 CF_EXPECT(LoadGroupFromJson(group_array[i]));
325 }
326 return {};
327 }
328
329 } // namespace selector
330 } // namespace cuttlefish
331