Line data Source code
1 : /*
2 : * If not stated otherwise in this file or this component's LICENSE file the
3 : * following copyright and licenses apply:
4 : *
5 : * Copyright 2022 Sky UK
6 : *
7 : * Licensed under the Apache License, Version 2.0 (the "License");
8 : * you may not use this file except in compliance with the License.
9 : * You may obtain a copy of the License at
10 : *
11 : * http://www.apache.org/licenses/LICENSE-2.0
12 : *
13 : * Unless required by applicable law or agreed to in writing, software
14 : * distributed under the License is distributed on an "AS IS" BASIS,
15 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 : * See the License for the specific language governing permissions and
17 : * limitations under the License.
18 : */
19 :
20 : #include "SessionServerAppManager.h"
21 : #include "RialtoServerManagerLogging.h"
22 : #include "Utils.h"
23 : #include <algorithm>
24 : #include <future>
25 : #include <utility>
26 :
27 : namespace
28 : {
29 : const std::unique_ptr<rialto::servermanager::common::ISessionServerApp> kInvalidSessionServer;
30 : } // namespace
31 :
32 : namespace rialto::servermanager::common
33 : {
34 32 : SessionServerAppManager::SessionServerAppManager(
35 : std::unique_ptr<ipc::IController> &ipcController, const std::shared_ptr<service::IStateObserver> &stateObserver,
36 : std::unique_ptr<ISessionServerAppFactory> &&sessionServerAppFactory,
37 : std::unique_ptr<IHealthcheckServiceFactory> &&healthcheckServiceFactory,
38 : const std::shared_ptr<firebolt::rialto::common::IEventThreadFactory> &eventThreadFactory,
39 32 : const firebolt::rialto::ipc::INamedSocketFactory &namedSocketFactory)
40 32 : : m_ipcController{ipcController},
41 64 : m_eventThread{eventThreadFactory->createEventThread("rialtoservermanager-appmanager")},
42 32 : m_sessionServerAppFactory{std::move(sessionServerAppFactory)}, m_stateObserver{stateObserver},
43 32 : m_healthcheckService{healthcheckServiceFactory->createHealthcheckService(*this)},
44 64 : m_namedSocketFactory{namedSocketFactory}
45 : {
46 32 : }
47 :
48 64 : SessionServerAppManager::~SessionServerAppManager()
49 : {
50 32 : m_eventThread->add(&SessionServerAppManager::shutdownAllSessionServers, this);
51 32 : m_eventThread->flush();
52 32 : m_eventThread.reset();
53 64 : }
54 :
55 7 : void SessionServerAppManager::preloadSessionServers(unsigned numOfPreloadedServers)
56 : {
57 7 : m_eventThread->add(
58 7 : [this, numOfPreloadedServers]()
59 : {
60 14 : for (unsigned i = 0; i < numOfPreloadedServers; ++i)
61 : {
62 7 : connectSessionServer(preloadSessionServer());
63 : }
64 7 : });
65 : }
66 :
67 28 : bool SessionServerAppManager::initiateApplication(const std::string &appName,
68 : const firebolt::rialto::common::SessionServerState &state,
69 : const firebolt::rialto::common::AppConfig &appConfig)
70 : {
71 28 : std::promise<bool> p;
72 28 : std::future<bool> f{p.get_future()};
73 56 : m_eventThread->add([&]() { return p.set_value(handleInitiateApplication(appName, state, appConfig)); });
74 56 : return f.get();
75 28 : }
76 :
77 28 : bool SessionServerAppManager::handleInitiateApplication(const std::string &appName,
78 : const firebolt::rialto::common::SessionServerState &state,
79 : const firebolt::rialto::common::AppConfig &appConfig)
80 : {
81 28 : RIALTO_SERVER_MANAGER_LOG_INFO("RialtoServerManager requests to launch %s with initial state: %s", appName.c_str(),
82 : toString(state));
83 28 : if (state != firebolt::rialto::common::SessionServerState::NOT_RUNNING && !getServerByAppName(appName))
84 : {
85 26 : const auto &preloadedServer{getPreloadedServer()};
86 26 : if (preloadedServer)
87 : {
88 4 : return configurePreloadedSessionServer(preloadedServer, appName, state, appConfig);
89 : }
90 22 : return connectSessionServer(launchSessionServer(appName, state, appConfig));
91 : }
92 2 : else if (state == firebolt::rialto::common::SessionServerState::NOT_RUNNING)
93 : {
94 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Initialization of %s failed - wrong state", appName.c_str());
95 : }
96 : else
97 : {
98 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Initialization of %s failed. App is already launched", appName.c_str());
99 : }
100 2 : return false;
101 : }
102 :
103 4 : bool SessionServerAppManager::setSessionServerState(const std::string &appName,
104 : const firebolt::rialto::common::SessionServerState &newState)
105 : {
106 4 : std::promise<bool> p;
107 4 : std::future<bool> f{p.get_future()};
108 8 : m_eventThread->add([&]() { return p.set_value(changeSessionServerState(appName, newState)); });
109 8 : return f.get();
110 4 : }
111 :
112 15 : void SessionServerAppManager::onSessionServerStateChanged(int serverId,
113 : const firebolt::rialto::common::SessionServerState &newState)
114 : {
115 15 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Queue state change of serverId: %d to %s", serverId, toString(newState));
116 : // Event loop needed here, as function caller may be deleted as a result of this call
117 15 : m_eventThread->add(&SessionServerAppManager::handleSessionServerStateChange, this, serverId, newState);
118 : }
119 :
120 2 : void SessionServerAppManager::sendPingEvents(int pingId)
121 : {
122 2 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Queue ping procedure with id: %d", pingId);
123 2 : m_eventThread->add(
124 2 : [this, pingId]()
125 : {
126 4 : for (const auto &sessionServer : m_sessionServerApps)
127 : {
128 2 : auto serverId{sessionServer->getServerId()};
129 2 : if (!m_ipcController->performPing(serverId, pingId))
130 : {
131 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Ping with id: %d failed for server: %d", pingId, serverId);
132 1 : m_healthcheckService->onPingFailed(serverId, pingId);
133 1 : continue;
134 : }
135 1 : m_healthcheckService->onPingSent(serverId, pingId);
136 : }
137 2 : });
138 : }
139 :
140 2 : void SessionServerAppManager::onAck(int serverId, int pingId, bool success)
141 : {
142 2 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Queue ack handling for serverId: %d ping id: %d", serverId, pingId);
143 2 : m_eventThread->add(&SessionServerAppManager::handleAck, this, serverId, pingId, success);
144 : }
145 :
146 7 : std::string SessionServerAppManager::getAppConnectionInfo(const std::string &appName) const
147 : {
148 7 : std::promise<std::string> p;
149 7 : std::future<std::string> f{p.get_future()};
150 7 : m_eventThread->add(
151 7 : [&]()
152 : {
153 7 : const auto &kSessionServer{getServerByAppName(appName)};
154 7 : if (kSessionServer)
155 : {
156 1 : return p.set_value(kSessionServer->getSessionManagementSocketName());
157 : }
158 6 : RIALTO_SERVER_MANAGER_LOG_ERROR("App: %s could not be found", appName.c_str());
159 18 : return p.set_value("");
160 : });
161 14 : return f.get();
162 7 : }
163 :
164 2 : bool SessionServerAppManager::setLogLevels(const service::LoggingLevels &logLevels) const
165 : {
166 2 : std::promise<bool> p;
167 2 : std::future<bool> f{p.get_future()};
168 2 : m_eventThread->add(
169 2 : [&]()
170 : {
171 2 : setLocalLogLevels(logLevels);
172 2 : if (!m_ipcController->setLogLevels(logLevels))
173 : {
174 1 : RIALTO_SERVER_MANAGER_LOG_WARN("Change log levels failed.");
175 1 : return p.set_value(false);
176 : }
177 1 : RIALTO_SERVER_MANAGER_LOG_INFO("Change log levels succeeded.");
178 1 : return p.set_value(true);
179 : });
180 4 : return f.get();
181 2 : }
182 :
183 2 : void SessionServerAppManager::restartServer(int serverId)
184 : {
185 2 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Queue restart server handling for serverId: %d", serverId);
186 2 : m_eventThread->add(&SessionServerAppManager::handleRestartServer, this, serverId);
187 : }
188 :
189 2 : void SessionServerAppManager::handleRestartServer(int serverId)
190 : {
191 2 : const auto &kSessionServer{getServerById(serverId)};
192 2 : if (!kSessionServer)
193 : {
194 0 : RIALTO_SERVER_MANAGER_LOG_WARN("Unable to restart server, serverId: %d", serverId);
195 1 : return;
196 : }
197 : // First, get all needed information from current app
198 2 : const std::string kAppName{kSessionServer->getAppName()};
199 2 : const firebolt::rialto::common::SessionServerState kState{kSessionServer->getExpectedState()};
200 2 : const firebolt::rialto::common::AppConfig kAppConfig{kSessionServer->getSessionManagementSocketName(),
201 2 : kSessionServer->getClientDisplayName()};
202 2 : std::unique_ptr<firebolt::rialto::ipc::INamedSocket> namedSocket{std::move(kSessionServer->releaseNamedSocket())};
203 2 : if (firebolt::rialto::common::SessionServerState::INACTIVE != kState &&
204 1 : firebolt::rialto::common::SessionServerState::ACTIVE != kState)
205 : {
206 1 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Restart server to %s not needed for serverId: %d", toString(kState), serverId);
207 1 : return;
208 : }
209 1 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Restarting server with id: %d", serverId);
210 : // Then kill the app
211 1 : kSessionServer->kill();
212 1 : handleSessionServerStateChange(serverId, firebolt::rialto::common::SessionServerState::NOT_RUNNING);
213 :
214 : // Finally, spawn the new app with old settings and set named socket if present
215 1 : auto app = m_sessionServerAppFactory->create(kAppName, kState, kAppConfig, *this, std::move(namedSocket));
216 1 : if (app->launch())
217 : {
218 1 : auto result = m_sessionServerApps.emplace(std::move(app));
219 1 : if (result.second)
220 : {
221 1 : connectSessionServer(*result.first);
222 : }
223 : }
224 : else
225 : {
226 0 : RIALTO_SERVER_MANAGER_LOG_ERROR("Failed to restart server");
227 : }
228 4 : }
229 :
230 35 : bool SessionServerAppManager::connectSessionServer(const std::unique_ptr<ISessionServerApp> &kSessionServer)
231 : {
232 35 : if (!kSessionServer)
233 : {
234 7 : RIALTO_SERVER_MANAGER_LOG_ERROR("Unable to connect Session Server - pointer is null!");
235 7 : return false;
236 : }
237 28 : if (!m_ipcController->createClient(kSessionServer->getServerId(), kSessionServer->getAppManagementSocketName()))
238 : {
239 2 : RIALTO_SERVER_MANAGER_LOG_ERROR("Failed to establish RialtoServerManager - RialtoSessionServer connection for "
240 : "session server with id: %d",
241 : kSessionServer->getServerId());
242 2 : kSessionServer->kill();
243 2 : m_healthcheckService->onServerRemoved(kSessionServer->getServerId());
244 2 : m_sessionServerApps.erase(kSessionServer);
245 2 : return false;
246 : }
247 26 : RIALTO_SERVER_MANAGER_LOG_INFO("RialtoServerManager with id %d successfully connected",
248 : kSessionServer->getServerId());
249 26 : return true;
250 : }
251 :
252 8 : bool SessionServerAppManager::configureSessionServer(const std::unique_ptr<ISessionServerApp> &kSessionServer)
253 : {
254 8 : if (!kSessionServer)
255 : {
256 0 : RIALTO_SERVER_MANAGER_LOG_ERROR("Unable to configure Session Server - pointer is null!");
257 0 : return false;
258 : }
259 8 : if (kSessionServer->isNamedSocketInitialized())
260 : {
261 2 : return configureSessionServerWithSocketFd(kSessionServer);
262 : }
263 6 : return configureSessionServerWithSocketName(kSessionServer);
264 : }
265 :
266 4 : bool SessionServerAppManager::configurePreloadedSessionServer(const std::unique_ptr<ISessionServerApp> &kSessionServer,
267 : const std::string &appName,
268 : const firebolt::rialto::common::SessionServerState &state,
269 : const firebolt::rialto::common::AppConfig &appConfig)
270 : {
271 4 : RIALTO_SERVER_MANAGER_LOG_INFO("Configuration of preloaded session server with id: %d for %s app",
272 : kSessionServer->getServerId(), appName.c_str());
273 4 : if (kSessionServer->configure(appName, state, appConfig) && configureSessionServer(kSessionServer))
274 : {
275 : // Schedule adding new preloaded session server (as we've just used one) and return immediately
276 4 : m_eventThread->add([this]() { connectSessionServer(preloadSessionServer()); });
277 2 : return true;
278 : }
279 : // Configuration failed, kill server and return error
280 2 : handleSessionServerStateChange(kSessionServer->getServerId(), firebolt::rialto::common::SessionServerState::ERROR);
281 2 : kSessionServer->kill();
282 2 : handleSessionServerStateChange(kSessionServer->getServerId(),
283 : firebolt::rialto::common::SessionServerState::NOT_RUNNING);
284 : // Schedule adding new preloaded session server
285 4 : m_eventThread->add([this]() { connectSessionServer(preloadSessionServer()); });
286 2 : return false;
287 : }
288 :
289 4 : bool SessionServerAppManager::changeSessionServerState(const std::string &appName,
290 : const firebolt::rialto::common::SessionServerState &newState)
291 : {
292 4 : RIALTO_SERVER_MANAGER_LOG_INFO("RialtoServerManager requests to change state of %s to %s", appName.c_str(),
293 : toString(newState));
294 4 : const auto &kSessionServer{getServerByAppName(appName)};
295 4 : if (!kSessionServer)
296 : {
297 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Change state of %s to %s failed - session server not found.", appName.c_str(),
298 : toString(newState));
299 1 : return false;
300 : }
301 3 : kSessionServer->setExpectedState(newState);
302 3 : if (!m_ipcController->performSetState(kSessionServer->getServerId(), newState))
303 : {
304 2 : RIALTO_SERVER_MANAGER_LOG_ERROR("Change state of %s to %s failed.", appName.c_str(), toString(newState));
305 2 : handleStateChangeFailure(kSessionServer, newState);
306 2 : return false;
307 : }
308 1 : RIALTO_SERVER_MANAGER_LOG_INFO("Change state of %s to %s succeeded.", appName.c_str(), toString(newState));
309 1 : return true;
310 : }
311 :
312 26 : void SessionServerAppManager::handleSessionServerStateChange(int serverId,
313 : firebolt::rialto::common::SessionServerState newState)
314 : {
315 26 : RIALTO_SERVER_MANAGER_LOG_INFO("SessionServer with id: %d changed state to %s", serverId, toString(newState));
316 26 : const auto &kSessionServer{getServerById(serverId)};
317 26 : if (!kSessionServer)
318 : {
319 0 : RIALTO_SERVER_MANAGER_LOG_WARN("SessionServer with id: %d not found", serverId);
320 0 : return;
321 : }
322 26 : std::string appName{kSessionServer->getAppName()};
323 26 : if (!appName.empty() && m_stateObserver) // empty app name is when SessionServer is preloaded
324 : {
325 17 : m_stateObserver->stateChanged(appName, newState);
326 : }
327 26 : if (firebolt::rialto::common::SessionServerState::UNINITIALIZED == newState)
328 : {
329 10 : kSessionServer->cancelStartupTimer();
330 10 : if (!kSessionServer->isPreloaded() && !configureSessionServer(kSessionServer))
331 : {
332 2 : handleSessionServerStateChange(serverId, firebolt::rialto::common::SessionServerState::ERROR);
333 2 : kSessionServer->kill();
334 2 : handleSessionServerStateChange(serverId, firebolt::rialto::common::SessionServerState::NOT_RUNNING);
335 : }
336 : }
337 16 : else if (newState == firebolt::rialto::common::SessionServerState::ERROR && kSessionServer->isPreloaded())
338 : {
339 1 : m_ipcController->removeClient(serverId);
340 1 : kSessionServer->kill();
341 1 : m_healthcheckService->onServerRemoved(kSessionServer->getServerId());
342 1 : m_sessionServerApps.erase(kSessionServer);
343 1 : connectSessionServer(preloadSessionServer());
344 : }
345 15 : else if (newState == firebolt::rialto::common::SessionServerState::NOT_RUNNING)
346 : {
347 7 : m_ipcController->removeClient(serverId);
348 7 : m_healthcheckService->onServerRemoved(kSessionServer->getServerId());
349 7 : m_sessionServerApps.erase(kSessionServer);
350 : }
351 26 : }
352 :
353 2 : void SessionServerAppManager::handleAck(int serverId, int pingId, bool success)
354 : {
355 2 : if (success)
356 : {
357 1 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Ping with id: %d succeeded for server: %d", pingId, serverId);
358 : }
359 : else
360 : {
361 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Ping with id: %d failed for server: %d", pingId, serverId);
362 : }
363 2 : m_healthcheckService->onAckReceived(serverId, pingId, success);
364 : }
365 :
366 32 : void SessionServerAppManager::shutdownAllSessionServers()
367 : {
368 50 : for (const auto &kSessionServer : m_sessionServerApps)
369 : {
370 18 : kSessionServer->kill();
371 : }
372 32 : m_sessionServerApps.clear();
373 : }
374 :
375 : const std::unique_ptr<ISessionServerApp> &
376 22 : SessionServerAppManager::launchSessionServer(const std::string &appName,
377 : const firebolt::rialto::common::SessionServerState &kInitialState,
378 : const firebolt::rialto::common::AppConfig &appConfig)
379 : {
380 22 : RIALTO_SERVER_MANAGER_LOG_INFO("Launching Rialto Session Server for %s", appName.c_str());
381 22 : auto app = m_sessionServerAppFactory->create(appName, kInitialState, appConfig, *this,
382 22 : m_namedSocketFactory.createNamedSocket());
383 22 : if (app->launch())
384 : {
385 21 : auto result = m_sessionServerApps.emplace(std::move(app));
386 21 : if (result.second)
387 : {
388 21 : return *result.first;
389 : }
390 : }
391 1 : return kInvalidSessionServer;
392 22 : }
393 :
394 12 : const std::unique_ptr<ISessionServerApp> &SessionServerAppManager::preloadSessionServer()
395 : {
396 12 : RIALTO_SERVER_MANAGER_LOG_INFO("Preloading new Rialto Session Server");
397 12 : auto app = m_sessionServerAppFactory->create(*this, m_namedSocketFactory.createNamedSocket());
398 12 : if (app->launch())
399 : {
400 6 : auto result = m_sessionServerApps.emplace(std::move(app));
401 6 : if (result.second)
402 : {
403 6 : return *result.first;
404 : }
405 : }
406 6 : return kInvalidSessionServer;
407 12 : }
408 :
409 26 : const std::unique_ptr<ISessionServerApp> &SessionServerAppManager::getPreloadedServer() const
410 : {
411 26 : auto iter = std::find_if(m_sessionServerApps.begin(), m_sessionServerApps.end(),
412 4 : [](const auto &srv) { return srv->isPreloaded() && srv->isConnected(); });
413 26 : if (m_sessionServerApps.end() != iter)
414 : {
415 4 : return *iter;
416 : }
417 22 : return kInvalidSessionServer;
418 : }
419 :
420 38 : const std::unique_ptr<ISessionServerApp> &SessionServerAppManager::getServerByAppName(const std::string &appName) const
421 : {
422 38 : auto iter{std::find_if(m_sessionServerApps.begin(), m_sessionServerApps.end(),
423 9 : [&](const auto &srv) { return srv->getAppName() == appName; })};
424 38 : if (m_sessionServerApps.end() != iter)
425 : {
426 5 : return *iter;
427 : }
428 33 : return kInvalidSessionServer;
429 : }
430 :
431 28 : const std::unique_ptr<ISessionServerApp> &SessionServerAppManager::getServerById(int serverId) const
432 : {
433 28 : auto iter{std::find_if(m_sessionServerApps.begin(), m_sessionServerApps.end(),
434 28 : [&](const auto &srv) { return srv->getServerId() == serverId; })};
435 28 : if (m_sessionServerApps.end() != iter)
436 : {
437 28 : return *iter;
438 : }
439 0 : return kInvalidSessionServer;
440 : }
441 :
442 2 : void SessionServerAppManager::handleStateChangeFailure(const std::unique_ptr<ISessionServerApp> &kSessionServer,
443 : const firebolt::rialto::common::SessionServerState &state)
444 : {
445 2 : if (state == firebolt::rialto::common::SessionServerState::NOT_RUNNING)
446 : {
447 1 : RIALTO_SERVER_MANAGER_LOG_WARN("Force change of %s to NotRunning.", kSessionServer->getAppName().c_str());
448 1 : kSessionServer->kill();
449 1 : handleSessionServerStateChange(kSessionServer->getServerId(), state);
450 : }
451 : else
452 : {
453 1 : handleSessionServerStateChange(kSessionServer->getServerId(),
454 : firebolt::rialto::common::SessionServerState::ERROR);
455 : }
456 2 : }
457 :
458 6 : bool SessionServerAppManager::configureSessionServerWithSocketName(const std::unique_ptr<ISessionServerApp> &kSessionServer)
459 : {
460 6 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Configuring Session Server using socket name");
461 6 : const auto kInitialState{kSessionServer->getInitialState()};
462 6 : const auto kSocketName{kSessionServer->getSessionManagementSocketName()};
463 6 : const auto kClientDisplayName{kSessionServer->getClientDisplayName()};
464 6 : const auto kSocketPermissions{kSessionServer->getSessionManagementSocketPermissions()};
465 6 : const auto kSocketOwner{kSessionServer->getSessionManagementSocketOwner()};
466 6 : const auto kSocketGroup{kSessionServer->getSessionManagementSocketGroup()};
467 6 : const auto kAppName{kSessionServer->getAppName()};
468 :
469 6 : const firebolt::rialto::common::MaxResourceCapabilitites kMaxResource{kSessionServer->getMaxPlaybackSessions(),
470 6 : kSessionServer->getMaxWebAudioPlayers()};
471 6 : if (!m_ipcController->performSetConfiguration(kSessionServer->getServerId(), kInitialState, kSocketName,
472 : kClientDisplayName, kMaxResource, kSocketPermissions, kSocketOwner,
473 : kSocketGroup, kAppName))
474 : {
475 2 : RIALTO_SERVER_MANAGER_LOG_ERROR("Configuration of server with id %d failed - ipc error.",
476 : kSessionServer->getServerId());
477 2 : return false;
478 : }
479 4 : RIALTO_SERVER_MANAGER_LOG_INFO("Configuration of server with id %d succeeded.", kSessionServer->getServerId());
480 4 : return true;
481 6 : }
482 :
483 2 : bool SessionServerAppManager::configureSessionServerWithSocketFd(const std::unique_ptr<ISessionServerApp> &kSessionServer)
484 : {
485 2 : RIALTO_SERVER_MANAGER_LOG_DEBUG("Configuring Session Server using socket fd");
486 2 : const auto kInitialState{kSessionServer->getInitialState()};
487 2 : const auto kSocketFd{kSessionServer->getSessionManagementSocketFd()};
488 2 : const auto kClientDisplayName{kSessionServer->getClientDisplayName()};
489 2 : const auto kAppName{kSessionServer->getAppName()};
490 :
491 2 : const firebolt::rialto::common::MaxResourceCapabilitites kMaxResource{kSessionServer->getMaxPlaybackSessions(),
492 2 : kSessionServer->getMaxWebAudioPlayers()};
493 2 : if (!m_ipcController->performSetConfiguration(kSessionServer->getServerId(), kInitialState, kSocketFd,
494 : kClientDisplayName, kMaxResource, kAppName))
495 : {
496 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Configuration of server with id %d failed - ipc error.",
497 : kSessionServer->getServerId());
498 1 : return false;
499 : }
500 1 : RIALTO_SERVER_MANAGER_LOG_INFO("Configuration of server with id %d succeeded.", kSessionServer->getServerId());
501 1 : return true;
502 2 : }
503 : } // namespace rialto::servermanager::common
|
