OdbDesign
OdbDesign ODB++ Parser - C++ library, gRPC/REST server, CLI, tests
 
Loading...
Searching...
No Matches
DesignsController.cpp
Go to the documentation of this file.
1#include "DesignsController.h"
3#include "UrlEncoding.h"
4#include "App/IOdbServerApp.h"
6#include "../Services/OdbDesignServiceImpl.h"
7#include <Logger.h>
8#include <cstring>
9#include <utility>
10#include <vector>
11
12
13using namespace Odb::Lib::App;
14using namespace Utils;
15
17{
22
23 std::optional<crow::response> DesignsController::TryGetDesign(
24 const std::string& designName,
25 std::shared_ptr<Odb::Lib::ProductModel::Design>& pDesign) const
26 {
27 try
28 {
29 pDesign = m_serverApp.designs().GetDesign(designName);
30 }
31 catch (const std::exception& e)
32 {
33 // Corrupt / unloadable archive: DesignCache::LoadFileArchive throws,
34 // and the exception propagates through LoadDesign/GetDesign. Translate
35 // to INTERNAL/500. The exception details (which may contain server
36 // filesystem paths) are logged server-side only, never sent to the client.
37 logexception_msg(e, "failed to load design \"" + designName + "\"");
38 return crow::response(crow::status::INTERNAL_SERVER_ERROR,
39 "failed to load design \"" + designName + "\": could not extract or parse archive");
40 }
41
42 if (pDesign == nullptr)
43 {
44 std::stringstream ss;
45 ss << "design: \"" << designName << "\" not found";
46 return crow::response(crow::status::NOT_FOUND, ss.str());
47 }
48
49 return std::nullopt;
50 }
51
53 {
54 CROW_ROUTE(m_serverApp.crow_app(), "/designs")
55 ([&](const crow::request& req)
56 {
57 // authenticate request before sending to handler
58 auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
59 if (authResp.code != crow::status::OK)
60 {
61 return authResp;
62 }
63
64 return this->designs_list_route_handler(req);
65 });
66
67 CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>")
68 ([&](const crow::request& req, std::string designName)
69 {
70 // authenticate request before sending to handler
71 auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
72 if (authResp.code != crow::status::OK)
73 {
74 return authResp;
75 }
76
77 return this->design_route_handler(designName, req);
78 });
79
80 CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/load")
81 .methods(crow::HTTPMethod::POST)
82 ([&](const crow::request& req, std::string designName)
83 {
84 // authenticate request before sending to handler
85 auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
86 if (authResp.code != crow::status::OK)
87 {
88 return authResp;
89 }
90
91 return this->designs_load_route_handler(designName, req);
92 });
93
94 CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/components")
95 ([&](const crow::request& req, std::string designName)
96 {
97 // authenticate request before sending to handler
98 auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
99 if (authResp.code != crow::status::OK)
100 {
101 return authResp;
102 }
103
104 return this->designs_components_route_handler(designName, req);
105 });
106
107 //CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/components/<string>")
108 // ([&](const crow::request& req, std::string designName, std::string refDes)
109 // {
110 // // authenticate request before sending to handler
111 // auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
112 // if (authResp.code != crow::status::OK)
113 // {
114 // return authResp;
115 // }
116
117 // return this->designs_component_route_handler(designName, refDes, req);
118 // });
119
120 CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/nets")
121 ([&](const crow::request& req, std::string designName)
122 {
123 // authenticate request before sending to handler
124 auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
125 if (authResp.code != crow::status::OK)
126 {
127 return authResp;
128 }
129
130 return this->designs_nets_route_handler(designName, req);
131 });
132
133 //CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/nets/<string>")
134 // ([&](const crow::request& req, std::string designName, std::string netName)
135 // {
136 // // authenticate request before sending to handler
137 // auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
138 // if (authResp.code != crow::status::OK)
139 // {
140 // return authResp;
141 // }
142
143 // return this->designs_net_route_handler(designName, netName, req);
144 // });
145
146 CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/packages")
147 ([&](const crow::request& req, std::string designName)
148 {
149 // authenticate request before sending to handler
150 auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
151 if (authResp.code != crow::status::OK)
152 {
153 return authResp;
154 }
155
156 return this->designs_packages_route_handler(designName, req);
157 });
158
159 //CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/packages/<string>")
160 // ([&](const crow::request& req, std::string designName, std::string packageName)
161 // {
162 // // authenticate request before sending to handler
163 // auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
164 // if (authResp.code != crow::status::OK)
165 // {
166 // return authResp;
167 // }
168
169 // return this->designs_package_route_handler(designName, packageName, req);
170 // });
171
172 CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/parts")
173 ([&](const crow::request& req, std::string designName)
174 {
175 // authenticate request before sending to handler
176 auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
177 if (authResp.code != crow::status::OK)
178 {
179 return authResp;
180 }
181
182 return this->designs_parts_route_handler(designName, req);
183 });
184
185 //CROW_ROUTE(m_serverApp.crow_app(), "/designs/<string>/parts/<string>")
186 // ([&](const crow::request& req, std::string designName, std::string partName)
187 // {
188 // // authenticate request before sending to handler
189 // auto authResp = m_serverApp.request_auth().AuthenticateRequest(req);
190 // if (authResp.code != crow::status::OK)
191 // {
192 // return authResp;
193 // }
194
195 // return this->designs_part_route_handler(designName, partName, req);
196 // });
197 }
198
199 crow::response DesignsController::designs_list_route_handler(const crow::request& req)
200 {
201 return makeLoadedFileModelsResponse(false);
202 }
203
204 crow::response DesignsController::design_route_handler(std::string designName, const crow::request& req)
205 {
206 auto designNameDecoded = UrlEncoding::decode(designName);
207 if (designNameDecoded.empty())
208 {
209 return crow::response(crow::status::BAD_REQUEST, "design name not specified");
210 }
211
212 std::shared_ptr<Odb::Lib::ProductModel::Design> pDesign;
213 if (auto errorResponse = TryGetDesign(designNameDecoded, pDesign))
214 {
215 return std::move(*errorResponse);
216 }
217
218 // TODO: use excludeFileArchive
219 bool includeFileArchive = false;
220 auto szIncludeFileArchive = req.url_params.get(kszIncludeFileArchiveQueryParamName);
221 if (szIncludeFileArchive != nullptr)
222 {
223 if (std::strcmp(szIncludeFileArchive, "true") == 0 ||
224 std::strcmp(szIncludeFileArchive, "yes") == 0)
225 {
226 includeFileArchive = true;
227 }
228 }
229
230 if (!includeFileArchive)
231 {
232 // Serve a clipped VIEW, never the cached object itself: pDesign is
233 // the shared cache-resident Design (GetDesign returns the cached
234 // instance), and ClipFileModel() nulls the member on whatever it
235 // is called on — calling it here used to destroy the file model
236 // for every later consumer of the same cache entry (gRPC GetDesign
237 // served a fileModel-less Design message from then on, until
238 // eviction or restart). The shallow copy only bumps shared_ptr
239 // refcounts for the heavy collections; the cached Design must keep
240 // its file model (see the M1.4 note in DesignCache.h).
241 auto pClippedView = std::make_shared<Odb::Lib::ProductModel::Design>(*pDesign);
242 pClippedView->ClipFileModel();
243 return crow::response(JsonCrowReturnable(*pClippedView));
244 }
245
246 return crow::response(JsonCrowReturnable(*pDesign));
247 }
248 crow::response DesignsController::designs_load_route_handler(std::string designName, const crow::request& req)
249 {
250 auto designNameDecoded = UrlEncoding::decode(designName);
251 if (designNameDecoded.empty())
252 {
253 return crow::response(crow::status::BAD_REQUEST, "design name not specified");
254 }
255
256 // Same pure status mapping as the gRPC RequestLoadDesign twin: never
257 // blocks on a parse, the only mutating call is the async-load kick.
258 // Like the gRPC twin (and TryGetDesign above), thread-spawn failure
259 // from LoadDesignAsync maps to an error response — an uncaught escape
260 // would die in Crow's worker loop and leave the client with no
261 // response at all.
262 Odb::Grpc::LoadStatus status;
263 try
264 {
266 m_serverApp.designs(), designNameDecoded);
267 }
268 catch (const std::exception& e)
269 {
270 logexception_msg(e, "failed to kick load for design \"" + designNameDecoded + "\"");
271 return crow::response(crow::status::INTERNAL_SERVER_ERROR,
272 "failed to start load for design \"" + designNameDecoded + "\"");
273 }
274
275 crow::json::wvalue wv;
276 wv["designName"] = designNameDecoded;
278
279 // 202 even for "not_found": the request itself succeeded, the body
280 // carries the load status distinction.
281 return crow::response(crow::status::ACCEPTED, std::move(wv));
282 }
283
284 crow::response DesignsController::designs_components_route_handler(std::string designName, const crow::request& req)
285 {
286 auto designNameDecoded = UrlEncoding::decode(designName);
287 if (designNameDecoded.empty())
288 {
289 return crow::response(crow::status::BAD_REQUEST, "design name not specified");
290 }
291
292 std::shared_ptr<Odb::Lib::ProductModel::Design> pDesign;
293 if (auto errorResponse = TryGetDesign(designNameDecoded, pDesign))
294 {
295 return std::move(*errorResponse);
296 }
297
298 std::vector<crow::json::rvalue> rvComponents;
299
300 const auto& components = pDesign->GetComponents();
301 for (const auto& component : components)
302 {
303 rvComponents.push_back(crow::json::load(component->to_json()));
304 }
305
306 crow::json::wvalue wv;
307 wv = std::move(rvComponents);
308 return crow::response(wv);
309 }
310
311 crow::response DesignsController::designs_component_route_handler(std::string designName, std::string refDes, const crow::request& req)
312 {
313 return crow::response();
314 }
315
316 crow::response DesignsController::designs_nets_route_handler(std::string designName, const crow::request& req)
317 {
318 auto designNameDecoded = UrlEncoding::decode(designName);
319 if (designNameDecoded.empty())
320 {
321 return crow::response(crow::status::BAD_REQUEST, "design name not specified");
322 }
323
324 std::shared_ptr<Odb::Lib::ProductModel::Design> pDesign;
325 if (auto errorResponse = TryGetDesign(designNameDecoded, pDesign))
326 {
327 return std::move(*errorResponse);
328 }
329
330 std::vector<crow::json::rvalue> rvNets;
331
332 const auto& nets = pDesign->GetNets();
333 for (const auto& net : nets)
334 {
335 rvNets.push_back(crow::json::load(net->to_json()));
336 }
337
338 crow::json::wvalue wv;
339 wv = std::move(rvNets);
340 return crow::response(wv);
341 }
342
343 crow::response DesignsController::designs_net_route_handler(std::string designName, std::string netName, const crow::request& req)
344 {
345 return crow::response();
346 }
347
348 crow::response DesignsController::designs_parts_route_handler(std::string designName, const crow::request& req)
349 {
350 auto designNameDecoded = UrlEncoding::decode(designName);
351 if (designNameDecoded.empty())
352 {
353 return crow::response(crow::status::BAD_REQUEST, "design name not specified");
354 }
355
356 std::shared_ptr<Odb::Lib::ProductModel::Design> pDesign;
357 if (auto errorResponse = TryGetDesign(designNameDecoded, pDesign))
358 {
359 return std::move(*errorResponse);
360 }
361
362 std::vector<crow::json::rvalue> rvParts;
363
364 const auto& parts = pDesign->GetParts();
365 for (const auto& part : parts)
366 {
367 rvParts.push_back(crow::json::load(part->to_json()));
368 }
369
370 crow::json::wvalue wv;
371 wv = std::move(rvParts);
372 return crow::response(wv);
373 }
374
375 crow::response DesignsController::designs_part_route_handler(std::string designName, std::string partName, const crow::request& req)
376 {
377 return crow::response();
378 }
379
380 crow::response DesignsController::designs_packages_route_handler(std::string designName, const crow::request& req)
381 {
382 auto designNameDecoded = UrlEncoding::decode(designName);
383 if (designNameDecoded.empty())
384 {
385 return crow::response(crow::status::BAD_REQUEST, "design name not specified");
386 }
387
388 std::shared_ptr<Odb::Lib::ProductModel::Design> pDesign;
389 if (auto errorResponse = TryGetDesign(designNameDecoded, pDesign))
390 {
391 return std::move(*errorResponse);
392 }
393
394 std::vector<crow::json::rvalue> rvPackages;
395
396 const auto& packages = pDesign->GetPackages();
397 for (const auto& package : packages)
398 {
399 rvPackages.push_back(crow::json::load(package->to_json()));
400 }
401
402 crow::json::wvalue wv;
403 wv = std::move(rvPackages);
404 return crow::response(wv);
405 }
406
407 crow::response DesignsController::designs_package_route_handler(std::string designName, std::string packageName, const crow::request& req)
408 {
409 return crow::response();
410 }
411}
#define logexception_msg(e, m)
Definition Logger.h:29
static constexpr const char * kszIncludeFileArchiveQueryParamName
DesignsController(Odb::Lib::App::IOdbServerApp &serverApp)
std::shared_ptr< ProductModel::Design > GetDesign(const std::string &designName)
virtual DesignCache & designs()=0
virtual RequestAuthenticationBase & request_auth()=0
virtual CrowApp & crow_app()=0
virtual crow::response AuthenticateRequest(const crow::request &req)
crow::response makeLoadedFileModelsResponse(bool) const
static std::string decode(const std::string &encoded)
const char * LoadStatusToString(Odb::Grpc::LoadStatus status)
Odb::Grpc::LoadStatus ComputeRequestLoadStatus(Odb::Lib::App::DesignCache &designCache, const std::string &designName)