sharpetronics/drogon
1
0
Fork 0
mirror of https://github.com/drogonframework/drogon.git synced 2025-09-18 00:01:01 -04:00
Code Issues Projects Releases Wiki Activity

Reduce dependencies between declarations (#212)

Browse Source
This commit is contained in:
An Tao 2019-08-15 20:59:16 +08:00 committed by GitHub
parent 673d74191e
commit da285cd4d2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
67 changed files with 472 additions and 414 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
CMakeLists.txt
View File

@ -104,7 +104,6 @@ set(DROGON_SOURCES lib/src/AOPAdvice.cc
lib/src/HttpServer.cc
lib/src/HttpSimpleControllersRouter.cc
lib/src/HttpUtils.cc
lib/src/HttpViewBase.cc
lib/src/HttpViewData.cc
lib/src/IntranetIpFilter.cc
lib/src/ListenerManager.cc
@ -247,7 +246,7 @@ else()
set(DROGON_SOURCES ${DROGON_SOURCES} lib/src/DbClientManagerSkipped.cc)
endif()
add_library(drogon ${DROGON_SOURCES})
add_library(drogon STATIC ${DROGON_SOURCES})
set_property(TARGET drogon PROPERTY CXX_STANDARD ${DROGON_CXX_STANDARD})
set_property(TARGET drogon PROPERTY CXX_STANDARD_REQUIRED ON)
@ -343,7 +342,6 @@ set(DROGON_HEADERS
lib/inc/drogon/HttpResponse.h
lib/inc/drogon/HttpSimpleController.h
lib/inc/drogon/HttpTypes.h
lib/inc/drogon/HttpViewBase.h
lib/inc/drogon/HttpViewData.h
lib/inc/drogon/IntranetIpFilter.h
lib/inc/drogon/LocalHostFilter.h
@ -355,7 +353,8 @@ set(DROGON_HEADERS
lib/inc/drogon/WebSocketConnection.h
lib/inc/drogon/WebSocketController.h
lib/inc/drogon/drogon.h
lib/inc/drogon/version.h)
lib/inc/drogon/version.h
lib/inc/drogon/drogon_callbacks.h)
install(FILES ${DROGON_HEADERS} DESTINATION ${INSTALL_INCLUDE_DIR}/drogon)
set(ORM_HEADERS

6
lib/inc/drogon/CacheMap.h
View File

@ -14,17 +14,17 @@
#pragma once
#include <assert.h>
#include <trantor/net/EventLoop.h>
#include <trantor/utils/Logger.h>
#include <atomic>
#include <deque>
#include <map>
#include <mutex>
#include <set>
#include <trantor/net/EventLoop.h>
#include <trantor/utils/Logger.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <assert.h>
#define WHEELS_NUM 4
#define BUCKET_NUM_PER_WHEEL 200

6
lib/inc/drogon/DrClassMap.h
View File

@ -14,16 +14,16 @@
#pragma once
#include <cxxabi.h>
#include <drogon/utils/ClassTraits.h>
#include <trantor/utils/Logger.h>
#include <functional>
#include <memory>
#include <mutex>
#include <stdio.h>
#include <thread>
#include <trantor/utils/Logger.h>
#include <unordered_map>
#include <vector>
#include <cxxabi.h>
#include <stdio.h>
namespace drogon
{

15
lib/inc/drogon/HttpAppFramework.h
View File

@ -14,22 +14,21 @@
#pragma once
#include <drogon/orm/DbClient.h>
#include <drogon/utils/HttpConstraint.h>
#include <drogon/CacheMap.h>
#include <drogon/DrObject.h>
#include <drogon/HttpBinder.h>
#include <drogon/HttpClient.h>
#include <drogon/HttpFilter.h>
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/IntranetIpFilter.h>
#include <drogon/LocalHostFilter.h>
#include <drogon/MultiPart.h>
#include <drogon/NotFound.h>
#include <drogon/plugins/Plugin.h>
#include <drogon/drogon_callbacks.h>
#include <drogon/utils/ClassTraits.h>
#include <drogon/utils/Utilities.h>
#include <drogon/plugins/Plugin.h>
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/orm/DbClient.h>
#include <trantor/net/Resolver.h>
#include <trantor/net/EventLoop.h>
#include <trantor/utils/NonCopyable.h>
@ -57,8 +56,6 @@ std::string getGitCommit();
class HttpControllerBase;
class HttpSimpleControllerBase;
class WebSocketControllerBase;
typedef std::function<void(const HttpResponsePtr &)> AdviceCallback;
typedef std::function<void()> AdviceChainCallback;
class HttpAppFramework : public trantor::NonCopyable
{
@ -105,7 +102,7 @@ class HttpAppFramework : public trantor::NonCopyable
* User can run some timer tasks or other tasks in this loop;
* This method can be call in any thread.
*/
virtual trantor::EventLoop *getLoop() = 0;
virtual trantor::EventLoop *getLoop() const = 0;
/// Set custom 404 page
/**

2
lib/inc/drogon/HttpBinder.h
View File

@ -16,8 +16,6 @@
#include <drogon/DrClassMap.h>
#include <drogon/DrObject.h>
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/utils/FunctionTraits.h>
#include <list>
#include <memory>

11
lib/inc/drogon/HttpClient.h
View File

@ -14,20 +14,19 @@
*/
#pragma once
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/HttpTypes.h>
#include <drogon/drogon_callbacks.h>
#include <drogon/HttpResponse.h>
#include <drogon/HttpRequest.h>
#include <trantor/utils/NonCopyable.h>
#include <trantor/net/EventLoop.h>
#include <functional>
#include <memory>
#include <trantor/net/EventLoop.h>
#include <trantor/utils/NonCopyable.h>
namespace drogon
{
class HttpClient;
typedef std::shared_ptr<HttpClient> HttpClientPtr;
typedef std::function<void(ReqResult, const HttpResponsePtr &)> HttpReqCallback;
/// Asynchronous http client
/**
* HttpClient implementation object uses the HttpAppFramework's event loop by

3
lib/inc/drogon/HttpFilter.h
View File

@ -15,6 +15,7 @@
#pragma once
#include <drogon/DrObject.h>
#include <drogon/drogon_callbacks.h>
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <memory>
@ -23,8 +24,6 @@
namespace drogon
{
typedef std::function<void(const HttpResponsePtr &)> FilterCallback;
typedef std::function<void()> FilterChainCallback;
class HttpFilterBase : public virtual DrObjectBase
{
public:

4
lib/inc/drogon/HttpRequest.h
View File

@ -19,10 +19,10 @@
#include <drogon/Session.h>
#include <drogon/UploadFile.h>
#include <json/json.h>
#include <memory>
#include <string>
#include <trantor/net/InetAddress.h>
#include <trantor/utils/Date.h>
#include <memory>
#include <string>
#include <unordered_map>
namespace drogon

2
lib/inc/drogon/HttpResponse.h
View File

@ -135,7 +135,7 @@ class HttpResponse
/// If there is no the cookie, the @param defaultCookie is retured.
virtual const Cookie &getCookie(
const std::string &key,
const Cookie &defaultCookie = Cookie()) const = 0;
const Cookie &defaultCookie = Cookie{}) const = 0;
/// Get all cookies.
virtual const std::unordered_map<std::string, Cookie> &cookies() const = 0;

2
lib/inc/drogon/HttpSimpleController.h
View File

@ -17,9 +17,9 @@
#include <drogon/DrObject.h>
#include <drogon/utils/HttpConstraint.h>
#include <drogon/HttpAppFramework.h>
#include <trantor/utils/Logger.h>
#include <iostream>
#include <string>
#include <trantor/utils/Logger.h>
#include <vector>
#define PATH_LIST_BEGIN \
static void initPathRouting() \

10
lib/inc/drogon/HttpTypes.h
View File

@ -118,4 +118,14 @@ enum class ReqResult
Timeout
};
enum class WebSocketMessageType
{
Text,
Binary,
Ping,
Pong,
Close,
Unknown
};
} // namespace drogon

38
lib/inc/drogon/HttpViewBase.h
View File

@ -1,38 +0,0 @@
/**
*
* HttpViewBase.h
* An Tao
*
* Copyright 2018, An Tao. All rights reserved.
* https://github.com/an-tao/drogon
* Use of this source code is governed by a MIT license
* that can be found in the License file.
*
* Drogon
*
*/
#pragma once
#include <drogon/DrObject.h>
#include <drogon/HttpResponse.h>
#include <drogon/HttpViewData.h>
#include <map>
#include <string>
namespace drogon
{
class HttpViewBase : virtual public DrObjectBase
{
public:
static HttpResponsePtr genHttpResponse(std::string viewName,
const HttpViewData &data);
virtual ~HttpViewBase(){};
HttpViewBase(){};
protected:
virtual HttpResponsePtr genHttpResponse(const HttpViewData &) = 0;
};
} // namespace drogon

5
lib/inc/drogon/HttpViewData.h
View File

@ -18,12 +18,11 @@
#include <drogon/utils/any.h>
#include <trantor/utils/Logger.h>
#include <trantor/utils/MsgBuffer.h>
#include <sstream>
#include <stdarg.h>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <stdarg.h>
#include <stdio.h>
namespace drogon
{

2
lib/inc/drogon/MultiPart.h
View File

@ -14,8 +14,6 @@
#pragma once
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <map>
#include <string>
#include <vector>

1
lib/inc/drogon/WebSocketClient.h
View File

@ -17,6 +17,7 @@
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/WebSocketConnection.h>
#include <drogon/HttpTypes.h>
#include <functional>
#include <memory>
#include <string>

11
lib/inc/drogon/WebSocketConnection.h
View File

@ -16,20 +16,11 @@
#include <memory>
#include <string>
#include <drogon/HttpTypes.h>
#include <trantor/net/InetAddress.h>
#include <trantor/utils/NonCopyable.h>
namespace drogon
{
enum class WebSocketMessageType
{
Text,
Binary,
Ping,
Pong,
Close,
Unknown
};
class WebSocketConnection
{
public:

5
lib/inc/drogon/WebSocketController.h
View File

@ -17,12 +17,13 @@
#include <drogon/DrObject.h>
#include <drogon/HttpAppFramework.h>
#include <drogon/WebSocketConnection.h>
#include <drogon/HttpTypes.h>
#include <trantor/utils/Logger.h>
#include <iostream>
#include <memory>
#include <string>
#include <trantor/net/TcpConnection.h>
#include <trantor/utils/Logger.h>
#include <vector>
#define WS_PATH_LIST_BEGIN \
static std::vector<std::pair<std::string, std::vector<std::string>>> \
__paths() \

8
lib/inc/drogon/drogon.h
View File

@ -24,4 +24,10 @@
#include <drogon/HttpClient.h>
#include <drogon/HttpController.h>
#include <drogon/HttpSimpleController.h>
#include <drogon/utils/Utilities.h>
#include <drogon/utils/Utilities.h>
#include <drogon/MultiPart.h>
#include <drogon/plugins/Plugin.h>
#include <drogon/Cookie.h>
#include <drogon/Session.h>
#include <drogon/UploadFile.h>
#include <drogon/orm/DbClient.h>

30
lib/inc/drogon/drogon_callbacks.h Normal file
View File

@ -0,0 +1,30 @@
/**
*
* drogon_callbacks.h
* An Tao
*
* Copyright 2018, An Tao. All rights reserved.
* https://github.com/an-tao/drogon
* Use of this source code is governed by a MIT license
* that can be found in the License file.
*
* Drogon
*
*/
#pragma once
#include <drogon/HttpTypes.h>
#include <functional>
#include <memory>
namespace drogon
{
class HttpResponse;
typedef std::shared_ptr<HttpResponse> HttpResponsePtr;
typedef std::function<void(const HttpResponsePtr &)> AdviceCallback;
typedef std::function<void()> AdviceChainCallback;
typedef std::function<void(const HttpResponsePtr &)> FilterCallback;
typedef std::function<void()> FilterChainCallback;
typedef std::function<void(ReqResult, const HttpResponsePtr &)> HttpReqCallback;
} // namespace drogon

2
lib/src/AOPAdvice.cc
View File

@ -1,5 +1,7 @@
#include "AOPAdvice.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
namespace drogon
{

8
lib/src/AOPAdvice.h
View File

@ -13,8 +13,12 @@
*/
#pragma once
#include "HttpRequestImpl.h"
#include <drogon/HttpAppFramework.h>
#include "impl_forwards.h"
#include <drogon/drogon_callbacks.h>
#include <deque>
#include <functional>
#include <vector>
#include <memory>
namespace drogon
{

4
lib/src/ConfigLoader.cc
View File

@ -13,8 +13,8 @@
*/
#include "ConfigLoader.h"
#include "HttpAppFrameworkImpl.h"
#include <drogon/config.h>
#include <drogon/HttpAppFramework.h>
#include <fstream>
#include <iostream>
#include <sstream>
@ -130,7 +130,7 @@ static void loadLogSetting(const Json::Value &log)
{
auto baseName = log.get("logfile_base_name", "").asString();
auto logSize = log.get("log_size_limit", 100000000).asUInt64();
drogon::app().setLogPath(logPath, baseName, logSize);
HttpAppFrameworkImpl::instance().setLogPath(logPath, baseName, logSize);
}
auto logLevel = log.get("log_level", "DEBUG").asString();
if (logLevel == "TRACE")

9
lib/src/DrTemplateBase.cc
View File

@ -31,11 +31,6 @@ std::shared_ptr<DrTemplateBase> DrTemplateBase::newTemplate(
templateName = templateName.substr(0, pos);
}
}
auto obj = std::shared_ptr<DrObjectBase>(
drogon::DrClassMap::newObject(templateName));
if (obj)
{
return std::dynamic_pointer_cast<DrTemplateBase>(obj);
}
return nullptr;
return std::dynamic_pointer_cast<DrTemplateBase>(
drogon::DrClassMap::getSingleInstance(templateName));
}

1
lib/src/FiltersFunction.cc
View File

@ -13,6 +13,7 @@
*/
#include "FiltersFunction.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include <drogon/HttpFilter.h>

3
lib/src/FiltersFunction.h
View File

@ -14,8 +14,7 @@
#pragma once
#include "HttpRequestImpl.h"
#include <drogon/HttpFilter.h>
#include "impl_forwards.h"
#include <memory>
#include <string>
#include <vector>

175
lib/src/HttpAppFrameworkImpl.cc
View File

@ -13,9 +13,23 @@
*/
#include "HttpAppFrameworkImpl.h"
#include "HttpRequestImpl.h"
#include "HttpClientImpl.h"
#include "HttpResponseImpl.h"
#include "WebSocketConnectionImpl.h"
#include "StaticFileRouter.h"
#include "HttpSimpleControllersRouter.h"
#include "HttpControllersRouter.h"
#include "WebsocketControllersRouter.h"
#include "HttpClientImpl.h"
#include "AOPAdvice.h"
#include "ConfigLoader.h"
#include "HttpServer.h"
#include "PluginsManager.h"
#include "ListenerManager.h"
#include "SharedLibManager.h"
#include "SessionManager.h"
#include "DbClientManager.h"
#include <drogon/config.h>
#include <algorithm>
#include <drogon/version.h>
@ -47,6 +61,29 @@
using namespace drogon;
using namespace std::placeholders;
HttpAppFrameworkImpl::HttpAppFrameworkImpl()
: _staticFileRouterPtr(new (StaticFileRouter)),
_httpCtrlsRouterPtr(new HttpControllersRouter(*_staticFileRouterPtr,
_postRoutingAdvices,
_postRoutingObservers,
_preHandlingAdvices,
_preHandlingObservers,
_postHandlingAdvices)),
_httpSimpleCtrlsRouterPtr(
new HttpSimpleControllersRouter(*_httpCtrlsRouterPtr,
_postRoutingAdvices,
_postRoutingObservers,
_preHandlingAdvices,
_preHandlingObservers,
_postHandlingAdvices)),
_websockCtrlsRouterPtr(new WebsocketControllersRouter),
_listenerManagerPtr(new ListenerManager),
_pluginsManagerPtr(new PluginsManager),
_dbClientManagerPtr(new orm::DbClientManager),
_uploadPath(_rootPath + "uploads"),
_connectionNum(0)
{
}
/// Make sure that the main event loop is initialized in the main thread.
drogon::InitBeforeMainFunction drogon::HttpAppFrameworkImpl::_initFirst([]() {
HttpAppFrameworkImpl::instance().getLoop()->runInLoop([]() {
@ -98,7 +135,24 @@ static void godaemon(void)
return;
}
HttpAppFrameworkImpl::~HttpAppFrameworkImpl() noexcept
{
// Destroy the following objects before _loop destruction
_sharedLibManagerPtr.reset();
_sessionManagerPtr.reset();
}
void HttpAppFrameworkImpl::setStaticFilesCacheTime(int cacheTime)
{
_staticFileRouterPtr->setStaticFilesCacheTime(cacheTime);
}
int HttpAppFrameworkImpl::staticFilesCacheTime() const
{
return _staticFileRouterPtr->staticFilesCacheTime();
}
void HttpAppFrameworkImpl::setGzipStatic(bool useGzipStatic)
{
_staticFileRouterPtr->setGzipStatic(useGzipStatic);
}
void HttpAppFrameworkImpl::enableDynamicViewsLoading(
const std::vector<std::string> &libPaths)
{
@ -125,7 +179,7 @@ void HttpAppFrameworkImpl::enableDynamicViewsLoading(
}
void HttpAppFrameworkImpl::setFileTypes(const std::vector<std::string> &types)
{
_staticFileRouter.setFileTypes(types);
_staticFileRouterPtr->setFileTypes(types);
}
void HttpAppFrameworkImpl::registerWebSocketController(
@ -134,9 +188,9 @@ void HttpAppFrameworkImpl::registerWebSocketController(
const std::vector<std::string> &filters)
{
assert(!_running);
_websockCtrlsRouter.registerWebSocketController(pathName,
ctrlName,
filters);
_websockCtrlsRouterPtr->registerWebSocketController(pathName,
ctrlName,
filters);
}
void HttpAppFrameworkImpl::registerHttpSimpleController(
const std::string &pathName,
@ -144,9 +198,9 @@ void HttpAppFrameworkImpl::registerHttpSimpleController(
const std::vector<internal::HttpConstraint> &filtersAndMethods)
{
assert(!_running);
_httpSimpleCtrlsRouter.registerHttpSimpleController(pathName,
ctrlName,
filtersAndMethods);
_httpSimpleCtrlsRouterPtr->registerHttpSimpleController(pathName,
ctrlName,
filtersAndMethods);
}
void HttpAppFrameworkImpl::registerHttpController(
@ -159,7 +213,7 @@ void HttpAppFrameworkImpl::registerHttpController(
assert(!pathPattern.empty());
assert(binder);
assert(!_running);
_httpCtrlsRouter.addHttpPath(
_httpCtrlsRouterPtr->addHttpPath(
pathPattern, binder, validMethods, filters, handlerName);
}
void HttpAppFrameworkImpl::setThreadNum(size_t threadNum)
@ -167,6 +221,19 @@ void HttpAppFrameworkImpl::setThreadNum(size_t threadNum)
assert(threadNum >= 1);
_threadNum = threadNum;
}
PluginBase *HttpAppFrameworkImpl::getPlugin(const std::string &name)
{
return _pluginsManagerPtr->getPlugin(name);
}
void HttpAppFrameworkImpl::addListener(const std::string &ip,
uint16_t port,
bool useSSL,
const std::string &certFile,
const std::string &keyFile)
{
assert(!_running);
_listenerManagerPtr->addListener(ip, port, useSSL, certFile, keyFile);
}
void HttpAppFrameworkImpl::setMaxConnectionNum(size_t maxConnections)
{
_maxConnectionNum = maxConnections;
@ -297,7 +364,7 @@ void HttpAppFrameworkImpl::run()
new SharedLibManager(getLoop(), _libFilePaths));
}
// Create all listeners.
auto ioLoops = _listenerManager.createListeners(
auto ioLoops = _listenerManagerPtr->createListeners(
std::bind(&HttpAppFrameworkImpl::onAsyncRequest, this, _1, _2),
std::bind(&HttpAppFrameworkImpl::onNewWebsockRequest, this, _1, _2, _3),
std::bind(&HttpAppFrameworkImpl::onConnection, this, _1),
@ -308,12 +375,12 @@ void HttpAppFrameworkImpl::run()
// A fast database client instance should be created in the main event loop,
// so put the main loop into ioLoops.
ioLoops.push_back(getLoop());
_dbClientManager.createDbClients(ioLoops);
_dbClientManagerPtr->createDbClients(ioLoops);
ioLoops.pop_back();
_httpCtrlsRouter.init(ioLoops);
_httpSimpleCtrlsRouter.init(ioLoops);
_staticFileRouter.init();
_websockCtrlsRouter.init();
_httpCtrlsRouterPtr->init(ioLoops);
_httpSimpleCtrlsRouterPtr->init(ioLoops);
_staticFileRouterPtr->init();
_websockCtrlsRouterPtr->init();
if (_useSession)
{
@ -325,14 +392,14 @@ void HttpAppFrameworkImpl::run()
const auto &pluginConfig = _jsonConfig["plugins"];
if (!pluginConfig.isNull())
{
_pluginsManager.initializeAllPlugins(pluginConfig,
[](PluginBase *plugin) {
// TODO: new plugin
});
_pluginsManagerPtr->initializeAllPlugins(pluginConfig,
[](PluginBase *plugin) {
// TODO: new plugin
});
}
// Let listener event loops run when everything is ready.
_listenerManager.startListening();
_listenerManagerPtr->startListening();
getLoop()->loop();
}
@ -425,16 +492,16 @@ void HttpAppFrameworkImpl::onNewWebsockRequest(
std::function<void(const HttpResponsePtr &)> &&callback,
const WebSocketConnectionImplPtr &wsConnPtr)
{
_websockCtrlsRouter.route(req, std::move(callback), wsConnPtr);
_websockCtrlsRouterPtr->route(req, std::move(callback), wsConnPtr);
}
std::vector<std::tuple<std::string, HttpMethod, std::string>>
HttpAppFrameworkImpl::getHandlersInfo() const
{
auto ret = _httpSimpleCtrlsRouter.getHandlersInfo();
auto v = _httpCtrlsRouter.getHandlersInfo();
auto ret = _httpSimpleCtrlsRouterPtr->getHandlersInfo();
auto v = _httpCtrlsRouterPtr->getHandlersInfo();
ret.insert(ret.end(), v.begin(), v.end());
v = _websockCtrlsRouter.getHandlersInfo();
v = _websockCtrlsRouterPtr->getHandlersInfo();
ret.insert(ret.end(), v.begin(), v.end());
return ret;
}
@ -479,10 +546,10 @@ void HttpAppFrameworkImpl::onAsyncRequest(
}
if (_preRoutingAdvices.empty())
{
_httpSimpleCtrlsRouter.route(req,
std::move(callback),
needSetJsessionid,
std::move(sessionId));
_httpSimpleCtrlsRouterPtr->route(req,
std::move(callback),
needSetJsessionid,
std::move(sessionId));
}
else
{
@ -507,15 +574,15 @@ void HttpAppFrameworkImpl::onAsyncRequest(
}
}),
[this, callbackPtr, req, needSetJsessionid, sessionIdPtr]() {
_httpSimpleCtrlsRouter.route(req,
std::move(*callbackPtr),
needSetJsessionid,
std::move(*sessionIdPtr));
_httpSimpleCtrlsRouterPtr->route(req,
std::move(*callbackPtr),
needSetJsessionid,
std::move(*sessionIdPtr));
});
}
}
trantor::EventLoop *HttpAppFrameworkImpl::getLoop()
trantor::EventLoop *HttpAppFrameworkImpl::getLoop() const
{
static trantor::EventLoop loop;
return &loop;
@ -529,7 +596,15 @@ HttpAppFramework &HttpAppFramework::instance()
HttpAppFramework::~HttpAppFramework()
{
}
void HttpAppFrameworkImpl::forward(
const HttpRequestPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
const std::string &hostString)
{
forward(std::dynamic_pointer_cast<HttpRequestImpl>(req),
std::move(callback),
hostString);
}
void HttpAppFrameworkImpl::forward(
const HttpRequestImplPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
@ -581,3 +656,35 @@ void HttpAppFrameworkImpl::forward(
});
}
}
orm::DbClientPtr HttpAppFrameworkImpl::getDbClient(const std::string &name)
{
return _dbClientManagerPtr->getDbClient(name);
}
orm::DbClientPtr HttpAppFrameworkImpl::getFastDbClient(const std::string &name)
{
return _dbClientManagerPtr->getFastDbClient(name);
}
void HttpAppFrameworkImpl::createDbClient(const std::string &dbType,
const std::string &host,
const u_short port,
const std::string &databaseName,
const std::string &userName,
const std::string &password,
const size_t connectionNum,
const std::string &filename,
const std::string &name,
const bool isFast)
{
assert(!_running);
_dbClientManagerPtr->createDbClient(dbType,
host,
port,
databaseName,
userName,
password,
connectionNum,
filename,
name,
isFast);
}

127
lib/src/HttpAppFrameworkImpl.h
View File

@ -14,30 +14,15 @@
#pragma once
#include "DbClientManager.h"
#include "HttpClientImpl.h"
#include "HttpControllersRouter.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "HttpSimpleControllersRouter.h"
#include "PluginsManager.h"
#include "ListenerManager.h"
#include "SharedLibManager.h"
#include "WebSocketConnectionImpl.h"
#include "WebsocketControllersRouter.h"
#include "StaticFileRouter.h"
#include "SessionManager.h"
#include <drogon/config.h>
#include "impl_forwards.h"
#include <drogon/HttpAppFramework.h>
#include <drogon/HttpSimpleController.h>
#include <trantor/net/EventLoop.h>
#include <trantor/net/EventLoopThread.h>
#include <drogon/config.h>
#include <memory>
#include <mutex>
#include <regex>
#include <string>
#include <vector>
#include <functional>
namespace drogon
{
@ -51,43 +36,19 @@ struct InitBeforeMainFunction
class HttpAppFrameworkImpl : public HttpAppFramework
{
public:
HttpAppFrameworkImpl()
: _httpCtrlsRouter(_staticFileRouter,
_postRoutingAdvices,
_postRoutingObservers,
_preHandlingAdvices,
_preHandlingObservers,
_postHandlingAdvices),
_httpSimpleCtrlsRouter(_httpCtrlsRouter,
_postRoutingAdvices,
_postRoutingObservers,
_preHandlingAdvices,
_preHandlingObservers,
_postHandlingAdvices),
_uploadPath(_rootPath + "uploads"),
_connectionNum(0)
{
}
HttpAppFrameworkImpl();
virtual const Json::Value &getCustomConfig() const override
{
return _jsonConfig["custom_config"];
}
virtual PluginBase *getPlugin(const std::string &name) override
{
return _pluginsManager.getPlugin(name);
}
virtual PluginBase *getPlugin(const std::string &name) override;
virtual void addListener(const std::string &ip,
uint16_t port,
bool useSSL = false,
const std::string &certFile = "",
const std::string &keyFile = "") override
{
assert(!_running);
_listenerManager.addListener(ip, port, useSSL, certFile, keyFile);
}
const std::string &keyFile = "") override;
virtual void setThreadNum(size_t threadNum) override;
virtual size_t getThreadNum() const override
{
@ -121,12 +82,7 @@ class HttpAppFrameworkImpl : public HttpAppFramework
virtual void forward(
const HttpRequestPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
const std::string &hostString = "") override
{
forward(std::dynamic_pointer_cast<HttpRequestImpl>(req),
std::move(callback),
hostString);
}
const std::string &hostString = "") override;
void forward(const HttpRequestImplPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
@ -214,8 +170,7 @@ class HttpAppFrameworkImpl : public HttpAppFramework
virtual const std::shared_ptr<trantor::Resolver> &getResolver()
const override
{
static auto resolver =
trantor::Resolver::newResolver(drogon::app().getLoop());
static auto resolver = trantor::Resolver::newResolver(getLoop());
return resolver;
}
virtual void setUploadPath(const std::string &uploadPath) override;
@ -249,14 +204,8 @@ class HttpAppFrameworkImpl : public HttpAppFramework
{
return _useGzip;
}
virtual void setStaticFilesCacheTime(int cacheTime) override
{
_staticFileRouter.setStaticFilesCacheTime(cacheTime);
}
virtual int staticFilesCacheTime() const override
{
return _staticFileRouter.staticFilesCacheTime();
}
virtual void setStaticFilesCacheTime(int cacheTime) override;
virtual int staticFilesCacheTime() const override;
virtual void setIdleConnectionTimeout(size_t timeout) override
{
_idleConnectionTimeout = timeout;
@ -269,10 +218,7 @@ class HttpAppFrameworkImpl : public HttpAppFramework
{
_pipeliningRequestsNumber = number;
}
virtual void setGzipStatic(bool useGzipStatic) override
{
_staticFileRouter.setGzipStatic(useGzipStatic);
}
virtual void setGzipStatic(bool useGzipStatic) override;
virtual void setClientMaxBodySize(size_t maxSize) override
{
_clientMaxBodySize = maxSize;
@ -317,19 +263,13 @@ class HttpAppFrameworkImpl : public HttpAppFramework
return _pipeliningRequestsNumber;
}
virtual ~HttpAppFrameworkImpl() noexcept
{
// Destroy the following objects before _loop destruction
_sharedLibManagerPtr.reset();
_sessionManagerPtr.reset();
}
virtual ~HttpAppFrameworkImpl() noexcept;
virtual bool isRunning() override
{
return _running;
}
virtual trantor::EventLoop *getLoop() override;
virtual trantor::EventLoop *getLoop() const override;
virtual void quit() override
{
@ -366,15 +306,9 @@ class HttpAppFrameworkImpl : public HttpAppFramework
}
virtual orm::DbClientPtr getDbClient(
const std::string &name = "default") override
{
return _dbClientManager.getDbClient(name);
}
const std::string &name = "default") override;
virtual orm::DbClientPtr getFastDbClient(
const std::string &name = "default") override
{
return _dbClientManager.getFastDbClient(name);
}
const std::string &name = "default") override;
virtual void createDbClient(const std::string &dbType,
const std::string &host,
const u_short port,
@ -384,20 +318,7 @@ class HttpAppFrameworkImpl : public HttpAppFramework
const size_t connectionNum = 1,
const std::string &filename = "",
const std::string &name = "default",
const bool isFast = false) override
{
assert(!_running);
_dbClientManager.createDbClient(dbType,
host,
port,
databaseName,
userName,
password,
connectionNum,
filename,
name,
isFast);
}
const bool isFast = false) override;
inline static HttpAppFrameworkImpl &instance()
{
@ -435,14 +356,18 @@ class HttpAppFrameworkImpl : public HttpAppFramework
size_t _sessionTimeout = 0;
size_t _idleConnectionTimeout = 60;
bool _useSession = false;
ListenerManager _listenerManager;
std::string _serverHeader =
"Server: drogon/" + drogon::getVersion() + "\r\n";
HttpControllersRouter _httpCtrlsRouter;
HttpSimpleControllersRouter _httpSimpleCtrlsRouter;
StaticFileRouter _staticFileRouter;
WebsocketControllersRouter _websockCtrlsRouter;
const std::unique_ptr<StaticFileRouter> _staticFileRouterPtr;
const std::unique_ptr<HttpControllersRouter> _httpCtrlsRouterPtr;
const std::unique_ptr<HttpSimpleControllersRouter>
_httpSimpleCtrlsRouterPtr;
const std::unique_ptr<WebsocketControllersRouter> _websockCtrlsRouterPtr;
const std::unique_ptr<ListenerManager> _listenerManagerPtr;
const std::unique_ptr<PluginsManager> _pluginsManagerPtr;
const std::unique_ptr<orm::DbClientManager> _dbClientManagerPtr;
std::string _rootPath = "./";
std::string _uploadPath;
@ -478,9 +403,7 @@ class HttpAppFrameworkImpl : public HttpAppFramework
std::unique_ptr<SessionManager> _sessionManagerPtr;
// Json::Value _customConfig;
Json::Value _jsonConfig;
PluginsManager _pluginsManager;
HttpResponsePtr _custom404;
orm::DbClientManager _dbClientManager;
static InitBeforeMainFunction _initFirst;
bool _enableServerHeader = true;
bool _enableDateHeader = true;

11
lib/src/HttpClientImpl.cc
View File

@ -13,9 +13,10 @@
*/
#include "HttpClientImpl.h"
#include "HttpAppFrameworkImpl.h"
#include "HttpResponseImpl.h"
#include "HttpRequestImpl.h"
#include "HttpResponseParser.h"
#include "HttpAppFrameworkImpl.h"
#include <drogon/config.h>
#include <algorithm>
#include <stdlib.h>
@ -441,7 +442,7 @@ HttpClientPtr HttpClient::newHttpClient(const std::string &ip,
{
bool isIpv6 = ip.find(":") == std::string::npos ? false : true;
return std::make_shared<HttpClientImpl>(
loop == nullptr ? app().getLoop() : loop,
loop == nullptr ? HttpAppFrameworkImpl::instance().getLoop() : loop,
trantor::InetAddress(ip, port, isIpv6),
useSSL);
}
@ -449,9 +450,9 @@ HttpClientPtr HttpClient::newHttpClient(const std::string &ip,
HttpClientPtr HttpClient::newHttpClient(const std::string &hostString,
trantor::EventLoop *loop)
{
return std::make_shared<HttpClientImpl>(loop == nullptr ? app().getLoop()
: loop,
hostString);
return std::make_shared<HttpClientImpl>(
loop == nullptr ? HttpAppFrameworkImpl::instance().getLoop() : loop,
hostString);
}
void HttpClientImpl::onError(ReqResult result)

8
lib/src/HttpClientImpl.h
View File

@ -14,15 +14,15 @@
#pragma once
#include "HttpResponseImpl.h"
#include "impl_forwards.h"
#include <drogon/HttpClient.h>
#include <drogon/Cookie.h>
#include <mutex>
#include <queue>
#include <vector>
#include <trantor/net/EventLoop.h>
#include <trantor/net/TcpClient.h>
#include <trantor/net/Resolver.h>
#include <mutex>
#include <queue>
#include <vector>
namespace drogon
{

8
lib/src/HttpControllersRouter.cc
View File

@ -13,10 +13,12 @@
*/
#include "HttpControllersRouter.h"
#include "HttpAppFrameworkImpl.h"
#include "FiltersFunction.h"
#include "AOPAdvice.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "StaticFileRouter.h"
#include "HttpAppFrameworkImpl.h"
#include "FiltersFunction.h"
using namespace drogon;
@ -30,7 +32,7 @@ void HttpControllersRouter::doWhenNoHandlerFound(
!HttpAppFrameworkImpl::instance().getHomePage().empty())
{
req->setPath("/" + HttpAppFrameworkImpl::instance().getHomePage());
drogon::app().forward(req, std::move(callback));
HttpAppFrameworkImpl::instance().forward(req, std::move(callback));
return;
}
_fileRouter.route(req,

13
lib/src/HttpControllersRouter.h
View File

@ -13,20 +13,19 @@
*/
#pragma once
#include "AOPAdvice.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "StaticFileRouter.h"
#include <atomic>
#include "impl_forwards.h"
#include <drogon/drogon_callbacks.h>
#include <drogon/HttpBinder.h>
#include <drogon/HttpFilter.h>
#include <trantor/utils/NonCopyable.h>
#include <atomic>
#include <memory>
#include <mutex>
#include <regex>
#include <string>
#include <trantor/utils/NonCopyable.h>
#include <vector>
#include <map>
#include <unordered_map>
namespace drogon
{

1
lib/src/HttpFileUploadRequest.cc
View File

@ -13,6 +13,7 @@
*/
#include "HttpFileUploadRequest.h"
#include <drogon/UploadFile.h>
#include <drogon/utils/Utilities.h>
using namespace drogon;

7
lib/src/HttpRequestImpl.h
View File

@ -18,21 +18,18 @@
#include "CacheFile.h"
#include <drogon/utils/Utilities.h>
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/utils/Utilities.h>
#include <trantor/net/EventLoop.h>
#include <trantor/net/InetAddress.h>
#include <trantor/utils/Logger.h>
#include <trantor/utils/MsgBuffer.h>
#include <trantor/utils/NonCopyable.h>
#include <algorithm>
#include <assert.h>
#include <stdio.h>
#include <string>
#include <thread>
#include <unordered_map>
#include <assert.h>
#include <stdio.h>
namespace drogon
{

7
lib/src/HttpRequestParser.cc
View File

@ -15,6 +15,7 @@
#include "HttpRequestParser.h"
#include "HttpAppFrameworkImpl.h"
#include "HttpResponseImpl.h"
#include "HttpRequestImpl.h"
#include "HttpUtils.h"
#include <drogon/HttpTypes.h>
#include <iostream>
@ -82,7 +83,11 @@ bool HttpRequestParser::processRequestLine(const char *begin, const char *end)
}
return succeed;
}
void HttpRequestParser::reset()
{
_state = HttpRequestParseState_ExpectMethod;
_request.reset(new HttpRequestImpl(_loop));
}
// Return false if any error
bool HttpRequestParser::parseRequest(MsgBuffer *buf)
{

11
lib/src/HttpRequestParser.h
View File

@ -14,9 +14,8 @@
#pragma once
#include "HttpRequestImpl.h"
#include "WebSocketConnectionImpl.h"
#include <drogon/HttpResponse.h>
#include "impl_forwards.h"
#include <drogon/HttpTypes.h>
#include <trantor/utils/NonCopyable.h>
#include <trantor/net/TcpConnection.h>
#include <trantor/utils/MsgBuffer.h>
@ -47,11 +46,7 @@ class HttpRequestParser : public trantor::NonCopyable
return _state == HttpRequestParseState_GotAll;
}
void reset()
{
_state = HttpRequestParseState_ExpectMethod;
_request.reset(new HttpRequestImpl(_loop));
}
void reset();
const HttpRequestImplPtr &requestImpl() const
{

22
lib/src/HttpResponseImpl.cc
View File

@ -15,8 +15,6 @@
#include "HttpResponseImpl.h"
#include "HttpAppFrameworkImpl.h"
#include "HttpUtils.h"
#include <drogon/HttpAppFramework.h>
#include <drogon/HttpViewBase.h>
#include <drogon/HttpViewData.h>
#include <fstream>
#include <memory>
@ -27,6 +25,24 @@
using namespace trantor;
using namespace drogon;
namespace drogon
{
static HttpResponsePtr genHttpResponse(std::string viewName,
const HttpViewData &data)
{
auto templ = DrTemplateBase::newTemplate(viewName);
if (templ)
{
auto res = HttpResponse::newHttpResponse();
res->setStatusCode(k200OK);
res->setContentTypeCode(CT_TEXT_HTML);
res->setBody(templ->genText(data));
return res;
}
return drogon::HttpResponse::newNotFoundResponse();
}
} // namespace drogon
HttpResponsePtr HttpResponse::newHttpResponse()
{
auto res = std::make_shared<HttpResponseImpl>(k200OK, CT_TEXT_HTML);
@ -78,7 +94,7 @@ HttpResponsePtr HttpResponse::newRedirectionResponse(
HttpResponsePtr HttpResponse::newHttpViewResponse(const std::string &viewName,
const HttpViewData &data)
{
return HttpViewBase::genHttpResponse(viewName, data);
return genHttpResponse(viewName, data);
}
HttpResponsePtr HttpResponse::newFileResponse(

8
lib/src/HttpResponseImpl.h
View File

@ -15,15 +15,15 @@
#pragma once
#include "HttpUtils.h"
#include <atomic>
#include <drogon/HttpResponse.h>
#include <drogon/utils/Utilities.h>
#include <memory>
#include <mutex>
#include <string>
#include <trantor/net/InetAddress.h>
#include <trantor/utils/Date.h>
#include <trantor/utils/MsgBuffer.h>
#include <memory>
#include <mutex>
#include <string>
#include <atomic>
#include <unordered_map>
namespace drogon

9
lib/src/HttpResponseParser.cc
View File

@ -13,11 +13,20 @@
*/
#include "HttpResponseParser.h"
#include "HttpResponseImpl.h"
#include <iostream>
#include <trantor/utils/Logger.h>
#include <trantor/utils/MsgBuffer.h>
using namespace trantor;
using namespace drogon;
void HttpResponseParser::reset()
{
_state = HttpResponseParseState::kExpectResponseLine;
_response.reset(new HttpResponseImpl);
_parseResponseForHeadMethod = false;
}
HttpResponseParser::HttpResponseParser()
: _state(HttpResponseParseState::kExpectResponseLine),
_response(new HttpResponseImpl)

10
lib/src/HttpResponseParser.h
View File

@ -14,8 +14,7 @@
#pragma once
#include "HttpResponseImpl.h"
#include <drogon/WebSocketConnection.h>
#include "impl_forwards.h"
#include <trantor/utils/NonCopyable.h>
#include <trantor/net/TcpConnection.h>
#include <trantor/utils/MsgBuffer.h>
@ -56,12 +55,7 @@ class HttpResponseParser : public trantor::NonCopyable
_parseResponseForHeadMethod = true;
}
void reset()
{
_state = HttpResponseParseState::kExpectResponseLine;
_response.reset(new HttpResponseImpl);
_parseResponseForHeadMethod = false;
}
void reset();
const HttpResponseImplPtr &responseImpl() const
{

4
lib/src/HttpServer.cc
View File

@ -13,9 +13,11 @@
*/
#include "HttpServer.h"
#include "HttpRequestImpl.h"
#include "HttpRequestParser.h"
#include "HttpAppFrameworkImpl.h"
#include "HttpResponseImpl.h"
#include "WebSocketConnectionImpl.h"
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/utils/Utilities.h>

16
lib/src/HttpServer.h
View File

@ -14,30 +14,16 @@
#pragma once
#include "HttpRequestImpl.h"
#include "WebSocketConnectionImpl.h"
#include "HttpRequestParser.h"
#include <drogon/WebSocketController.h>
#include "impl_forwards.h"
#include <trantor/net/TcpServer.h>
#include <trantor/net/callbacks.h>
#include <trantor/utils/NonCopyable.h>
#include <functional>
#include <string>
#include <vector>
namespace drogon
{
class HttpRequest;
class HttpResponse;
typedef std::shared_ptr<HttpRequest> HttpRequestPtr;
typedef std::function<void(const HttpRequestImplPtr &,
std::function<void(const HttpResponsePtr &)> &&)>
HttpAsyncCallback;
typedef std::function<void(const HttpRequestImplPtr &,
std::function<void(const HttpResponsePtr &)> &&,
const WebSocketConnectionImplPtr &)>
WebSocketNewAsyncCallback;
class HttpServer : trantor::NonCopyable
{
public:

5
lib/src/HttpSimpleControllersRouter.cc
View File

@ -13,9 +13,12 @@
*/
#include "HttpSimpleControllersRouter.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "AOPAdvice.h"
#include "HttpControllersRouter.h"
#include "FiltersFunction.h"
#include "HttpAppFrameworkImpl.h"
#include <drogon/HttpSimpleController.h>
#include <drogon/utils/HttpConstraint.h>
using namespace drogon;

13
lib/src/HttpSimpleControllersRouter.h
View File

@ -13,21 +13,20 @@
*/
#pragma once
#include "HttpControllersRouter.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "impl_forwards.h"
#include <drogon/drogon_callbacks.h>
#include <drogon/utils/HttpConstraint.h>
#include <trantor/utils/NonCopyable.h>
#include <atomic>
#include <drogon/HttpBinder.h>
#include <drogon/HttpFilter.h>
#include <drogon/HttpSimpleController.h>
#include <memory>
#include <mutex>
#include <regex>
#include <shared_mutex>
#include <string>
#include <trantor/utils/NonCopyable.h>
#include <vector>
#include <map>
#include <unordered_map>
namespace drogon
{

1
lib/src/HttpUtils.h
View File

@ -16,7 +16,6 @@
#include <drogon/utils/string_view.h>
#include <drogon/HttpTypes.h>
#include <drogon/WebSocketConnection.h>
#include <string>
#include <trantor/utils/MsgBuffer.h>

46
lib/src/HttpViewBase.cc
View File

@ -1,46 +0,0 @@
/**
*
* HttpViewBase.cc
* An Tao
*
* Copyright 2018, An Tao. All rights reserved.
* https://github.com/an-tao/drogon
* Use of this source code is governed by a MIT license
* that can be found in the License file.
*
* Drogon
*
*/
#include <drogon/DrClassMap.h>
#include <drogon/HttpViewBase.h>
#include <drogon/DrTemplateBase.h>
#include <memory>
#include <trantor/utils/Logger.h>
using namespace drogon;
HttpResponsePtr HttpViewBase::genHttpResponse(std::string viewName,
const HttpViewData &data)
{
LOG_TRACE << "http view name=" << viewName;
auto pos = viewName.find(".csp");
if (pos != std::string::npos)
{
if (pos == viewName.length() - 4)
{
viewName = viewName.substr(0, pos);
}
}
auto templ = DrTemplateBase::newTemplate(viewName);
if (templ)
{
auto res = HttpResponse::newHttpResponse();
res->setStatusCode(k200OK);
res->setContentTypeCode(CT_TEXT_HTML);
res->setBody(templ->genText(data));
return res;
}
return drogon::HttpResponse::newNotFoundResponse();
}

6
lib/src/ListenerManager.cc
View File

@ -13,6 +13,8 @@
*/
#include "ListenerManager.h"
#include "HttpServer.h"
#include "HttpAppFrameworkImpl.h"
#include <drogon/config.h>
#include <trantor/utils/Logger.h>
#include <fcntl.h>
@ -87,7 +89,7 @@ std::vector<trantor::EventLoop *> ListenerManager::createListeners(
{
DrogonFileLocker lock;
// Check whether the port is in use.
TcpServer server(app().getLoop(),
TcpServer server(HttpAppFrameworkImpl::instance().getLoop(),
InetAddress(ip, listener._port, isIpv6),
"drogonPortTest",
true,
@ -183,4 +185,4 @@ void ListenerManager::startListening()
{
loopThread->run();
}
}
}

5
lib/src/ListenerManager.h
View File

@ -14,9 +14,10 @@
#pragma once
#include "HttpServer.h"
#include "impl_forwards.h"
#include <trantor/utils/NonCopyable.h>
#include <trantor/net/EventLoopThread.h>
#include <trantor/net/EventLoopThreadPool.h>
#include <trantor/net/callbacks.h>
#include <string>
#include <vector>
#include <memory>

8
lib/src/MultiPart.cc
View File

@ -14,7 +14,7 @@
#include "HttpRequestImpl.h"
#include "HttpUtils.h"
#include <drogon/HttpAppFramework.h>
#include "HttpAppFrameworkImpl.h"
#include <drogon/MultiPart.h>
#include <drogon/utils/Utilities.h>
#include <drogon/config.h>
@ -155,7 +155,7 @@ int HttpFile::save(const std::string &path) const
}
else
{
auto &uploadPath = drogon::app().getUploadPath();
auto &uploadPath = HttpAppFrameworkImpl::instance().getUploadPath();
if (uploadPath[uploadPath.length() - 1] == '/')
tmpPath = uploadPath + path;
else
@ -176,7 +176,7 @@ int HttpFile::save(const std::string &path) const
}
int HttpFile::save() const
{
return save(drogon::app().getUploadPath());
return save(HttpAppFrameworkImpl::instance().getUploadPath());
}
int HttpFile::saveAs(const std::string &filename) const
{
@ -191,7 +191,7 @@ int HttpFile::saveAs(const std::string &filename) const
}
else
{
auto &uploadPath = drogon::app().getUploadPath();
auto &uploadPath = HttpAppFrameworkImpl::instance().getUploadPath();
if (uploadPath[uploadPath.length() - 1] == '/')
pathAndFileName = uploadPath + filename;
else

5
lib/src/SessionManager.h
View File

@ -14,11 +14,10 @@
#pragma once
#include <trantor/utils/NonCopyable.h>
#include <trantor/net/EventLoop.h>
#include <drogon/Session.h>
#include <drogon/CacheMap.h>
#include <trantor/utils/NonCopyable.h>
#include <trantor/net/EventLoop.h>
#include <memory>
#include <string>
#include <mutex>

17
lib/src/StaticFileRouter.cc
View File

@ -13,6 +13,9 @@
*/
#include "StaticFileRouter.h"
#include "HttpAppFrameworkImpl.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include <fstream>
#include <iostream>
@ -23,6 +26,17 @@
using namespace drogon;
void StaticFileRouter::init()
{
_responseCachingMap =
std::unique_ptr<CacheMap<std::string, HttpResponsePtr>>(
new CacheMap<std::string, HttpResponsePtr>(
HttpAppFrameworkImpl::instance().getLoop(),
1.0,
4,
50)); // Max timeout up to about 70 days;
}
void StaticFileRouter::route(
const HttpRequestImplPtr &req,
std::function<void(const HttpResponsePtr &)> &&callback,
@ -38,7 +52,8 @@ void StaticFileRouter::route(
if (_fileTypeSet.find(filetype) != _fileTypeSet.end())
{
// LOG_INFO << "file query!" << path;
std::string filePath = drogon::app().getDocumentRoot() + path;
std::string filePath =
HttpAppFrameworkImpl::instance().getDocumentRoot() + path;
if (filePath.find("/../") != std::string::npos)
{
// Downloading files from the parent folder is forbidden.

15
lib/src/StaticFileRouter.h
View File

@ -14,10 +14,8 @@
#pragma once
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "impl_forwards.h"
#include <drogon/CacheMap.h>
#include <drogon/HttpAppFramework.h>
#include <functional>
#include <set>
#include <string>
@ -45,16 +43,7 @@ class StaticFileRouter
{
_gzipStaticFlag = useGzipStatic;
}
void init()
{
_responseCachingMap =
std::unique_ptr<CacheMap<std::string, HttpResponsePtr>>(
new CacheMap<std::string, HttpResponsePtr>(
drogon::app().getLoop(),
1.0,
4,
50)); // Max timeout up to about 70 days;
}
void init();
private:
std::set<std::string> _fileTypeSet = {"html",

13
lib/src/WebSocketClientImpl.cc
View File

@ -13,10 +13,12 @@
*/
#include "WebSocketClientImpl.h"
#include "HttpResponseImpl.h"
#include "HttpRequestImpl.h"
#include "HttpResponseParser.h"
#include "HttpUtils.h"
#include <drogon/HttpAppFramework.h>
#include "WebSocketConnectionImpl.h"
#include "HttpAppFrameworkImpl.h"
#include <drogon/utils/Utilities.h>
#include <drogon/config.h>
#include <trantor/net/InetAddress.h>
@ -32,6 +34,10 @@ using namespace trantor;
WebSocketClientImpl::~WebSocketClientImpl()
{
}
WebSocketConnectionPtr WebSocketClientImpl::getConnection()
{
return _websockConnPtr;
}
void WebSocketClientImpl::createTcpClient()
{
LOG_TRACE << "New TcpClient," << _server.toIpPort();
@ -399,7 +405,7 @@ WebSocketClientPtr WebSocketClient::newWebSocketClient(const std::string &ip,
{
bool isIpv6 = ip.find(":") == std::string::npos ? false : true;
return std::make_shared<WebSocketClientImpl>(
loop == nullptr ? app().getLoop() : loop,
loop == nullptr ? HttpAppFrameworkImpl::instance().getLoop() : loop,
trantor::InetAddress(ip, port, isIpv6),
useSSL);
}
@ -409,5 +415,6 @@ WebSocketClientPtr WebSocketClient::newWebSocketClient(
trantor::EventLoop *loop)
{
return std::make_shared<WebSocketClientImpl>(
loop == nullptr ? app().getLoop() : loop, hostString);
loop == nullptr ? HttpAppFrameworkImpl::instance().getLoop() : loop,
hostString);
}

7
lib/src/WebSocketClientImpl.h
View File

@ -14,7 +14,7 @@
#pragma once
#include "WebSocketConnectionImpl.h"
#include "impl_forwards.h"
#include <drogon/WebSocketClient.h>
#include <trantor/net/EventLoop.h>
#include <trantor/net/TcpClient.h>
@ -30,10 +30,7 @@ class WebSocketClientImpl
public std::enable_shared_from_this<WebSocketClientImpl>
{
public:
virtual WebSocketConnectionPtr getConnection() override
{
return _websockConnPtr;
}
virtual WebSocketConnectionPtr getConnection() override;
virtual void setMessageHandler(
const std::function<void(std::string &&message,

1
lib/src/WebSocketConnectionImpl.cc
View File

@ -15,7 +15,6 @@
#include "WebSocketConnectionImpl.h"
#include "HttpAppFrameworkImpl.h"
#include <thread>
#include <trantor/net/TcpConnection.h>
#include <trantor/net/inner/TcpConnectionImpl.h>
using namespace drogon;

3
lib/src/WebSocketConnectionImpl.h
View File

@ -14,9 +14,10 @@
#pragma once
#include "impl_forwards.h"
#include <drogon/WebSocketConnection.h>
#include <drogon/WebSocketController.h>
#include <trantor/utils/NonCopyable.h>
#include <trantor/net/TcpConnection.h>
namespace drogon
{

6
lib/src/WebsocketControllersRouter.cc
View File

@ -13,8 +13,12 @@
*/
#include "WebsocketControllersRouter.h"
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "WebSocketConnectionImpl.h"
#include "FiltersFunction.h"
#include "HttpAppFrameworkImpl.h"
#include <drogon/HttpFilter.h>
#include <drogon/WebSocketController.h>
#include <drogon/config.h>
#ifdef OpenSSL_FOUND
#include <openssl/sha.h>

11
lib/src/WebsocketControllersRouter.h
View File

@ -13,17 +13,16 @@
*/
#pragma once
#include "HttpRequestImpl.h"
#include "HttpResponseImpl.h"
#include "WebSocketConnectionImpl.h"
#include <drogon/HttpFilter.h>
#include <drogon/WebSocketController.h>
#include "impl_forwards.h"
#include <drogon/HttpTypes.h>
#include <trantor/utils/NonCopyable.h>
#include <memory>
#include <mutex>
#include <regex>
#include <string>
#include <trantor/utils/NonCopyable.h>
#include <vector>
#include <unordered_map>
namespace drogon
{

64
lib/src/impl_forwards.h Normal file
View File

@ -0,0 +1,64 @@
#pragma once
#include <memory>
#include <functional>
namespace drogon
{
class HttpRequest;
typedef std::shared_ptr<HttpRequest> HttpRequestPtr;
class HttpResponse;
typedef std::shared_ptr<HttpResponse> HttpResponsePtr;
class Cookie;
class Session;
typedef std::shared_ptr<Session> SessionPtr;
class UploadFile;
class WebSocketControllerBase;
typedef std::shared_ptr<WebSocketControllerBase> WebSocketControllerBasePtr;
class HttpFilterBase;
typedef std::shared_ptr<HttpFilterBase> HttpFilterBasePtr;
class HttpSimpleControllerBase;
typedef std::shared_ptr<HttpSimpleControllerBase> HttpSimpleControllerBasePtr;
class HttpRequestImpl;
typedef std::shared_ptr<HttpRequestImpl> HttpRequestImplPtr;
class HttpResponseImpl;
typedef std::shared_ptr<HttpResponseImpl> HttpResponseImplPtr;
class WebSocketConnectionImpl;
typedef std::shared_ptr<WebSocketConnectionImpl> WebSocketConnectionImplPtr;
class HttpRequestParser;
class StaticFileRouter;
class HttpControllersRouter;
class WebsocketControllersRouter;
class HttpSimpleControllersRouter;
class PluginsManager;
class ListenerManager;
class SharedLibManager;
class SessionManager;
class HttpServer;
namespace orm
{
class DbClient;
typedef std::shared_ptr<DbClient> DbClientPtr;
class DbClientManager;
} // namespace orm
} // namespace drogon
namespace trantor
{
class EventLoop;
class TcpConnection;
typedef std::shared_ptr<TcpConnection> TcpConnectionPtr;
class Resolver;
} // namespace trantor
namespace drogon
{
typedef std::function<void(const HttpRequestImplPtr &,
std::function<void(const HttpResponsePtr &)> &&)>
HttpAsyncCallback;
typedef std::function<void(const HttpRequestImplPtr &,
std::function<void(const HttpResponsePtr &)> &&,
const WebSocketConnectionImplPtr &)>
WebSocketNewAsyncCallback;
} // namespace drogon

3
orm_lib/src/DbClientImpl.h
View File

@ -15,14 +15,13 @@
#pragma once
#include "DbConnection.h"
#include <drogon/HttpTypes.h>
#include <drogon/orm/DbClient.h>
#include <trantor/net/EventLoopThreadPool.h>
#include <functional>
#include <list>
#include <memory>
#include <string>
#include <thread>
#include <trantor/net/EventLoopThreadPool.h>
#include <unordered_set>
namespace drogon

3
orm_lib/src/DbClientLockFree.h
View File

@ -15,14 +15,13 @@
#pragma once
#include "DbConnection.h"
#include <drogon/HttpTypes.h>
#include <drogon/orm/DbClient.h>
#include <trantor/net/EventLoopThreadPool.h>
#include <functional>
#include <memory>
#include <queue>
#include <string>
#include <thread>
#include <trantor/net/EventLoopThreadPool.h>
#include <unordered_set>
namespace drogon

6
orm_lib/src/DbConnection.h
View File

@ -16,15 +16,15 @@
#include <drogon/config.h>
#include <drogon/orm/DbClient.h>
#include <trantor/net/EventLoop.h>
#include <trantor/net/inner/Channel.h>
#include <trantor/utils/NonCopyable.h>
#include <functional>
#include <iostream>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <string>
#include <trantor/net/EventLoop.h>
#include <trantor/net/inner/Channel.h>
#include <trantor/utils/NonCopyable.h>
namespace drogon
{

6
orm_lib/src/mysql_impl/MysqlConnection.h
View File

@ -16,14 +16,14 @@
#include "../DbConnection.h"
#include <drogon/orm/DbClient.h>
#include <trantor/net/EventLoop.h>
#include <trantor/net/inner/Channel.h>
#include <trantor/utils/NonCopyable.h>
#include <functional>
#include <iostream>
#include <memory>
#include <mysql.h>
#include <string>
#include <trantor/net/EventLoop.h>
#include <trantor/net/inner/Channel.h>
#include <trantor/utils/NonCopyable.h>
namespace drogon
{

2
orm_lib/src/mysql_impl/MysqlResultImpl.h
View File

@ -14,11 +14,11 @@
#pragma once
#include "../ResultImpl.h"
#include <trantor/utils/Logger.h>
#include <algorithm>
#include <memory>
#include <mysql.h>
#include <string>
#include <trantor/utils/Logger.h>
#include <unordered_map>
#include <vector>

3
orm_lib/src/postgresql_impl/PgBatchConnection.cc
View File

@ -294,7 +294,8 @@ void PgConnection::sendBatchedSql()
{
auto sql = cmd->_sql;
std::transform(sql.begin(), sql.end(), sql.begin(), tolower);
if (sql.find("update") != std::string::npos ||
if (sql.length() > 1024 ||
sql.find("update") != std::string::npos ||
sql.find("insert") != std::string::npos ||
sql.find("delete") != std::string::npos ||
sql.find("drop") != std::string::npos ||

1
orm_lib/src/sqlite3_impl/Sqlite3Connection.h
View File

@ -16,7 +16,6 @@
#include "../DbConnection.h"
#include "Sqlite3ResultImpl.h"
#include <drogon/HttpTypes.h>
#include <drogon/orm/DbClient.h>
#include <functional>
#include <iostream>

2
orm_lib/src/sqlite3_impl/Sqlite3ResultImpl.h
View File

@ -16,8 +16,8 @@
#include "../ResultImpl.h"
#include <memory>
#include <sqlite3.h>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

2
trantor

@ -1 +1 @@
Subproject commit 2274a3d6560cadba27e3d838d88c784a97dcf880
Subproject commit 70b8d01d32642a8e96045e5489d8aa287682d7d4