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 "Client.h"
21 : #include "IIpcChannel.h"
22 : #include "ISessionServerAppManager.h"
23 : #include "IpcLoop.h"
24 : #include "RialtoServerManagerLogging.h"
25 : #include "Utils.h"
26 : #include "servermanagermodule.pb.h"
27 : #include <cstring>
28 : #include <sys/socket.h>
29 : #include <sys/wait.h>
30 : #include <unistd.h>
31 :
32 : namespace
33 : {
34 1 : firebolt::rialto::common::SessionServerState convert(const rialto::SessionServerState &sessionServerState)
35 : {
36 1 : switch (sessionServerState)
37 : {
38 0 : case rialto::SessionServerState::UNINITIALIZED:
39 : {
40 0 : return firebolt::rialto::common::SessionServerState::UNINITIALIZED;
41 : }
42 1 : case rialto::SessionServerState::INACTIVE:
43 : {
44 1 : return firebolt::rialto::common::SessionServerState::INACTIVE;
45 : }
46 0 : case rialto::SessionServerState::ACTIVE:
47 : {
48 0 : return firebolt::rialto::common::SessionServerState::ACTIVE;
49 : }
50 0 : case rialto::SessionServerState::NOT_RUNNING:
51 : {
52 0 : return firebolt::rialto::common::SessionServerState::NOT_RUNNING;
53 : }
54 0 : case rialto::SessionServerState::ERROR:
55 : {
56 0 : return firebolt::rialto::common::SessionServerState::ERROR;
57 : }
58 : }
59 0 : return firebolt::rialto::common::SessionServerState::ERROR;
60 : }
61 6 : rialto::SessionServerState convert(const firebolt::rialto::common::SessionServerState &state)
62 : {
63 6 : switch (state)
64 : {
65 0 : case firebolt::rialto::common::SessionServerState::UNINITIALIZED:
66 : {
67 0 : return rialto::SessionServerState::UNINITIALIZED;
68 : }
69 6 : case firebolt::rialto::common::SessionServerState::INACTIVE:
70 : {
71 6 : return rialto::SessionServerState::INACTIVE;
72 : }
73 0 : case firebolt::rialto::common::SessionServerState::ACTIVE:
74 : {
75 0 : return rialto::SessionServerState::ACTIVE;
76 : }
77 0 : case firebolt::rialto::common::SessionServerState::NOT_RUNNING:
78 : {
79 0 : return rialto::SessionServerState::NOT_RUNNING;
80 : }
81 0 : case firebolt::rialto::common::SessionServerState::ERROR:
82 : {
83 0 : return rialto::SessionServerState::ERROR;
84 : }
85 : }
86 0 : return rialto::SessionServerState::ERROR;
87 : }
88 2 : rialto::LogLevels convert(const rialto::servermanager::service::LoggingLevels &levels)
89 : {
90 2 : rialto::LogLevels logLevels;
91 2 : if (rialto::servermanager::service::LoggingLevel::UNCHANGED != levels.defaultLoggingLevel)
92 : {
93 0 : logLevels.set_defaultloglevels(rialto::servermanager::common::convert(levels.defaultLoggingLevel));
94 : }
95 2 : if (rialto::servermanager::service::LoggingLevel::UNCHANGED != levels.clientLoggingLevel)
96 : {
97 0 : logLevels.set_clientloglevels(rialto::servermanager::common::convert(levels.clientLoggingLevel));
98 : }
99 2 : if (rialto::servermanager::service::LoggingLevel::UNCHANGED != levels.sessionServerLoggingLevel)
100 : {
101 0 : logLevels.set_sessionserverloglevels(rialto::servermanager::common::convert(levels.sessionServerLoggingLevel));
102 : }
103 2 : if (rialto::servermanager::service::LoggingLevel::UNCHANGED != levels.ipcLoggingLevel)
104 : {
105 0 : logLevels.set_ipcloglevels(rialto::servermanager::common::convert(levels.ipcLoggingLevel));
106 : }
107 2 : if (rialto::servermanager::service::LoggingLevel::UNCHANGED != levels.serverManagerLoggingLevel)
108 : {
109 0 : logLevels.set_servermanagerloglevels(rialto::servermanager::common::convert(levels.serverManagerLoggingLevel));
110 : }
111 2 : if (rialto::servermanager::service::LoggingLevel::UNCHANGED != levels.commonLoggingLevel)
112 : {
113 0 : logLevels.set_commonloglevels(rialto::servermanager::common::convert(levels.commonLoggingLevel));
114 : }
115 2 : return logLevels;
116 : }
117 4 : rialto::LogLevels getCurrentLogLevels()
118 : {
119 4 : rialto::LogLevels logLevels;
120 4 : logLevels.set_defaultloglevels(firebolt::rialto::logging::getLogLevels(RIALTO_COMPONENT_DEFAULT));
121 4 : logLevels.set_clientloglevels(firebolt::rialto::logging::getLogLevels(RIALTO_COMPONENT_CLIENT));
122 4 : logLevels.set_sessionserverloglevels(firebolt::rialto::logging::getLogLevels(RIALTO_COMPONENT_SERVER));
123 4 : logLevels.set_ipcloglevels(firebolt::rialto::logging::getLogLevels(RIALTO_COMPONENT_IPC));
124 4 : logLevels.set_servermanagerloglevels(firebolt::rialto::logging::getLogLevels(RIALTO_COMPONENT_SERVER_MANAGER));
125 4 : logLevels.set_commonloglevels(firebolt::rialto::logging::getLogLevels(RIALTO_COMPONENT_COMMON));
126 4 : return logLevels;
127 : }
128 : } // namespace
129 :
130 : namespace rialto::servermanager::ipc
131 : {
132 17 : Client::Client(std::unique_ptr<common::ISessionServerAppManager> &sessionServerAppManager, int serverId, int socket)
133 17 : : m_serverId{serverId}, m_sessionServerAppManager{sessionServerAppManager}, m_socket{socket}
134 : {
135 17 : RIALTO_SERVER_MANAGER_LOG_INFO("Constructing client for serverId: %d", m_serverId);
136 : }
137 :
138 17 : Client::~Client()
139 : {
140 17 : RIALTO_SERVER_MANAGER_LOG_INFO("Client for serverId: %d is destructed", m_serverId);
141 17 : m_serviceStub.reset();
142 17 : m_ipcLoop.reset();
143 : }
144 :
145 17 : bool Client::connect()
146 : {
147 17 : m_ipcLoop = IpcLoop::create(m_socket, *this);
148 17 : if (!m_ipcLoop)
149 : {
150 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Failed to connect to rialto session server @ '%d'", m_socket);
151 1 : return false;
152 : }
153 16 : m_serviceStub = std::make_unique<::rialto::ServerManagerModule_Stub>(m_ipcLoop->channel());
154 32 : m_ipcLoop->channel()->subscribe<rialto::StateChangedEvent>(
155 16 : std::bind(&Client::onStateChangedEvent, this, std::placeholders::_1));
156 16 : m_ipcLoop->channel()->subscribe<rialto::AckEvent>(std::bind(&Client::onAckEvent, this, std::placeholders::_1));
157 16 : return true;
158 : }
159 :
160 2 : bool Client::performSetState(const firebolt::rialto::common::SessionServerState &state)
161 : {
162 2 : if (!m_ipcLoop || !m_serviceStub)
163 : {
164 0 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to set status - client is not active for serverId: %d", m_serverId);
165 0 : return false;
166 : }
167 2 : rialto::SetStateRequest request;
168 2 : rialto::SetStateResponse response;
169 2 : request.set_sessionserverstate(convert(state));
170 2 : auto ipcController = m_ipcLoop->createRpcController();
171 2 : auto blockingClosure = m_ipcLoop->createBlockingClosure();
172 2 : m_serviceStub->setState(ipcController.get(), &request, &response, blockingClosure.get());
173 : // wait for the call to complete
174 2 : blockingClosure->wait();
175 :
176 : // check the result
177 2 : if (ipcController->Failed())
178 : {
179 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to set status due to '%s'", ipcController->ErrorText().c_str());
180 1 : return false;
181 : }
182 1 : return true;
183 2 : }
184 :
185 2 : bool Client::performSetConfiguration(const firebolt::rialto::common::SessionServerState &initialState,
186 : const std::string &socketName, const std::string &clientDisplayName,
187 : const firebolt::rialto::common::MaxResourceCapabilitites &maxResource,
188 : const unsigned int socketPermissions, const std::string &socketOwner,
189 : const std::string &socketGroup, const std::string &appName) const
190 : {
191 2 : if (!m_ipcLoop || !m_serviceStub)
192 : {
193 0 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to set configuration - client is not active for serverId: %d",
194 : m_serverId);
195 0 : return false;
196 : }
197 2 : rialto::SetConfigurationRequest request;
198 2 : rialto::SetConfigurationResponse response;
199 : request.set_sessionmanagementsocketname(socketName);
200 : request.set_clientdisplayname(clientDisplayName);
201 2 : request.mutable_resources()->set_maxplaybacks(maxResource.maxPlaybacks);
202 2 : request.mutable_resources()->set_maxwebaudioplayers(maxResource.maxWebAudioPlayers);
203 2 : request.set_socketpermissions(socketPermissions);
204 : request.set_socketowner(socketOwner);
205 : request.set_socketgroup(socketGroup);
206 : request.set_appname(appName);
207 2 : *(request.mutable_loglevels()) = getCurrentLogLevels();
208 2 : request.set_initialsessionserverstate(convert(initialState));
209 2 : auto ipcController = m_ipcLoop->createRpcController();
210 2 : auto blockingClosure = m_ipcLoop->createBlockingClosure();
211 2 : m_serviceStub->setConfiguration(ipcController.get(), &request, &response, blockingClosure.get());
212 : // wait for the call to complete
213 2 : blockingClosure->wait();
214 :
215 : // check the result
216 2 : if (ipcController->Failed())
217 : {
218 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to set configuration due to '%s'", ipcController->ErrorText().c_str());
219 1 : return false;
220 : }
221 1 : return true;
222 2 : }
223 :
224 2 : bool Client::performSetConfiguration(const firebolt::rialto::common::SessionServerState &initialState, int socketFd,
225 : const std::string &clientDisplayName,
226 : const firebolt::rialto::common::MaxResourceCapabilitites &maxResource,
227 : const std::string &appName) const
228 : {
229 2 : if (!m_ipcLoop || !m_serviceStub)
230 : {
231 0 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to set configuration - client is not active for serverId: %d",
232 : m_serverId);
233 0 : return false;
234 : }
235 2 : rialto::SetConfigurationRequest request;
236 2 : rialto::SetConfigurationResponse response;
237 2 : request.set_sessionmanagementsocketfd(socketFd);
238 : request.set_clientdisplayname(clientDisplayName);
239 2 : request.mutable_resources()->set_maxplaybacks(maxResource.maxPlaybacks);
240 2 : request.mutable_resources()->set_maxwebaudioplayers(maxResource.maxWebAudioPlayers);
241 : request.set_appname(appName);
242 2 : *(request.mutable_loglevels()) = getCurrentLogLevels();
243 2 : request.set_initialsessionserverstate(convert(initialState));
244 2 : auto ipcController = m_ipcLoop->createRpcController();
245 2 : auto blockingClosure = m_ipcLoop->createBlockingClosure();
246 2 : m_serviceStub->setConfiguration(ipcController.get(), &request, &response, blockingClosure.get());
247 : // wait for the call to complete
248 2 : blockingClosure->wait();
249 :
250 : // check the result
251 2 : if (ipcController->Failed())
252 : {
253 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to set configuration due to '%s'", ipcController->ErrorText().c_str());
254 1 : return false;
255 : }
256 1 : return true;
257 2 : }
258 :
259 2 : bool Client::performPing(int pingId) const
260 : {
261 2 : if (!m_ipcLoop || !m_serviceStub)
262 : {
263 0 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to ping - client is not active for serverId: %d", m_serverId);
264 0 : return false;
265 : }
266 2 : rialto::PingRequest request;
267 2 : rialto::PingResponse response;
268 2 : request.set_id(pingId);
269 2 : auto ipcController = m_ipcLoop->createRpcController();
270 2 : auto blockingClosure = m_ipcLoop->createBlockingClosure();
271 2 : m_serviceStub->ping(ipcController.get(), &request, &response, blockingClosure.get());
272 : // wait for the call to complete
273 2 : blockingClosure->wait();
274 :
275 : // check the result
276 2 : if (ipcController->Failed())
277 : {
278 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("failed to ping due to '%s'", ipcController->ErrorText().c_str());
279 1 : return false;
280 : }
281 1 : return true;
282 2 : }
283 :
284 2 : bool Client::setLogLevels(const service::LoggingLevels &logLevels) const
285 : {
286 2 : if (!m_ipcLoop || !m_serviceStub)
287 : {
288 0 : RIALTO_SERVER_MANAGER_LOG_WARN("failed to change log levels - client is not active for serverId: %d", m_serverId);
289 0 : return false;
290 : }
291 2 : rialto::SetLogLevelsRequest request;
292 2 : rialto::SetLogLevelsResponse response;
293 2 : *(request.mutable_loglevels()) = convert(logLevels);
294 2 : auto ipcController = m_ipcLoop->createRpcController();
295 2 : auto blockingClosure = m_ipcLoop->createBlockingClosure();
296 2 : m_serviceStub->setLogLevels(ipcController.get(), &request, &response, blockingClosure.get());
297 : // wait for the call to complete
298 2 : blockingClosure->wait();
299 :
300 : // check the result
301 2 : if (ipcController->Failed())
302 : {
303 1 : RIALTO_SERVER_MANAGER_LOG_WARN("failed to change log levels due to '%s'", ipcController->ErrorText().c_str());
304 1 : return false;
305 : }
306 1 : return true;
307 2 : }
308 :
309 1 : void Client::onDisconnected() const
310 : {
311 1 : RIALTO_SERVER_MANAGER_LOG_WARN("Connection to serverId: %d broken, server probably crashed. Starting recovery",
312 : m_serverId);
313 1 : m_sessionServerAppManager->restartServer(m_serverId);
314 : }
315 :
316 1 : void Client::onStateChangedEvent(const std::shared_ptr<rialto::StateChangedEvent> &event) const
317 : {
318 1 : RIALTO_SERVER_MANAGER_LOG_DEBUG("StateChangedEvent received for serverId: %d", m_serverId);
319 1 : if (!m_sessionServerAppManager || !event)
320 : {
321 0 : RIALTO_SERVER_MANAGER_LOG_WARN("Problem during StateChangedEvent processing");
322 0 : return;
323 : }
324 1 : m_sessionServerAppManager->onSessionServerStateChanged(m_serverId, convert(event->sessionserverstate()));
325 : }
326 :
327 1 : void Client::onAckEvent(const std::shared_ptr<rialto::AckEvent> &event) const
328 : {
329 1 : RIALTO_SERVER_MANAGER_LOG_DEBUG("AckEvent received for serverId: %d", m_serverId);
330 1 : if (!m_sessionServerAppManager || !event)
331 : {
332 0 : RIALTO_SERVER_MANAGER_LOG_WARN("Problem during AckEvent processing");
333 0 : return;
334 : }
335 1 : m_sessionServerAppManager->onAck(m_serverId, event->id(), event->success());
336 : }
337 : } // namespace rialto::servermanager::ipc
|
