Cutelyst  2.13.0
context.cpp
1 /*
2  * Copyright (C) 2013-2017 Daniel Nicoletti <dantti12@gmail.com>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 #include "context_p.h"
19 
20 #include "common.h"
21 #include "request.h"
22 #include "response.h"
23 #include "action.h"
24 #include "dispatcher.h"
25 #include "controller.h"
26 #include "application.h"
27 #include "stats.h"
28 #include "enginerequest.h"
29 
30 #include "config.h"
31 
32 #include <QUrl>
33 #include <QUrlQuery>
34 #include <QCoreApplication>
35 #include <QBuffer>
36 
37 using namespace Cutelyst;
38 
39 Context::Context(ContextPrivate *priv) : d_ptr(priv)
40 {
41 }
42 
44  d_ptr(new ContextPrivate(app, app->engine(), app->dispatcher(), app->plugins()))
45 {
46  auto req = new DummyRequest(this);
47  req->body = new QBuffer(this);
48  req->body->open(QBuffer::ReadWrite);
49  req->context = this;
50 
51  d_ptr->response = new Response(app->defaultHeaders(), req);
52  d_ptr->request = new Request(req);
53  d_ptr->request->d_ptr->engine = d_ptr->engine;
54 }
55 
56 Context::~Context()
57 {
58  delete d_ptr->request;
59  delete d_ptr->response;
60  delete d_ptr;
61 }
62 
63 bool Context::error() const
64 {
65  Q_D(const Context);
66  return !d->error.isEmpty();
67 }
68 
69 void Context::error(const QString &error)
70 {
71  Q_D(Context);
72  if (error.isEmpty()) {
73  d->error.clear();
74  } else {
75  d->error << error;
76  qCCritical(CUTELYST_CORE) << error;
77  }
78 }
79 
80 QStringList Context::errors() const
81 {
82  Q_D(const Context);
83  return d->error;
84 }
85 
86 bool Context::state() const
87 {
88  Q_D(const Context);
89  return d->state;
90 }
91 
92 void Context::setState(bool state)
93 {
94  Q_D(Context);
95  d->state = state;
96 }
97 
99 {
100  Q_D(const Context);
101  return d->engine;
102 }
103 
105 {
106  Q_D(const Context);
107  return d->app;
108 }
109 
111 {
112  Q_D(const Context);
113  return d->response;
114 }
115 
117 {
118  Q_D(const Context);
119  return d->response;
120 }
121 
122 Action *Context::action() const
123 {
124  Q_D(const Context);
125  return d->action;
126 }
127 
128 QString Context::actionName() const
129 {
130  Q_D(const Context);
131  return d->action->name();
132 }
133 
134 QString Context::ns() const
135 {
136  Q_D(const Context);
137  return d->action->ns();
138 }
139 
140 Request *Context::request() const
141 {
142  Q_D(const Context);
143  return d->request;
144 }
145 
146 Request *Context::req() const
147 {
148  Q_D(const Context);
149  return d->request;
150 }
151 
153 {
154  Q_D(const Context);
155  return d->dispatcher;
156 }
157 
158 QString Cutelyst::Context::controllerName() const
159 {
160  Q_D(const Context);
161  return QString::fromLatin1(d->action->controller()->metaObject()->className());
162 }
163 
164 Controller *Context::controller() const
165 {
166  Q_D(const Context);
167  return d->action->controller();
168 }
169 
170 Controller *Context::controller(const QString &name) const
171 {
172  Q_D(const Context);
173  return d->dispatcher->controllers().value(name);
174 }
175 
177 {
178  Q_D(const Context);
179  return d->view;
180 }
181 
182 View *Context::view(const QString &name) const
183 {
184  Q_D(const Context);
185  return d->app->view(name);
186 }
187 
188 bool Context::setCustomView(const QString &name)
189 {
190  Q_D(Context);
191  d->view = d->app->view(name);
192  return d->view;
193 }
194 
195 QVariantHash &Context::stash()
196 {
197  Q_D(Context);
198  return d->stash;
199 }
200 
201 QVariant Context::stash(const QString &key) const
202 {
203  Q_D(const Context);
204  return d->stash.value(key);
205 }
206 
207 QVariant Context::stash(const QString &key, const QVariant &defaultValue) const
208 {
209  Q_D(const Context);
210  return d->stash.value(key, defaultValue);
211 }
212 
213 QVariant Context::stashTake(const QString &key)
214 {
215  Q_D(Context);
216  return d->stash.take(key);
217 }
218 
219 bool Context::stashRemove(const QString &key)
220 {
221  Q_D(Context);
222  return d->stash.remove(key);
223 }
224 
225 void Context::setStash(const QString &key, const QVariant &value)
226 {
227  Q_D(Context);
228  d->stash.insert(key, value);
229 }
230 
231 void Context::setStash(const QString &key, const ParamsMultiMap &map)
232 {
233  Q_D(Context);
234  d->stash.insert(key, QVariant::fromValue(map));
235 }
236 
237 QStack<Component *> Context::stack() const
238 {
239  Q_D(const Context);
240  return d->stack;
241 }
242 
243 QUrl Context::uriFor(const QString &path, const QStringList &args, const ParamsMultiMap &queryValues) const
244 {
245  Q_D(const Context);
246 
247  QUrl uri = d->request->uri();
248 
249  QString _path;
250  if (path.isEmpty()) {
251  // ns must NOT return a leading slash
252  const QString controllerNS = d->action->controller()->ns();
253  if (!controllerNS.isEmpty()) {
254  _path.prepend(controllerNS);
255  }
256  } else {
257  _path = path;
258  }
259 
260  if (!args.isEmpty()) {
261  if (_path == QLatin1String("/")) {
262  _path += args.join(QLatin1Char('/'));
263  } else {
264  _path = _path + QLatin1Char('/') + args.join(QLatin1Char('/'));
265  }
266  }
267 
268  if (!_path.startsWith(QLatin1Char('/'))) {
269  _path.prepend(QLatin1Char('/'));
270  }
271  uri.setPath(_path, QUrl::DecodedMode);
272 
273  QUrlQuery query;
274  if (!queryValues.isEmpty()) {
275  // Avoid a trailing '?'
276  if (queryValues.size()) {
277  auto it = queryValues.constEnd();
278  while (it != queryValues.constBegin()) {
279  --it;
280  query.addQueryItem(it.key(), it.value());
281  }
282  }
283  }
284  uri.setQuery(query);
285 
286  return uri;
287 }
288 
289 QUrl Context::uriFor(Action *action, const QStringList &captures, const QStringList &args, const ParamsMultiMap &queryValues) const
290 {
291  Q_D(const Context);
292 
293  QUrl uri;
294  Action *localAction = action;
295  if (!localAction) {
296  localAction = d->action;
297  }
298 
299  QStringList localArgs = args;
300  QStringList localCaptures = captures;
301 
302  Action *expandedAction = d->dispatcher->expandAction(this, action);
303  if (expandedAction->numberOfCaptures() > 0) {
304  while (localCaptures.size() < expandedAction->numberOfCaptures()
305  && localArgs.size()) {
306  localCaptures.append(localArgs.takeFirst());
307  }
308  } else {
309  QStringList localCapturesAux = localCaptures;
310  localCapturesAux.append(localArgs);
311  localArgs = localCapturesAux;
312  localCaptures = QStringList();
313  }
314 
315  const QString path = d->dispatcher->uriForAction(localAction, localCaptures);
316  if (path.isEmpty()) {
317  qCWarning(CUTELYST_CORE) << "Can not find action for" << localAction << localCaptures;
318  return uri;
319  }
320 
321  uri = uriFor(path, localArgs, queryValues);
322  return uri;
323 }
324 
325 QUrl Context::uriForAction(const QString &path, const QStringList &captures, const QStringList &args, const ParamsMultiMap &queryValues) const
326 {
327  Q_D(const Context);
328 
329  QUrl uri;
330  Action *action = d->dispatcher->getActionByPath(path);
331  if (!action) {
332  qCWarning(CUTELYST_CORE) << "Can not find action for" << path;
333  return uri;
334  }
335 
336  uri = uriFor(action, captures, args, queryValues);
337  return uri;
338 }
339 
340 bool Context::detached() const
341 {
342  Q_D(const Context);
343  return d->detached;
344 }
345 
346 void Context::detach(Action *action)
347 {
348  Q_D(Context);
349  if (action) {
350  d->dispatcher->forward(this, action);
351  } else {
352  d->detached = true;
353  }
354 }
355 
357 {
358  Q_D(Context);
359  d->asyncDetached = true;
360  d->engineRequest->status |= EngineRequest::Async;
361 }
362 
364 {
365  Q_D(Context);
366  bool &asyncDetached = d->asyncDetached;
367  asyncDetached = false;
368 
369  while (!d->pendingAsync.isEmpty()) {
370  Component *action = d->pendingAsync.takeLast();
371  if (!execute(action)) {
372  break; // we are finished
373  } else if (asyncDetached) {
374  return;
375  }
376  }
377 
378  if (d->engineRequest->status & EngineRequest::Async) {
379  Q_EMIT d->app->afterDispatch(this);
380 
381  finalize();
382  }
383 }
384 
386 {
387  Q_D(Context);
388  return d->dispatcher->forward(this, action);
389 }
390 
391 bool Context::forward(const QString &action)
392 {
393  Q_D(Context);
394  return d->dispatcher->forward(this, action);
395 }
396 
397 Action *Context::getAction(const QString &action, const QString &ns) const
398 {
399  Q_D(const Context);
400  return d->dispatcher->getAction(action, ns);
401 }
402 
403 QVector<Action *> Context::getActions(const QString &action, const QString &ns) const
404 {
405  Q_D(const Context);
406  return d->dispatcher->getActions(action, ns);
407 }
408 
409 QVector<Cutelyst::Plugin *> Context::plugins() const
410 {
411  Q_D(const Context);
412  return d->plugins;
413 }
414 
416 {
417  Q_D(Context);
418  Q_ASSERT_X(code, "Context::execute", "trying to execute a null Cutelyst::Component");
419 
420  static int recursion = qEnvironmentVariableIsSet("RECURSION") ? qEnvironmentVariableIntValue("RECURSION") : 1000;
421  if (d->stack.size() >= recursion) {
422  QString msg = QStringLiteral("Deep recursion detected (stack size %1) calling %2, %3")
423  .arg(QString::number(d->stack.size()), code->reverse(), code->name());
424  error(msg);
425  setState(false);
426  return false;
427  }
428 
429  bool ret;
430  d->stack.push(code);
431 
432  if (d->stats) {
433  const QString statsInfo = d->statsStartExecute(code);
434 
435  ret = code->execute(this);
436 
437  if (!statsInfo.isEmpty()) {
438  d->statsFinishExecute(statsInfo);
439  }
440  } else {
441  ret = code->execute(this);
442  }
443 
444  d->stack.pop();
445 
446  return ret;
447 }
448 
449 QLocale Context::locale() const
450 {
451  Q_D(const Context);
452  return d->locale;
453 }
454 
455 void Context::setLocale(const QLocale &locale)
456 {
457  Q_D(Context);
458  d->locale = locale;
459 }
460 
461 QVariant Context::config(const QString &key, const QVariant &defaultValue) const
462 {
463  Q_D(const Context);
464  return d->app->config(key, defaultValue);
465 }
466 
467 QVariantMap Context::config() const
468 {
469  Q_D(const Context);
470  return d->app->config();
471 }
472 
473 QString Context::translate(const char *context, const char *sourceText, const char *disambiguation, int n) const
474 {
475  Q_D(const Context);
476  return d->app->translate(d->locale, context, sourceText, disambiguation, n);
477 }
478 
479 bool Context::wait(uint count)
480 {
481  Q_UNUSED(count)
482 // Q_D(Context);
483 // if (d->loop) {
484 // d->loopWait += count;
485 // return false;
486 // }
487 
488 // if (count) {
489 // d->loopWait = count;
490 // d->loop = new QEventLoop(this);
491 // d->loop->exec();
492 // return true;
493 // }
494  return false;
495 }
496 
497 void Context::finalize()
498 {
499  Q_D(Context);
500 
501  if (d->stats) {
502  qCDebug(CUTELYST_STATS, "Response Code: %d; Content-Type: %s; Content-Length: %s",
503  d->response->status(),
504  qPrintable(d->response->headers().header(QStringLiteral("CONTENT_TYPE"), QStringLiteral("unknown"))),
505  qPrintable(d->response->headers().header(QStringLiteral("CONTENT_LENGTH"), QStringLiteral("unknown"))));
506 
507  const double enlapsed = d->engineRequest->elapsed.nsecsElapsed() / 1000000000.0;
508  QString average;
509  if (enlapsed == 0.0) {
510  average = QStringLiteral("??");
511  } else {
512  average = QString::number(1.0 / enlapsed, 'f');
513  average.truncate(average.size() - 3);
514  }
515  qCInfo(CUTELYST_STATS) << qPrintable(QStringLiteral("Request took: %1s (%2/s)\n%3")
516  .arg(QString::number(enlapsed, 'f'),
517  average,
518  QString::fromLatin1(d->stats->report())));
519  delete d->stats;
520  d->stats = nullptr;
521  }
522 
523  d->engineRequest->finalize();
524 }
525 
526 void Context::next(bool force)
527 {
528 // Q_D(Context);
529  Q_UNUSED(force)
530 // if (!d->loop || (--d->loopWait && !force)) {
531 // return;
532 // }
533 
534 // d->loop->quit();
535 // d->loop->deleteLater();
536 // d->loop = nullptr;
537 }
538 
539 QString ContextPrivate::statsStartExecute(Component *code)
540 {
541  QString actionName;
542  // Skip internal actions
543  if (code->name().startsWith(QLatin1Char('_'))) {
544  return actionName;
545  }
546 
547  actionName = code->reverse();
548 
549  if (qobject_cast<Action *>(code)) {
550  actionName.prepend(QLatin1Char('/'));
551  }
552 
553  if (stack.size() > 2) {
554  actionName = QLatin1String("-> ") + actionName;
555  actionName = actionName.rightJustified(actionName.size() + stack.size() - 2, QLatin1Char(' '));
556  }
557 
558  stats->profileStart(actionName);
559 
560  return actionName;
561 }
562 
563 void ContextPrivate::statsFinishExecute(const QString &statsInfo)
564 {
565  stats->profileEnd(statsInfo);
566 }
567 
568 #include "moc_context.cpp"
569 #include "moc_context_p.cpp"
Cutelyst::Controller
Cutelyst Controller base class
Definition: controller.h:102
Cutelyst::ParamsMultiMap
QMap< QString, QString > ParamsMultiMap
Definition: paramsmultimap.h:36
Cutelyst::Request::body
QIODevice * body() const
Definition: request.cpp:192
Cutelyst::Context::detach
void detach(Action *action=nullptr)
Definition: context.cpp:346
Cutelyst::Application
The Cutelyst Application.
Definition: application.h:55
Cutelyst::Dispatcher
The Cutelyst Dispatcher.
Definition: dispatcher.h:40
Cutelyst::Context
The Cutelyst Context.
Definition: context.h:50
Cutelyst::Context::attachAsync
void attachAsync()
attachAsync
Definition: context.cpp:363
Cutelyst::Context::Context
Context(Application *app)
Constructs a new DUMMY Context object that is child of Application This currently is experimental to ...
Definition: context.cpp:43
Cutelyst::Context::stash
QVariantHash & stash()
Definition: context.cpp:195
Cutelyst::Context::setStash
void setStash(const QString &key, const QVariant &value)
Definition: context.cpp:225
Cutelyst::Context::response
Response * response() const
Definition: context.cpp:110
Cutelyst::Component
The Cutelyst Component base class.
Definition: component.h:38
Cutelyst::Request
Definition: request.h:42
Cutelyst::Application::defaultHeaders
Headers & defaultHeaders()
Definition: application.cpp:93
Cutelyst::Context::execute
bool execute(Component *code)
Definition: context.cpp:415
Cutelyst::Context::setCustomView
bool setCustomView(const QString &name)
Definition: context.cpp:188
Cutelyst::Context::translate
QString translate(const char *context, const char *sourceText, const char *disambiguation=nullptr, int n=-1) const
Definition: context.cpp:473
Cutelyst::Context::setLocale
void setLocale(const QLocale &locale)
Definition: context.cpp:455
Cutelyst::Component::execute
bool execute(Context *c)
Definition: component.cpp:75
Cutelyst::Context::error
bool error() const
Returns true if an error was set.
Definition: context.cpp:63
Cutelyst::Context::locale
QLocale locale() const
Definition: context.cpp:449
Cutelyst::Context::stashTake
QVariant stashTake(const QString &key)
Definition: context.cpp:213
Cutelyst::Context::detachAsync
void detachAsync()
Definition: context.cpp:356
Cutelyst::Context::customView
View * customView() const
Definition: context.cpp:176
Cutelyst::Context::dispatcher
Dispatcher * dispatcher() const
Definition: context.cpp:152
Cutelyst::View
Cutelyst View abstract view component
Definition: view.h:34
Cutelyst::Context::uriFor
QUrl uriFor(const QString &path=QString(), const QStringList &args=QStringList(), const ParamsMultiMap &queryValues=ParamsMultiMap()) const
Definition: context.cpp:243
Cutelyst::Context::errors
QStringList errors() const
Returns a list of errors that were defined.
Definition: context.cpp:80
Cutelyst
The Cutelyst namespace holds all public Cutelyst API.
Definition: Mainpage.dox:7
Cutelyst::Component::name
QString name() const
Definition: component.cpp:44
Cutelyst::Context::uriForAction
QUrl uriForAction(const QString &path, const QStringList &captures=QStringList(), const QStringList &args=QStringList(), const ParamsMultiMap &queryValues=ParamsMultiMap()) const
Definition: context.cpp:325
Cutelyst::Engine
The Cutelyst Engine.
Definition: engine.h:33
Cutelyst::Action
This class represents a Cutelyst Action.
Definition: action.h:47
Cutelyst::Context::res
Response * res() const
Definition: context.cpp:116
Cutelyst::Context::plugins
QVector< Plugin * > plugins() const
Definition: context.cpp:409
Cutelyst::Context::next
void next(bool force=false)
This method is deprecated and no longer works, creating local event loops leads to crashes.
Definition: context.cpp:526
Cutelyst::Action::numberOfCaptures
virtual qint8 numberOfCaptures() const
Definition: action.cpp:141
Cutelyst::Context::stashRemove
bool stashRemove(const QString &key)
Definition: context.cpp:219
Cutelyst::Context::app
Application * app() const
Definition: context.cpp:104
Cutelyst::Context::wait
Q_DECL_DEPRECATED bool wait(uint count=1)
This method is deprecated and no longer works, creating local event loops leads to crashes.
Definition: context.cpp:479
Cutelyst::Component::reverse
QString reverse() const
Definition: component.cpp:56
Cutelyst::Context::setState
void setState(bool state)
Sets the state of the current executed action, setting to false will make the dispatcher skip non pro...
Definition: context.cpp:92
Cutelyst::Context::getActions
QVector< Action * > getActions(const QString &action, const QString &ns=QString()) const
Definition: context.cpp:403
Cutelyst::Context::view
View * view(const QString &name=QString()) const
Definition: context.cpp:182
Cutelyst::Context::engine
Engine * engine() const
Definition: context.cpp:98
Cutelyst::Context::stack
QStack< Component * > stack() const
Definition: context.cpp:237
Cutelyst::Context::forward
bool forward(Component *component)
Definition: context.cpp:385
Cutelyst::Context::detached
bool detached() const
Definition: context.cpp:340
Cutelyst::Context::getAction
Action * getAction(const QString &action, const QString &ns=QString()) const
Definition: context.cpp:397
Cutelyst::Response
Definition: response.h:34