Rooba
/
drogon
mirror of https://github.com/drogonframework/drogon.git
1
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Optimize routing

This commit is contained in:
antao 2019-01-19 01:31:14 +08:00
parent c4987f690b
commit 2094ce217a
8 changed files with 59 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
lib/src/HttpAppFrameworkImpl.cc
View File

@ -583,8 +583,7 @@ void HttpAppFrameworkImpl::onNewWebsockRequest(const HttpRequestImplPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
const WebSocketConnectionPtr &wsConnPtr)
{
auto callbackPtr = std::make_shared<std::function<void(const HttpResponsePtr &)>>(std::move(callback));
_websockCtrlsRouter.route(req, callbackPtr, wsConnPtr);
_websockCtrlsRouter.route(req, std::move(callback), wsConnPtr);
}
void HttpAppFrameworkImpl::onAsyncRequest(const HttpRequestImplPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
{
@ -780,13 +779,9 @@ void HttpAppFrameworkImpl::onAsyncRequest(const HttpRequestImplPtr &req, std::fu
return;
}
}
auto sessionIdPtr = std::make_shared<std::string>(std::move(session_id));
auto callbackPtr = std::make_shared<std::function<void(const HttpResponsePtr &)>>(std::move(callback));
//find simple controller
if (_httpSimpleCtrlsRouter.route(req, callbackPtr, needSetJsessionid, sessionIdPtr))
return;
//Find http controller
_httpCtrlsRouter.route(req, callbackPtr, needSetJsessionid, sessionIdPtr);
//Route to controller
_httpSimpleCtrlsRouter.route(req, std::move(callback), needSetJsessionid, std::move(session_id));
}
void HttpAppFrameworkImpl::readSendFile(const std::string &filePath, const HttpRequestImplPtr &req, const HttpResponsePtr &resp)

7
lib/src/HttpAppFrameworkImpl.h
View File

@ -39,8 +39,8 @@ class HttpAppFrameworkImpl : public HttpAppFramework
{
public:
HttpAppFrameworkImpl()
: _httpSimpleCtrlsRouter(*this),
_httpCtrlsRouter(*this),
: _httpCtrlsRouter(*this),
_httpSimpleCtrlsRouter(*this, _httpCtrlsRouter),
_websockCtrlsRouter(*this),
_uploadPath(_rootPath + "uploads"),
_connectionNum(0)
@ -157,8 +157,9 @@ class HttpAppFrameworkImpl : public HttpAppFramework
std::unique_ptr<CacheMap<std::string, SessionPtr>> _sessionMapPtr;
std::unique_ptr<CacheMap<std::string, HttpResponsePtr>> _responseCachingMap;
HttpSimpleControllersRouter _httpSimpleCtrlsRouter;
HttpControllersRouter _httpCtrlsRouter;
HttpSimpleControllersRouter _httpSimpleCtrlsRouter;
WebsocketControllersRouter _websockCtrlsRouter;
bool _enableLastModify = true;

30
lib/src/HttpControllersRouter.cc
View File

@ -138,9 +138,9 @@ void HttpControllersRouter::addHttpPath(const std::string &path,
}
void HttpControllersRouter::route(const HttpRequestImplPtr &req,
const std::shared_ptr<std::function<void(const HttpResponsePtr &)>> &callbackPtr,
std::function<void(const HttpResponsePtr &)> &&callback,
bool needSetJsessionid,
const std::shared_ptr<std::string> &sessionIdPtr)
std::string &&session_id)
{
//find http controller
if (_ctrlRegex.mark_count() > 0)
@ -165,20 +165,22 @@ void HttpControllersRouter::route(const HttpRequestImplPtr &req,
//Invalid Http Method
auto res = drogon::HttpResponse::newHttpResponse();
res->setStatusCode(HttpResponse::k405MethodNotAllowed);
(*callbackPtr)(res);
callback(res);
return;
}
auto &filters = binder->filtersName;
if (!filters.empty())
{
auto sessionIdPtr = std::make_shared<std::string>(std::move(session_id));
auto callbackPtr = std::make_shared<std::function<void(const HttpResponsePtr &)>>(std::move(callback));
_appImpl.doFilters(filters, req, callbackPtr, needSetJsessionid, sessionIdPtr, [=]() {
doControllerHandler(binder, routerItem, req, std::move(*callbackPtr), needSetJsessionid, std::move(*sessionIdPtr));
});
}
else
{
doControllerHandler(binder, routerItem, req, std::move(*callbackPtr), needSetJsessionid, std::move(*sessionIdPtr));
doControllerHandler(binder, routerItem, req, std::move(callback), needSetJsessionid, std::move(session_id));
}
}
}
@ -188,20 +190,17 @@ void HttpControllersRouter::route(const HttpRequestImplPtr &req,
//No controller found
auto res = drogon::HttpResponse::newNotFoundResponse();
if (needSetJsessionid)
res->addCookie("JSESSIONID", *sessionIdPtr);
(*callbackPtr)(res);
res->addCookie("JSESSIONID", session_id);
callback(res);
}
}
else
{
//No controller found
auto res = drogon::HttpResponse::newNotFoundResponse();
if (needSetJsessionid)
res->addCookie("JSESSIONID", *sessionIdPtr);
(*callbackPtr)(res);
res->addCookie("JSESSIONID", session_id);
callback(res);
}
}
@ -285,9 +284,12 @@ void HttpControllersRouter::doControllerHandler(const CtrlBinderPtr &ctrlBinderP
}
if (needSetJsessionid)
{
//make a copy
newResp = std::make_shared<HttpResponseImpl>(*std::dynamic_pointer_cast<HttpResponseImpl>(resp));
newResp->setExpiredTime(-1); //make it temporary
if (resp->expiredTime() >= 0)
{
//make a copy
newResp = std::make_shared<HttpResponseImpl>(*std::dynamic_pointer_cast<HttpResponseImpl>(resp));
newResp->setExpiredTime(-1); //make it temporary
}
newResp->addCookie("JSESSIONID", session_id);
}
callback(newResp);

4
lib/src/HttpControllersRouter.h
View File

@ -36,9 +36,9 @@ class HttpControllersRouter : public trantor::NonCopyable
const std::vector<HttpMethod> &validMethods,
const std::vector<std::string> &filters);
void route(const HttpRequestImplPtr &req,
const std::shared_ptr<std::function<void(const HttpResponsePtr &)>> &callbackPtr,
std::function<void(const HttpResponsePtr &)> &&callback,
bool needSetJsessionid,
const std::shared_ptr<std::string> &sessionIdPtr);
std::string &&session_id);
private:
struct CtrlBinder

36
lib/src/HttpSimpleControllersRouter.cc
View File

@ -64,18 +64,18 @@ void HttpSimpleControllersRouter::registerHttpSimpleController(const std::string
}
}
bool HttpSimpleControllersRouter::route(const HttpRequestImplPtr &req,
const std::shared_ptr<std::function<void(const HttpResponsePtr &)>> &callbackPtr,
void HttpSimpleControllersRouter::route(const HttpRequestImplPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
bool needSetJsessionid,
const std::shared_ptr<std::string> &sessionIdPtr)
std::string &&session_id)
{
std::string pathLower(req->path());
std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), tolower);
std::string pathLower(req->path().length(), 0);
std::transform(req->path().begin(), req->path().end(), pathLower.begin(), tolower);
if (_simpCtrlMap.find(pathLower) != _simpCtrlMap.end())
{
auto &ctrlInfo = _simpCtrlMap[pathLower];
if (ctrlInfo._validMethodsFlags.size() > 0)
if (!ctrlInfo._validMethodsFlags.empty())
{
assert(ctrlInfo._validMethodsFlags.size() > req->method());
if (ctrlInfo._validMethodsFlags[req->method()] == 0)
@ -83,24 +83,26 @@ bool HttpSimpleControllersRouter::route(const HttpRequestImplPtr &req,
//Invalid Http Method
auto res = drogon::HttpResponse::newHttpResponse();
res->setStatusCode(HttpResponse::k405MethodNotAllowed);
(*callbackPtr)(res);
return true;
callback(res);
return;
}
}
auto &filters = ctrlInfo.filtersName;
if (!filters.empty())
{
auto sessionIdPtr = std::make_shared<std::string>(std::move(session_id));
auto callbackPtr = std::make_shared<std::function<void(const HttpResponsePtr &)>>(std::move(callback));
_appImpl.doFilters(filters, req, callbackPtr, needSetJsessionid, sessionIdPtr, [=, pathLower = std::move(pathLower)]() mutable {
doControllerHandler(std::move(pathLower), req, std::move(*callbackPtr), needSetJsessionid, std::move(*sessionIdPtr));
});
}
else
{
doControllerHandler(std::move(pathLower), req, std::move(*callbackPtr), needSetJsessionid, std::move(*sessionIdPtr));
doControllerHandler(std::move(pathLower), req, std::move(callback), needSetJsessionid, std::move(session_id));
}
return true;
return;
}
return false;
_httpCtrlsRouter.route(req, std::move(callback), needSetJsessionid, std::move(session_id));
}
void HttpSimpleControllersRouter::doControllerHandler(std::string &&pathLower,
@ -146,7 +148,7 @@ void HttpSimpleControllersRouter::doControllerHandler(std::string &&pathLower,
}
else
{
controller->asyncHandleHttpRequest(req, [callback = std::move(callback), this, pathLower = std::move(pathLower), needSetJsessionid, session_id = std::move(session_id)](const HttpResponsePtr &resp) {
controller->asyncHandleHttpRequest(req, [=, callback = std::move(callback), pathLower = std::move(pathLower), session_id = std::move(session_id)](const HttpResponsePtr &resp) {
auto newResp = resp;
if (resp->expiredTime() >= 0)
{
@ -160,12 +162,14 @@ void HttpSimpleControllersRouter::doControllerHandler(std::string &&pathLower,
}
if (needSetJsessionid)
{
//make a copy
newResp = std::make_shared<HttpResponseImpl>(*std::dynamic_pointer_cast<HttpResponseImpl>(resp));
newResp->setExpiredTime(-1); //make it temporary
if (resp->expiredTime() >= 0)
{
//make a copy
newResp = std::make_shared<HttpResponseImpl>(*std::dynamic_pointer_cast<HttpResponseImpl>(resp));
newResp->setExpiredTime(-1); //make it temporary
}
newResp->addCookie("JSESSIONID", session_id);
}
callback(newResp);
});
}

12
lib/src/HttpSimpleControllersRouter.h
View File

@ -27,20 +27,24 @@
namespace drogon
{
class HttpAppFrameworkImpl;
class HttpControllersRouter;
class HttpSimpleControllersRouter : public trantor::NonCopyable
{
public:
HttpSimpleControllersRouter(HttpAppFrameworkImpl &app) : _appImpl(app) {}
HttpSimpleControllersRouter(HttpAppFrameworkImpl &app, HttpControllersRouter &httpCtrlRouter)
: _appImpl(app),
_httpCtrlsRouter(httpCtrlRouter) {}
void registerHttpSimpleController(const std::string &pathName,
const std::string &ctrlName,
const std::vector<any> &filtersAndMethods);
bool route(const HttpRequestImplPtr &req,
const std::shared_ptr<std::function<void(const HttpResponsePtr &)>> &callbackPtr,
void route(const HttpRequestImplPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
bool needSetJsessionid,
const std::shared_ptr<std::string> &sessionIdPtr);
std::string &&session_id);
private:
HttpAppFrameworkImpl &_appImpl;
HttpControllersRouter &_httpCtrlsRouter;
struct SimpleControllerRouterItem
{
std::string controllerName;

7
lib/src/WebsocketControllersRouter.cc
View File

@ -39,7 +39,7 @@ void WebsocketControllersRouter::registerWebSocketController(const std::string &
}
void WebsocketControllersRouter::route(const HttpRequestImplPtr &req,
const std::shared_ptr<std::function<void(const HttpResponsePtr &)>> &callbackPtr,
std::function<void(const HttpResponsePtr &)> &&callback,
const WebSocketConnectionPtr &wsConnPtr)
{
std::string wsKey = req->getHeaderBy("sec-websocket-key");
@ -62,20 +62,21 @@ void WebsocketControllersRouter::route(const HttpRequestImplPtr &req,
{
if (!filtersName.empty())
{
auto callbackPtr = std::make_shared<std::function<void(const HttpResponsePtr &)>>(std::move(callback));
_appImpl.doFilters(filtersName, req, callbackPtr, false, nullptr, [=]() mutable {
doControllerHandler(ctrlPtr, wsKey, req, *callbackPtr, wsConnPtr);
});
}
else
{
doControllerHandler(ctrlPtr, wsKey, req, *callbackPtr, wsConnPtr);
doControllerHandler(ctrlPtr, wsKey, req, callback, wsConnPtr);
}
return;
}
}
auto resp = drogon::HttpResponse::newNotFoundResponse();
resp->setCloseConnection(true);
(*callbackPtr)(resp);
callback(resp);
}
void WebsocketControllersRouter::doControllerHandler(const WebSocketControllerBasePtr &ctrlPtr,

2
lib/src/WebsocketControllersRouter.h
View File

@ -34,7 +34,7 @@ class WebsocketControllersRouter : public trantor::NonCopyable
const std::string &ctrlName,
const std::vector<std::string> &filters);
void route(const HttpRequestImplPtr &req,
const std::shared_ptr<std::function<void(const HttpResponsePtr &)>> &callbackPtr,
std::function<void(const HttpResponsePtr &)> &&callback,
const WebSocketConnectionPtr &wsConnPtr);
private: