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 "ServerManagerModuleService.h"
21 : #include "AckSender.h"
22 : #include "ISessionServerManager.h"
23 : #include "RialtoServerLogging.h"
24 : #include <IIpcController.h>
25 :
26 : namespace
27 : {
28 10 : firebolt::rialto::common::SessionServerState convertSessionServerState(const rialto::SessionServerState &state)
29 : {
30 10 : switch (state)
31 : {
32 1 : case rialto::SessionServerState::UNINITIALIZED:
33 1 : return firebolt::rialto::common::SessionServerState::UNINITIALIZED;
34 1 : case rialto::SessionServerState::INACTIVE:
35 1 : return firebolt::rialto::common::SessionServerState::INACTIVE;
36 6 : case rialto::SessionServerState::ACTIVE:
37 6 : return firebolt::rialto::common::SessionServerState::ACTIVE;
38 1 : case rialto::SessionServerState::NOT_RUNNING:
39 1 : return firebolt::rialto::common::SessionServerState::NOT_RUNNING;
40 1 : case rialto::SessionServerState::ERROR:
41 1 : return firebolt::rialto::common::SessionServerState::ERROR;
42 0 : case rialto::SessionServerState::SUSPENDED:
43 0 : return firebolt::rialto::common::SessionServerState::SUSPENDED;
44 : }
45 0 : return firebolt::rialto::common::SessionServerState::ERROR;
46 : }
47 : } // namespace
48 :
49 : namespace firebolt::rialto::server::ipc
50 : {
51 14 : std::shared_ptr<IServerManagerModuleServiceFactory> IServerManagerModuleServiceFactory::createFactory()
52 : {
53 14 : std::shared_ptr<IServerManagerModuleServiceFactory> factory;
54 :
55 : try
56 : {
57 14 : factory = std::make_shared<ServerManagerModuleServiceFactory>();
58 : }
59 0 : catch (const std::exception &e)
60 : {
61 0 : RIALTO_SERVER_LOG_ERROR("Failed to create the server maanger module service factory, reason: %s", e.what());
62 : }
63 :
64 14 : return factory;
65 : }
66 :
67 : std::shared_ptr<::rialto::ServerManagerModule>
68 14 : ServerManagerModuleServiceFactory::create(service::ISessionServerManager &sessionServerManager) const
69 : {
70 14 : std::shared_ptr<::rialto::ServerManagerModule> serverManagerModule;
71 : try
72 : {
73 14 : serverManagerModule = std::make_shared<ServerManagerModuleService>(sessionServerManager);
74 : }
75 0 : catch (const std::exception &e)
76 : {
77 0 : RIALTO_SERVER_LOG_ERROR("Failed to create the server manager module service, reason: %s", e.what());
78 : }
79 :
80 14 : return serverManagerModule;
81 : }
82 :
83 14 : ServerManagerModuleService::ServerManagerModuleService(service::ISessionServerManager &sessionServerManager)
84 14 : : m_sessionServerManager{sessionServerManager}
85 : {
86 : }
87 :
88 : ServerManagerModuleService::~ServerManagerModuleService() {}
89 :
90 4 : void ServerManagerModuleService::setConfiguration(::google::protobuf::RpcController *controller,
91 : const ::rialto::SetConfigurationRequest *request,
92 : ::rialto::SetConfigurationResponse *response,
93 : ::google::protobuf::Closure *done)
94 : {
95 4 : RIALTO_SERVER_LOG_DEBUG("SetConfiguration received from ServerManager");
96 4 : common::MaxResourceCapabilitites maxResource{request->resources().maxplaybacks(),
97 4 : request->resources().maxwebaudioplayers()};
98 4 : const auto kClientDisplayName = request->has_clientdisplayname() ? request->clientdisplayname() : "";
99 4 : bool success{true};
100 4 : if (request->has_sessionmanagementsocketfd())
101 : {
102 2 : m_sessionServerManager.configureIpc(request->sessionmanagementsocketfd());
103 : }
104 : else
105 : {
106 2 : m_sessionServerManager.configureIpc(request->sessionmanagementsocketname(), request->socketpermissions(),
107 : request->socketowner(), request->socketgroup());
108 : }
109 4 : success &= m_sessionServerManager.configureServices(convertSessionServerState(request->initialsessionserverstate()),
110 : maxResource, kClientDisplayName, request->appname());
111 4 : m_sessionServerManager.setLogLevels(static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().defaultloglevels()),
112 4 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().clientloglevels()),
113 4 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().sessionserverloglevels()),
114 4 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().ipcloglevels()),
115 4 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().servermanagerloglevels()),
116 4 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().commonloglevels()));
117 4 : if (!success)
118 : {
119 2 : RIALTO_SERVER_LOG_ERROR("SetConfiguration operation failed");
120 6 : controller->SetFailed("SetConfiguration failed");
121 : }
122 4 : done->Run();
123 : }
124 :
125 6 : void ServerManagerModuleService::setState(::google::protobuf::RpcController *controller,
126 : const ::rialto::SetStateRequest *request,
127 : ::rialto::SetStateResponse *response, ::google::protobuf::Closure *done)
128 : {
129 6 : RIALTO_SERVER_LOG_DEBUG("SetState received from ServerManager");
130 6 : bool success = m_sessionServerManager.setState(convertSessionServerState(request->sessionserverstate()));
131 6 : if (!success)
132 : {
133 1 : RIALTO_SERVER_LOG_ERROR("SetState operation failed");
134 3 : controller->SetFailed("SetState failed");
135 : }
136 6 : done->Run();
137 : }
138 :
139 1 : void ServerManagerModuleService::setLogLevels(::google::protobuf::RpcController *controller,
140 : const ::rialto::SetLogLevelsRequest *request,
141 : ::rialto::SetLogLevelsResponse *response, ::google::protobuf::Closure *done)
142 : {
143 1 : RIALTO_SERVER_LOG_DEBUG("setLogLevels received from ServerManager");
144 1 : m_sessionServerManager.setLogLevels(static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().defaultloglevels()),
145 1 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().clientloglevels()),
146 1 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().sessionserverloglevels()),
147 1 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().ipcloglevels()),
148 1 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().servermanagerloglevels()),
149 1 : static_cast<RIALTO_DEBUG_LEVEL>(request->loglevels().commonloglevels()));
150 1 : done->Run();
151 : }
152 :
153 3 : void ServerManagerModuleService::ping(::google::protobuf::RpcController *controller, const ::rialto::PingRequest *request,
154 : ::rialto::PingResponse *response, ::google::protobuf::Closure *done)
155 : {
156 3 : RIALTO_SERVER_LOG_DEBUG("Ping received from ServerManager");
157 3 : auto ipcController = dynamic_cast<firebolt::rialto::ipc::IController *>(controller);
158 3 : if (!ipcController)
159 : {
160 1 : RIALTO_SERVER_LOG_ERROR("ipc library provided incompatible controller object");
161 2 : controller->SetFailed("ipc library provided incompatible controller object");
162 1 : done->Run();
163 1 : return;
164 : }
165 2 : bool success = m_sessionServerManager.ping(request->id(), std::make_shared<AckSender>(ipcController->getClient()));
166 2 : if (!success)
167 : {
168 1 : RIALTO_SERVER_LOG_ERROR("Ping failed");
169 3 : controller->SetFailed("Ping failed");
170 : }
171 2 : done->Run();
172 : }
173 : } // namespace firebolt::rialto::server::ipc
|
