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 "SessionServerManager.h"
21 : #include "IApplicationManagementServer.h"
22 : #include "IIpcFactory.h"
23 : #include "ISessionManagementServer.h"
24 : #include "RialtoServerLogging.h"
25 :
26 : #include <algorithm>
27 : #include <stdexcept>
28 : #include <utility>
29 :
30 : namespace
31 : {
32 5 : inline bool isNumber(const std::string &text)
33 : {
34 10 : return std::find_if(text.begin(), text.end(), [](const auto &letter) { return !std::isdigit(letter); }) == text.end();
35 : }
36 : } // namespace
37 :
38 : namespace firebolt::rialto::server::service
39 : {
40 28 : SessionServerManager::SessionServerManager(const ipc::IIpcFactory &ipcFactory, IPlaybackService &playbackService,
41 : ICdmService &cdmService, IControlService &controlService,
42 28 : std::unique_ptr<IHeartbeatProcedureFactory> &&heartbeatProcedureFactory)
43 28 : : m_playbackService{playbackService}, m_cdmService{cdmService}, m_controlService{controlService},
44 28 : m_heartbeatProcedureFactory{std::move(heartbeatProcedureFactory)},
45 28 : m_applicationManagementServer{ipcFactory.createApplicationManagementServer(*this)},
46 28 : m_sessionManagementServer{ipcFactory.createSessionManagementServer(playbackService, cdmService, controlService)},
47 56 : m_isServiceRunning{true}, m_currentState{common::SessionServerState::UNINITIALIZED}
48 : {
49 28 : RIALTO_SERVER_LOG_INFO("Starting Rialto Server Service");
50 : }
51 :
52 56 : SessionServerManager::~SessionServerManager()
53 : {
54 28 : RIALTO_SERVER_LOG_INFO("Stopping Rialto Server Service");
55 :
56 : // The following reset() will ensure that the thread ApplicationManagementServer::m_ipcServerThread
57 : // isn't currently calling any methods within this class (while it is being destructed)
58 : // Particularly, the mentioned thread is responsible for calling the method
59 : // SessionServerManager::switchToNotRunning() which then triggers a call to this destuctor
60 : // after it calls stopService()
61 28 : m_applicationManagementServer.reset();
62 :
63 28 : stopService();
64 56 : }
65 :
66 7 : bool SessionServerManager::initialize(int argc, char *argv[])
67 : try
68 : {
69 7 : if (argc != 2)
70 : {
71 2 : RIALTO_SERVER_LOG_ERROR("Wrong number of arguments. Rialto Server Service will close now.");
72 2 : return false;
73 : }
74 10 : std::string socketStr{argv[1]};
75 5 : if (!isNumber(socketStr))
76 : {
77 1 : RIALTO_SERVER_LOG_ERROR("Rialto App Management socket is not a number.");
78 1 : return false;
79 : }
80 4 : if (!m_applicationManagementServer->initialize(std::stoi(socketStr)))
81 : {
82 1 : RIALTO_SERVER_LOG_ERROR("Initialization of Application Management server failed.");
83 1 : return false;
84 : }
85 2 : m_applicationManagementServer->start();
86 2 : return m_applicationManagementServer->sendStateChangedEvent(common::SessionServerState::UNINITIALIZED);
87 5 : }
88 1 : catch (const std::exception &e)
89 : {
90 1 : RIALTO_SERVER_LOG_ERROR("Exception caught during service initialization: %s", e.what());
91 1 : return false;
92 : }
93 :
94 1 : void SessionServerManager::startService()
95 : {
96 1 : std::unique_lock<std::mutex> lock{m_serviceMutex};
97 3 : m_serviceCv.wait(lock, [this]() { return !m_isServiceRunning; });
98 1 : }
99 :
100 32 : void SessionServerManager::stopService()
101 : {
102 32 : std::unique_lock<std::mutex> lock{m_serviceMutex};
103 32 : if (m_isServiceRunning)
104 : {
105 28 : m_isServiceRunning = false;
106 28 : m_serviceCv.notify_one();
107 : }
108 32 : }
109 :
110 3 : bool SessionServerManager::configureIpc(const std::string &socketName, unsigned int socketPermissions,
111 : const std::string &socketOwner, const std::string &socketGroup)
112 : {
113 3 : if (!m_sessionManagementServer->initialize(socketName, socketPermissions, socketOwner, socketGroup))
114 : {
115 1 : RIALTO_SERVER_LOG_ERROR("configureIpc failed - SessionManagementServer failed to initialize");
116 1 : return false;
117 : }
118 2 : return true;
119 : }
120 :
121 2 : bool SessionServerManager::configureIpc(int32_t socketFd)
122 : {
123 2 : if (!m_sessionManagementServer->initialize(socketFd))
124 : {
125 1 : RIALTO_SERVER_LOG_ERROR("configureIpc failed - SessionManagementServer failed to initialize");
126 1 : return false;
127 : }
128 1 : return true;
129 : }
130 :
131 3 : bool SessionServerManager::configureServices(const common::SessionServerState &state,
132 : const common::MaxResourceCapabilitites &maxResource,
133 : const std::string &clientDisplayName, const std::string &appName)
134 : {
135 3 : m_sessionManagementServer->start();
136 3 : m_playbackService.setMaxPlaybacks(maxResource.maxPlaybacks);
137 3 : m_playbackService.setMaxWebAudioPlayers(maxResource.maxWebAudioPlayers);
138 3 : m_playbackService.setClientDisplayName(clientDisplayName);
139 3 : m_playbackService.setResourceManagerAppName(appName);
140 3 : return setState(state);
141 : }
142 :
143 22 : bool SessionServerManager::setState(const common::SessionServerState &state)
144 : {
145 22 : switch (state)
146 : {
147 7 : case common::SessionServerState::ACTIVE:
148 : {
149 7 : return switchToActive();
150 : }
151 8 : case common::SessionServerState::INACTIVE:
152 : {
153 8 : return switchToInactive();
154 : }
155 5 : case common::SessionServerState::NOT_RUNNING:
156 : {
157 5 : return switchToNotRunning();
158 : }
159 2 : default:
160 : {
161 2 : RIALTO_SERVER_LOG_ERROR("SetState failed - unsupported state");
162 2 : m_applicationManagementServer->sendStateChangedEvent(common::SessionServerState::ERROR);
163 : }
164 : }
165 2 : return false;
166 : }
167 :
168 1 : void SessionServerManager::setLogLevels(RIALTO_DEBUG_LEVEL defaultLogLevels, RIALTO_DEBUG_LEVEL clientLogLevels,
169 : RIALTO_DEBUG_LEVEL sessionServerLogLevels, RIALTO_DEBUG_LEVEL ipcLogLevels,
170 : RIALTO_DEBUG_LEVEL serverManagerLogLevels, RIALTO_DEBUG_LEVEL commonLogLevels)
171 : {
172 1 : firebolt::rialto::logging::setLogLevels(RIALTO_COMPONENT_DEFAULT, defaultLogLevels);
173 1 : firebolt::rialto::logging::setLogLevels(RIALTO_COMPONENT_CLIENT, clientLogLevels);
174 1 : firebolt::rialto::logging::setLogLevels(RIALTO_COMPONENT_SERVER, sessionServerLogLevels);
175 1 : firebolt::rialto::logging::setLogLevels(RIALTO_COMPONENT_IPC, ipcLogLevels);
176 1 : firebolt::rialto::logging::setLogLevels(RIALTO_COMPONENT_SERVER_MANAGER, serverManagerLogLevels);
177 1 : firebolt::rialto::logging::setLogLevels(RIALTO_COMPONENT_COMMON, commonLogLevels);
178 1 : m_sessionManagementServer->setLogLevels(defaultLogLevels, clientLogLevels, ipcLogLevels, commonLogLevels);
179 : }
180 :
181 2 : bool SessionServerManager::ping(std::int32_t id, const std::shared_ptr<IAckSender> &ackSender)
182 : {
183 2 : auto heartbeatProcedure{m_heartbeatProcedureFactory->createHeartbeatProcedure(ackSender, id)};
184 :
185 : // Check all rialto server internal threads
186 2 : m_cdmService.ping(heartbeatProcedure);
187 2 : m_playbackService.ping(heartbeatProcedure);
188 :
189 : // Check all Rialto Clients
190 4 : return m_controlService.ping(heartbeatProcedure);
191 2 : }
192 :
193 7 : bool SessionServerManager::switchToActive()
194 : {
195 7 : if (m_currentState.load() == common::SessionServerState::ACTIVE)
196 : {
197 1 : RIALTO_SERVER_LOG_DEBUG("Session server already in Active state.");
198 1 : return true;
199 : }
200 6 : if (!m_playbackService.switchToActive())
201 : {
202 1 : RIALTO_SERVER_LOG_ERROR("Player service failed to switch to active state");
203 1 : return false;
204 : }
205 5 : if (!m_cdmService.switchToActive())
206 : {
207 1 : RIALTO_SERVER_LOG_ERROR("Cdm service failed to switch to active state");
208 1 : m_playbackService.switchToInactive();
209 1 : return false;
210 : }
211 4 : if (m_applicationManagementServer->sendStateChangedEvent(common::SessionServerState::ACTIVE))
212 : {
213 3 : m_controlService.setApplicationState(ApplicationState::RUNNING);
214 3 : m_currentState.store(common::SessionServerState::ACTIVE);
215 3 : return true;
216 : }
217 1 : m_playbackService.switchToInactive();
218 1 : m_cdmService.switchToInactive();
219 1 : return false;
220 : }
221 :
222 8 : bool SessionServerManager::switchToInactive()
223 : {
224 8 : if (m_currentState.load() == common::SessionServerState::INACTIVE)
225 : {
226 1 : RIALTO_SERVER_LOG_DEBUG("Session server already in Inactive state.");
227 1 : return true;
228 : }
229 7 : m_playbackService.switchToInactive();
230 7 : m_cdmService.switchToInactive();
231 7 : if (m_applicationManagementServer->sendStateChangedEvent(common::SessionServerState::INACTIVE))
232 : {
233 4 : m_controlService.setApplicationState(ApplicationState::INACTIVE);
234 4 : m_currentState.store(common::SessionServerState::INACTIVE);
235 4 : return true;
236 : }
237 3 : if (m_currentState.load() == common::SessionServerState::ACTIVE)
238 : {
239 1 : if (!m_playbackService.switchToActive())
240 : {
241 1 : RIALTO_SERVER_LOG_WARN("Player service failed to switch to active state");
242 : }
243 1 : if (!m_cdmService.switchToActive())
244 : {
245 1 : RIALTO_SERVER_LOG_WARN("Cdm service failed to switch to active state");
246 : }
247 : }
248 3 : return false;
249 : }
250 :
251 5 : bool SessionServerManager::switchToNotRunning()
252 : {
253 5 : if (m_currentState.load() == common::SessionServerState::NOT_RUNNING)
254 : {
255 1 : RIALTO_SERVER_LOG_DEBUG("Session server already in NotRunning state.");
256 1 : return true;
257 : }
258 : // Free resources before sending notification to ServerManager
259 4 : m_playbackService.switchToInactive();
260 4 : m_cdmService.switchToInactive();
261 4 : m_controlService.setApplicationState(ApplicationState::UNKNOWN);
262 :
263 4 : bool result{true};
264 4 : if (m_applicationManagementServer->sendStateChangedEvent(common::SessionServerState::NOT_RUNNING))
265 : {
266 3 : m_currentState.store(common::SessionServerState::NOT_RUNNING);
267 : }
268 : else
269 : {
270 1 : result = false;
271 : }
272 :
273 : // stopService() needs to be the last command of this method.
274 : // It triggers destruction of SessionServerManager and therefore
275 : // some member variables may not be valid after this command
276 4 : stopService(); // This HAS TO BE LAST (see above)
277 4 : return result;
278 : }
279 : } // namespace firebolt::rialto::server::service
|
