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 2023 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 "ConfigReader.h"
21 : #include "RialtoServerManagerLogging.h"
22 : #include <fstream>
23 : #include <json/json.h>
24 :
25 : namespace rialto::servermanager::service
26 : {
27 30 : ConfigReader::ConfigReader(std::shared_ptr<firebolt::rialto::wrappers::IJsonCppWrapper> jsonWrapper,
28 30 : std::shared_ptr<IFileReader> fileReader)
29 30 : : m_jsonWrapper(jsonWrapper), m_fileReader(fileReader)
30 : {
31 : }
32 :
33 29 : bool ConfigReader::read()
34 : {
35 29 : if (!m_fileReader->isOpen())
36 : {
37 1 : return false;
38 : }
39 :
40 28 : std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root;
41 28 : Json::CharReaderBuilder builder;
42 28 : if (!m_jsonWrapper->parseFromStream(builder, m_fileReader->get(), root, nullptr))
43 : {
44 1 : RIALTO_SERVER_MANAGER_LOG_ERROR("Failed to parse config file");
45 1 : return false;
46 : }
47 :
48 27 : parseEnvironmentVariables(root);
49 27 : parseExtraEnvVariables(root);
50 27 : parseSessionServerPath(root);
51 27 : parseSessionServerStartupTimeout(root);
52 27 : parseHealthcheckInterval(root);
53 27 : parseSocketPermissions(root);
54 27 : parseSocketOwner(root);
55 27 : parseSocketGroup(root);
56 27 : parseNumOfPreloadedServers(root);
57 27 : parseLogLevel(root);
58 27 : parseNumOfPingsBeforeRecovery(root);
59 :
60 27 : return true;
61 28 : }
62 :
63 27 : void ConfigReader::parseEnvironmentVariables(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
64 : {
65 27 : m_envVars = getListOfStrings(root, "environmentVariables");
66 : }
67 :
68 27 : void ConfigReader::parseExtraEnvVariables(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
69 : {
70 27 : m_extraEnvVars = getListOfStrings(root, "extraEnvVariables");
71 : }
72 :
73 27 : void ConfigReader::parseSessionServerPath(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
74 : {
75 27 : m_sessionServerPath = getString(root, "sessionServerPath");
76 : }
77 :
78 27 : void ConfigReader::parseSessionServerStartupTimeout(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
79 : {
80 27 : auto timeout{getUInt(root, "startupTimeoutMs")};
81 27 : if (timeout.has_value())
82 : {
83 1 : m_sessionServerStartupTimeout = std::chrono::milliseconds{timeout.value()};
84 : }
85 27 : }
86 :
87 27 : void ConfigReader::parseHealthcheckInterval(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
88 : {
89 27 : auto interval{getUInt(root, "healthcheckIntervalInSeconds")};
90 27 : if (interval.has_value())
91 : {
92 1 : m_healthcheckInterval = std::chrono::seconds{*interval};
93 : }
94 27 : }
95 :
96 27 : void ConfigReader::parseSocketPermissions(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
97 : {
98 27 : auto permissions{getUInt(root, "socketPermissions")};
99 27 : if (permissions.has_value())
100 : {
101 1 : firebolt::rialto::common::SocketPermissions socketPermissions;
102 1 : socketPermissions.ownerPermissions = (*permissions / 100) % 10;
103 1 : socketPermissions.groupPermissions = (*permissions / 10) % 10;
104 1 : socketPermissions.otherPermissions = (*permissions) % 10;
105 1 : m_socketPermissions = socketPermissions;
106 : }
107 27 : }
108 :
109 27 : void ConfigReader::parseSocketOwner(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
110 : {
111 27 : m_socketOwner = getString(root, "socketOwner");
112 : }
113 :
114 27 : void ConfigReader::parseSocketGroup(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
115 : {
116 27 : m_socketGroup = getString(root, "socketGroup");
117 : }
118 :
119 27 : void ConfigReader::parseNumOfPreloadedServers(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
120 : {
121 27 : m_numOfPreloadedServers = getUInt(root, "numOfPreloadedServers");
122 : }
123 :
124 27 : void ConfigReader::parseLogLevel(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
125 : {
126 27 : std::optional<unsigned> loggingLevel{getUInt(root, "logLevel")};
127 :
128 27 : if (loggingLevel)
129 : {
130 1 : rialto::servermanager::service::LoggingLevel newLevel{rialto::servermanager::service::LoggingLevel::UNCHANGED};
131 :
132 1 : switch (*loggingLevel)
133 : {
134 0 : case 0:
135 0 : newLevel = rialto::servermanager::service::LoggingLevel::FATAL;
136 0 : break;
137 0 : case 1:
138 0 : newLevel = rialto::servermanager::service::LoggingLevel::ERROR;
139 0 : break;
140 0 : case 2:
141 0 : newLevel = rialto::servermanager::service::LoggingLevel::WARNING;
142 0 : break;
143 1 : case 3:
144 1 : newLevel = rialto::servermanager::service::LoggingLevel::MILESTONE;
145 1 : break;
146 0 : case 4:
147 0 : newLevel = rialto::servermanager::service::LoggingLevel::INFO;
148 0 : break;
149 0 : case 5:
150 0 : newLevel = rialto::servermanager::service::LoggingLevel::DEBUG;
151 0 : break;
152 0 : default:
153 0 : newLevel = rialto::servermanager::service::LoggingLevel::UNCHANGED;
154 0 : break;
155 : }
156 1 : m_loggingLevels = {newLevel, newLevel, newLevel, newLevel, newLevel, newLevel};
157 : }
158 27 : }
159 :
160 27 : void ConfigReader::parseNumOfPingsBeforeRecovery(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root)
161 : {
162 27 : m_numOfPingsBeforeRecovery = getUInt(root, "numOfPingsBeforeRecovery");
163 : }
164 :
165 5 : std::list<std::string> ConfigReader::getEnvironmentVariables()
166 : {
167 5 : return m_envVars;
168 : }
169 :
170 4 : std::list<std::string> ConfigReader::getExtraEnvVariables()
171 : {
172 4 : return m_extraEnvVars;
173 : }
174 :
175 3 : std::optional<std::string> ConfigReader::getSessionServerPath()
176 : {
177 3 : return m_sessionServerPath;
178 : }
179 :
180 3 : std::optional<std::chrono::milliseconds> ConfigReader::getSessionServerStartupTimeout()
181 : {
182 3 : return m_sessionServerStartupTimeout;
183 : }
184 :
185 3 : std::optional<std::chrono::seconds> ConfigReader::getHealthcheckInterval()
186 : {
187 3 : return m_healthcheckInterval;
188 : }
189 :
190 5 : std::optional<firebolt::rialto::common::SocketPermissions> ConfigReader::getSocketPermissions()
191 : {
192 5 : return m_socketPermissions;
193 : }
194 :
195 3 : std::optional<std::string> ConfigReader::getSocketOwner()
196 : {
197 3 : return m_socketOwner;
198 : }
199 :
200 3 : std::optional<std::string> ConfigReader::getSocketGroup()
201 : {
202 3 : return m_socketGroup;
203 : }
204 :
205 4 : std::optional<unsigned int> ConfigReader::getNumOfPreloadedServers()
206 : {
207 4 : return m_numOfPreloadedServers;
208 : }
209 :
210 7 : std::optional<rialto::servermanager::service::LoggingLevels> ConfigReader::getLoggingLevels()
211 : {
212 7 : return m_loggingLevels;
213 : }
214 :
215 1 : std::optional<unsigned int> ConfigReader::getNumOfPingsBeforeRecovery()
216 : {
217 1 : return m_numOfPingsBeforeRecovery;
218 : }
219 :
220 54 : std::list<std::string> ConfigReader::getListOfStrings(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root,
221 : const std::string &valueName) const
222 : {
223 54 : std::list<std::string> result;
224 54 : if (root->isMember(valueName) && root->at(valueName)->isArray())
225 : {
226 6 : std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> envVarsJson = root->at(valueName);
227 6 : Json::ArrayIndex size = envVarsJson->size();
228 12 : for (Json::ArrayIndex index = 0; index < size; ++index)
229 : {
230 6 : if (envVarsJson->at(index)->isString())
231 : {
232 4 : result.emplace_back(envVarsJson->at(index)->asString());
233 : }
234 : }
235 6 : }
236 54 : return result;
237 : }
238 :
239 81 : std::optional<std::string> ConfigReader::getString(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root,
240 : const std::string &valueName) const
241 : {
242 81 : if (root->isMember(valueName) && root->at(valueName)->isString())
243 : {
244 3 : return root->at(valueName)->asString();
245 : }
246 78 : return std::nullopt;
247 : }
248 :
249 162 : std::optional<unsigned int> ConfigReader::getUInt(std::shared_ptr<firebolt::rialto::wrappers::IJsonValueWrapper> root,
250 : const std::string &valueName) const
251 : {
252 162 : if (root->isMember(valueName) && root->at(valueName)->isUInt())
253 : {
254 6 : return root->at(valueName)->asUInt();
255 : }
256 156 : return std::nullopt;
257 : }
258 :
259 : } // namespace rialto::servermanager::service
|
