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 <numeric> // std::iota
20
21 #include "host/commands/cvd/selector/instance_database_utils.h"
22 #include "host/commands/cvd/selector/selector_constants.h"
23
24 namespace cuttlefish {
25 namespace selector {
26
InstanceDatabase()27 InstanceDatabase::InstanceDatabase() {
28 group_handlers_[kHomeField] = [this](const Value& field_value) {
29 return FindGroupsByHome(field_value);
30 };
31 group_handlers_[kGroupNameField] = [this](const Value& field_value) {
32 return FindGroupsByGroupName(field_value);
33 };
34 group_handlers_[kInstanceNameField] = [this](const Value& field_value) {
35 return FindGroupsByInstanceName(field_value);
36 };
37 instance_handlers_[kInstanceIdField] = [this](const Value& field_value) {
38 return FindInstancesById(field_value);
39 };
40 instance_handlers_[kGroupNameField] = [this](const Value& field_value) {
41 return FindInstancesByGroupName(field_value);
42 };
43 instance_handlers_[kInstanceNameField] = [this](const Value& field_value) {
44 return FindInstancesByInstanceName(field_value);
45 };
46 }
47
IsEmpty() const48 bool InstanceDatabase::IsEmpty() const {
49 return local_instance_groups_.empty();
50 }
51
52 template <typename T>
Find(const Query & query,const Map<FieldName,ConstHandler<T>> & handler_map) const53 Result<Set<ConstRef<T>>> InstanceDatabase::Find(
54 const Query& query,
55 const Map<FieldName, ConstHandler<T>>& handler_map) const {
56 static_assert(std::is_same<T, LocalInstance>::value ||
57 std::is_same<T, LocalInstanceGroup>::value);
58 const auto& [key, value] = query;
59 auto itr = handler_map.find(key);
60 if (itr == handler_map.end()) {
61 return CF_ERR("Handler does not exist for query " << key);
62 }
63 return (itr->second)(value);
64 }
65
66 template <typename T>
Find(const Queries & queries,const Map<FieldName,ConstHandler<T>> & handler_map) const67 Result<Set<ConstRef<T>>> InstanceDatabase::Find(
68 const Queries& queries,
69 const Map<FieldName, ConstHandler<T>>& handler_map) const {
70 static_assert(std::is_same<T, LocalInstance>::value ||
71 std::is_same<T, LocalInstanceGroup>::value);
72 if (queries.empty()) {
73 return CF_ERR("Queries must not be empty");
74 }
75 auto first_set = CF_EXPECT(Find<T>(queries[0], handler_map));
76 for (int i = 1; i < queries.size(); i++) {
77 auto subset = CF_EXPECT(Find<T>(queries[i], handler_map));
78 first_set = Intersection(first_set, subset);
79 }
80 return {first_set};
81 }
82
83 template <typename T>
FindOne(const Query & query,const Map<FieldName,ConstHandler<T>> & handler_map) const84 Result<ConstRef<T>> InstanceDatabase::FindOne(
85 const Query& query,
86 const Map<FieldName, ConstHandler<T>>& handler_map) const {
87 auto set = CF_EXPECT(Find<T>(query, handler_map));
88 CF_EXPECT_EQ(set.size(), 1, "Only one Instance (Group) is allowed.");
89 return {*set.cbegin()};
90 }
91
92 template <typename T>
FindOne(const Queries & queries,const Map<FieldName,ConstHandler<T>> & handler_map) const93 Result<ConstRef<T>> InstanceDatabase::FindOne(
94 const Queries& queries,
95 const Map<FieldName, ConstHandler<T>>& handler_map) const {
96 auto set = CF_EXPECT(Find<T>(queries, handler_map));
97 CF_EXPECT_EQ(set.size(), 1, "Only one Instance (Group) is allowed.");
98 return {*set.cbegin()};
99 }
100
FindGroups(const Query & query) const101 Result<Set<ConstRef<LocalInstanceGroup>>> InstanceDatabase::FindGroups(
102 const Query& query) const {
103 return Find<LocalInstanceGroup>(query, group_handlers_);
104 }
105
FindGroups(const Queries & queries) const106 Result<Set<ConstRef<LocalInstanceGroup>>> InstanceDatabase::FindGroups(
107 const Queries& queries) const {
108 return Find<LocalInstanceGroup>(queries, group_handlers_);
109 }
110
FindInstances(const Query & query) const111 Result<Set<ConstRef<LocalInstance>>> InstanceDatabase::FindInstances(
112 const Query& query) const {
113 return Find<LocalInstance>(query, instance_handlers_);
114 }
115
FindInstances(const Queries & queries) const116 Result<Set<ConstRef<LocalInstance>>> InstanceDatabase::FindInstances(
117 const Queries& queries) const {
118 return Find<LocalInstance>(queries, instance_handlers_);
119 }
120
FindGroup(const Query & query) const121 Result<ConstRef<LocalInstanceGroup>> InstanceDatabase::FindGroup(
122 const Query& query) const {
123 return FindOne<LocalInstanceGroup>(query, group_handlers_);
124 }
125
FindGroup(const Queries & queries) const126 Result<ConstRef<LocalInstanceGroup>> InstanceDatabase::FindGroup(
127 const Queries& queries) const {
128 return FindOne<LocalInstanceGroup>(queries, group_handlers_);
129 }
130
FindInstance(const Query & query) const131 Result<ConstRef<LocalInstance>> InstanceDatabase::FindInstance(
132 const Query& query) const {
133 return FindOne<LocalInstance>(query, instance_handlers_);
134 }
135
FindInstance(const Queries & queries) const136 Result<ConstRef<LocalInstance>> InstanceDatabase::FindInstance(
137 const Queries& queries) const {
138 return FindOne<LocalInstance>(queries, instance_handlers_);
139 }
140
141 } // namespace selector
142 } // namespace cuttlefish
143