1 //
2 // Copyright (c) ZeroC, Inc. All rights reserved.
3 //
4
5 #include <IceGrid/PluginFacadeI.h>
6 #include <IceGrid/PlatformInfo.h>
7 #include <IceGrid/NodeSessionI.h>
8 #include <IceGrid/Database.h>
9
10 using namespace std;
11 using namespace IceGrid;
12
13 namespace IceGrid
14 {
15
16 ICEGRID_API void setRegistryPluginFacade(const RegistryPluginFacadePtr&);
17
18 }
19
20 namespace
21 {
22
23 class Init
24 {
25 public:
26
Init()27 Init()
28 {
29 IceGrid::setRegistryPluginFacade(new RegistryPluginFacadeI);
30 }
31
32 /* This is a bad idea, see
33 * https://isocpp.org/wiki/faq/ctors#construct-on-first-use-v2
34 * That's why we disabled it and make sure the registrypluginfacace
35 * is reset somwhere else. Construction is still here, so that
36 * registry plugins work as expected.
37 * ~Init()
38 * {
39 * IceGrid::setRegistryPluginFacade(0);
40 * }
41 */
42 };
43
44 Init init;
45
46 bool
hasAdapter(const CommunicatorDescriptorPtr & descriptor,const string & adapterId)47 hasAdapter(const CommunicatorDescriptorPtr& descriptor, const string& adapterId)
48 {
49 for(AdapterDescriptorSeq::const_iterator p = descriptor->adapters.begin(); p != descriptor->adapters.end(); ++p)
50 {
51 if(p->id == adapterId)
52 {
53 return true;
54 }
55 }
56 return false;
57 }
58
59 }
60
RegistryPluginFacadeI()61 RegistryPluginFacadeI::RegistryPluginFacadeI()
62 {
63 }
64
65 ApplicationInfo
getApplicationInfo(const string & name) const66 RegistryPluginFacadeI::getApplicationInfo(const string& name) const
67 {
68 Lock sync(*this);
69 if(!_database)
70 {
71 throw RegistryUnreachableException("", "registry not initialized yet");
72 }
73 return _database->getApplicationInfo(name);
74 }
75
76 ServerInfo
getServerInfo(const string & serverId) const77 RegistryPluginFacadeI::getServerInfo(const string& serverId) const
78 {
79 Lock sync(*this);
80 if(!_database)
81 {
82 throw RegistryUnreachableException("", "registry not initialized yet");
83 }
84 return _database->getServer(serverId)->getInfo(true);
85 }
86
87 AdapterInfoSeq
getAdapterInfo(const string & adapterId) const88 RegistryPluginFacadeI::getAdapterInfo(const string& adapterId) const
89 {
90 Lock sync(*this);
91 if(!_database)
92 {
93 throw RegistryUnreachableException("", "registry not initialized yet");
94 }
95 return _database->getAdapterInfo(adapterId);
96 }
97
98 string
getAdapterServer(const string & adapterId) const99 RegistryPluginFacadeI::getAdapterServer(const string& adapterId) const
100 {
101 Lock sync(*this);
102 if(!_database)
103 {
104 throw RegistryUnreachableException("", "registry not initialized yet");
105 }
106 return _database->getAdapterServer(adapterId);
107 }
108
109 string
getAdapterNode(const string & adapterId) const110 RegistryPluginFacadeI::getAdapterNode(const string& adapterId) const
111 {
112 Lock sync(*this);
113 if(!_database)
114 {
115 throw RegistryUnreachableException("", "registry not initialized yet");
116 }
117 return _database->getAdapterNode(adapterId);
118 }
119
120 string
getAdapterApplication(const string & adapterId) const121 RegistryPluginFacadeI::getAdapterApplication(const string& adapterId) const
122 {
123 Lock sync(*this);
124 if(!_database)
125 {
126 throw RegistryUnreachableException("", "registry not initialized yet");
127 }
128 return _database->getAdapterApplication(adapterId);
129 }
130
131 ObjectInfo
getObjectInfo(const Ice::Identity & id) const132 RegistryPluginFacadeI::getObjectInfo(const Ice::Identity& id) const
133 {
134 Lock sync(*this);
135 if(!_database)
136 {
137 throw RegistryUnreachableException("", "registry not initialized yet");
138 }
139 return _database->getObjectInfo(id);
140 }
141
142 NodeInfo
getNodeInfo(const string & name) const143 RegistryPluginFacadeI::getNodeInfo(const string& name) const
144 {
145 Lock sync(*this);
146 if(!_database)
147 {
148 throw RegistryUnreachableException("", "registry not initialized yet");
149 }
150 return toNodeInfo(_database->getNode(name)->getInfo());
151 }
152
153 LoadInfo
getNodeLoad(const string & name) const154 RegistryPluginFacadeI::getNodeLoad(const string& name) const
155 {
156 Lock sync(*this);
157 if(!_database)
158 {
159 throw RegistryUnreachableException("", "registry not initialized yet");
160 }
161 return _database->getNode(name)->getSession()->getLoadInfo();
162 }
163
164 std::string
getPropertyForAdapter(const std::string & adapterId,const std::string & name) const165 RegistryPluginFacadeI::getPropertyForAdapter(const std::string& adapterId, const std::string& name) const
166 {
167 try
168 {
169 ServerInfo info = _database->getServer(_database->getAdapterServer(adapterId))->getInfo(true);
170 if(hasAdapter(info.descriptor, adapterId))
171 {
172 return IceGrid::getProperty(info.descriptor->propertySet.properties, name);
173 }
174
175 IceBoxDescriptorPtr iceBox = IceBoxDescriptorPtr::dynamicCast(info.descriptor);
176 if(!iceBox)
177 {
178 return "";
179 }
180
181 for(ServiceInstanceDescriptorSeq::const_iterator p = iceBox->services.begin(); p != iceBox->services.end(); ++p)
182 {
183 if(hasAdapter(p->descriptor, adapterId))
184 {
185 return IceGrid::getProperty(p->descriptor->propertySet.properties, name);
186 }
187 }
188 }
189 catch(const ServerNotExistException&)
190 {
191 }
192 catch(const AdapterNotExistException&)
193 {
194 }
195 return "";
196 }
197
198 void
addReplicaGroupFilter(const string & id,const ReplicaGroupFilterPtr & filter)199 RegistryPluginFacadeI::addReplicaGroupFilter(const string& id, const ReplicaGroupFilterPtr& filter) ICE_NOEXCEPT
200 {
201 Lock sync(*this);
202 map<string, vector<ReplicaGroupFilterPtr> >::iterator p = _replicaGroupFilters.find(id);
203 if(p == _replicaGroupFilters.end())
204 {
205 p = _replicaGroupFilters.insert(make_pair(id, vector<ReplicaGroupFilterPtr>())).first;
206 }
207 p->second.push_back(filter);
208 }
209
210 bool
removeReplicaGroupFilter(const string & id,const ReplicaGroupFilterPtr & filter)211 RegistryPluginFacadeI::removeReplicaGroupFilter(const string& id, const ReplicaGroupFilterPtr& filter) ICE_NOEXCEPT
212 {
213 Lock sync(*this);
214
215 map<string, vector<ReplicaGroupFilterPtr> >::iterator p = _replicaGroupFilters.find(id);
216 if(p == _replicaGroupFilters.end())
217 {
218 return false;
219 }
220
221 vector<ReplicaGroupFilterPtr>::iterator q = find(p->second.begin(), p->second.end(), filter);
222 if(q == p->second.end())
223 {
224 return false;
225 }
226 p->second.erase(q);
227
228 if(p->second.empty())
229 {
230 _replicaGroupFilters.erase(p);
231 }
232 return true;
233 }
234
235 void
addTypeFilter(const string & id,const TypeFilterPtr & filter)236 RegistryPluginFacadeI::addTypeFilter(const string& id, const TypeFilterPtr& filter) ICE_NOEXCEPT
237 {
238 Lock sync(*this);
239 map<string, vector<TypeFilterPtr> >::iterator p = _typeFilters.find(id);
240 if(p == _typeFilters.end())
241 {
242 p = _typeFilters.insert(make_pair(id, vector<TypeFilterPtr>())).first;
243 }
244 p->second.push_back(filter);
245 }
246
247 bool
removeTypeFilter(const string & id,const TypeFilterPtr & filter)248 RegistryPluginFacadeI::removeTypeFilter(const string& id, const TypeFilterPtr& filter) ICE_NOEXCEPT
249 {
250 Lock sync(*this);
251
252 map<string, vector<TypeFilterPtr> >::iterator p = _typeFilters.find(id);
253 if(p == _typeFilters.end())
254 {
255 return false;
256 }
257
258 vector<TypeFilterPtr>::iterator q = find(p->second.begin(), p->second.end(), filter);
259 if(q == p->second.end())
260 {
261 return false;
262 }
263 p->second.erase(q);
264
265 if(p->second.empty())
266 {
267 _typeFilters.erase(p);
268 }
269 return true;
270 }
271
272 vector<ReplicaGroupFilterPtr>
getReplicaGroupFilters(const string & id) const273 RegistryPluginFacadeI::getReplicaGroupFilters(const string& id) const
274 {
275 Lock sync(*this);
276 map<string, vector<ReplicaGroupFilterPtr> >::const_iterator p = _replicaGroupFilters.find(id);
277 if(p != _replicaGroupFilters.end())
278 {
279 return p->second;
280 }
281 return vector<ReplicaGroupFilterPtr>();
282 }
283
284 bool
hasReplicaGroupFilters() const285 RegistryPluginFacadeI::hasReplicaGroupFilters() const
286 {
287 return !_replicaGroupFilters.empty();
288 }
289
290 vector<TypeFilterPtr>
getTypeFilters(const string & id) const291 RegistryPluginFacadeI::getTypeFilters(const string& id) const
292 {
293 Lock sync(*this);
294 map<string, vector<TypeFilterPtr> >::const_iterator p = _typeFilters.find(id);
295 if(p != _typeFilters.end())
296 {
297 return p->second;
298 }
299 return vector<TypeFilterPtr>();
300 }
301
302 bool
hasTypeFilters() const303 RegistryPluginFacadeI::hasTypeFilters() const
304 {
305 return !_typeFilters.empty();
306 }
307
308 void
setDatabase(const DatabasePtr & database)309 RegistryPluginFacadeI::setDatabase(const DatabasePtr& database)
310 {
311 Lock sync(*this);
312 _database = database;
313 }
314