Skip to content

Commit e11fa11

Browse files
IronsDuIronsDu
committed
update example
1 parent f347d00 commit e11fa11

5 files changed

Lines changed: 156 additions & 126 deletions

File tree

‎README.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -96,8 +96,8 @@ Examples
9696

9797
Users
9898
----------------------------
99+
* [ARK - distributed plugin framework](https://github.com/ArkNX/ARK)
99100
* [Redis proxy](https://github.com/IronsDu/DBProxy)
100-
* [Distributed game server framework](https://github.com/IronsDu/DServerFramework)
101+
* [gayrpc](https://github.com/IronsDu/gayrpc)
101102
* [Joynet - Lua network library](https://github.com/IronsDu/Joynet)
102-
* [HTTP-RPC](https://github.com/IronsDu/http-rpc)
103103
* [grpc-gateway](https://github.com/IronsDu/grpc-gateway)

‎examples/BenchWebsocket.cpp‎

Lines changed: 48 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
#include <brynet/net/http/HttpFormat.h>
1010
#include <brynet/net/http/WebSocketFormat.h>
1111
#include <brynet/utils/packet.h>
12+
#include <brynet/net/Wrapper.h>
1213

1314
using namespace brynet;
1415
using namespace brynet::net;
@@ -51,49 +52,59 @@ int main(int argc, char **argv)
5152
size_t workers = argc > 4 ? std::atoi(argv[4]) : std::thread::hardware_concurrency();
5253

5354
std::cout << "host: " << host << ':' << port << " | connections: " << connections << " | workers: " << workers << std::endl;
54-
55-
auto service = TcpService::Create();
56-
service->startWorkerThread(workers);
57-
58-
for (int i = 0; i < connections; i++)
59-
{
60-
sock fd = brynet::net::base::Connect(false, host, port);
61-
auto socket = TcpSocket::Create(fd, false);
62-
brynet::net::base::SocketNodelay(fd);
6355

64-
auto enterCallback = [host](const TcpConnection::Ptr& session) {
65-
HttpService::setup(session, [host](const HttpSession::Ptr& httpSession) {
66-
HttpRequest request;
67-
request.setMethod(HttpRequest::HTTP_METHOD::HTTP_METHOD_GET);
68-
request.setUrl("/ws");
69-
request.addHeadValue("Host", host);
70-
request.addHeadValue("Upgrade", "websocket");
71-
request.addHeadValue("Connection", "Upgrade");
72-
request.addHeadValue("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
73-
request.addHeadValue("Sec-WebSocket-Version", "13");
56+
auto enterCallback = [host](const HttpSession::Ptr& httpSession) {
57+
HttpRequest request;
58+
request.setMethod(HttpRequest::HTTP_METHOD::HTTP_METHOD_GET);
59+
request.setUrl("/ws");
60+
request.addHeadValue("Host", host);
61+
request.addHeadValue("Upgrade", "websocket");
62+
request.addHeadValue("Connection", "Upgrade");
63+
request.addHeadValue("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
64+
request.addHeadValue("Sec-WebSocket-Version", "13");
7465

75-
std::string requestStr = request.getResult();
76-
httpSession->send(requestStr.c_str(), requestStr.size());
66+
std::string requestStr = request.getResult();
67+
httpSession->send(requestStr.c_str(), requestStr.size());
7768

78-
httpSession->setWSConnected([](const HttpSession::Ptr& session, const HTTPParser&) {
79-
for (int i = 0; i < 200; i++)
80-
{
81-
sendPacket(session, "hello, world!", 13);
82-
}
83-
});
84-
85-
httpSession->setWSCallback([](const HttpSession::Ptr& session,
86-
WebSocketFormat::WebSocketFrameType, const std::string& payload) {
87-
std::cout << payload << std::endl;
69+
httpSession->setWSConnected([](const HttpSession::Ptr& session, const HTTPParser&) {
70+
for (int i = 0; i < 200; i++)
71+
{
8872
sendPacket(session, "hello, world!", 13);
89-
count += 1;
90-
});
73+
}
74+
});
75+
76+
httpSession->setWSCallback([](const HttpSession::Ptr& session,
77+
WebSocketFormat::WebSocketFrameType, const std::string& payload) {
78+
std::cout << payload << std::endl;
79+
sendPacket(session, "hello, world!", 13);
80+
count += 1;
9181
});
92-
};
82+
};
83+
84+
auto service = TcpService::Create();
85+
service->startWorkerThread(workers);
9386

94-
service->addTcpConnection(std::move(socket),
95-
brynet::net::TcpService::AddSocketOption::AddEnterCallback(enterCallback),
96-
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(1024*1024));
87+
auto connector = AsyncConnector::Create();
88+
connector->startWorkerThread();
89+
90+
wrapper::HttpConnectionBuilder connectionBuilder;
91+
connectionBuilder.configureService(service)
92+
.configureConnector(connector)
93+
.configureConnectionOptions({
94+
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(1024 * 1024)
95+
});
96+
97+
for (int i = 0; i < connections; i++)
98+
{
99+
connectionBuilder.configureConnectOptions({
100+
AsyncConnector::ConnectOptions::WithAddr(host, port),
101+
AsyncConnector::ConnectOptions::WithTimeout(std::chrono::seconds(10)),
102+
AsyncConnector::ConnectOptions::AddProcessTcpSocketCallback([](TcpSocket& socket) {
103+
socket.setNodelay();
104+
})
105+
})
106+
.configureEnterCallback(enterCallback)
107+
.asyncConnect();
97108
}
98109

99110
brynet::net::EventLoop mainLoop;

‎examples/PingPongClient.cpp‎

Lines changed: 32 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
#include <brynet/net/SocketLibFunction.h>
55
#include <brynet/net/TCPService.h>
66
#include <brynet/net/Connector.h>
7+
#include <brynet/net/Wrapper.h>
78

89
using namespace brynet;
910
using namespace brynet::net;
@@ -18,42 +19,45 @@ int main(int argc, char **argv)
1819

1920
std::string tmp(atoi(argv[5]), 'a');
2021

21-
auto server = TcpService::Create();
22-
server->startWorkerThread(atoi(argv[3]));
22+
auto service = TcpService::Create();
23+
service->startWorkerThread(atoi(argv[3]));
2324

2425
auto connector = AsyncConnector::Create();
2526
connector->startWorkerThread();
2627

28+
auto enterCallback = [tmp](const TcpConnection::Ptr& session) {
29+
session->setDataCallback([session](const char* buffer, size_t len) {
30+
session->send(buffer, len);
31+
return len;
32+
});
33+
session->send(tmp.c_str(), tmp.size());
34+
};
35+
36+
auto failedCallback = []() {
37+
std::cout << "connect failed" << std::endl;
38+
};
39+
40+
wrapper::ConnectionBuilder connectionBuilder;
41+
connectionBuilder.configureService(service)
42+
.configureConnector(connector)
43+
.configureConnectionOptions({
44+
brynet::net::TcpService::AddSocketOption::AddEnterCallback(enterCallback),
45+
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(1024 * 1024)
46+
});
47+
2748
for (auto i = 0; i < atoi(argv[4]); i++)
2849
{
2950
try
3051
{
31-
auto enterCallback = [server, tmp](TcpSocket::Ptr socket) {
32-
std::cout << "connect success" << std::endl;
33-
socket->setNodelay();
34-
35-
auto enterCallback = [tmp](const TcpConnection::Ptr& session) {
36-
session->setDataCallback([session](const char* buffer, size_t len) {
37-
session->send(buffer, len);
38-
return len;
39-
});
40-
session->send(tmp.c_str(), tmp.size());
41-
};
42-
43-
server->addTcpConnection(std::move(socket),
44-
brynet::net::TcpService::AddSocketOption::AddEnterCallback(enterCallback),
45-
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(1024 * 1024));
46-
};
47-
48-
auto failedCallback = []() {
49-
std::cout << "connect failed" << std::endl;
50-
};
51-
52-
connector->asyncConnect({
53-
AsyncConnector::ConnectOptions::WithAddr(argv[1], atoi(argv[2])),
54-
AsyncConnector::ConnectOptions::WithTimeout(std::chrono::seconds(10)),
55-
AsyncConnector::ConnectOptions::WithCompletedCallback(enterCallback),
56-
AsyncConnector::ConnectOptions::WithFailedCallback(failedCallback)});
52+
connectionBuilder.configureConnectOptions({
53+
AsyncConnector::ConnectOptions::WithAddr(argv[1], atoi(argv[2])),
54+
AsyncConnector::ConnectOptions::WithTimeout(std::chrono::seconds(10)),
55+
AsyncConnector::ConnectOptions::WithFailedCallback(failedCallback),
56+
AsyncConnector::ConnectOptions::AddProcessTcpSocketCallback([](TcpSocket& socket) {
57+
socket.setNodelay();
58+
})
59+
})
60+
.asyncConnect();
5761
}
5862
catch (std::runtime_error& e)
5963
{

‎examples/PingPongServer.cpp‎

Lines changed: 25 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -2,11 +2,9 @@
22
#include <mutex>
33
#include <atomic>
44

5-
#include <brynet/net/SocketLibFunction.h>
65
#include <brynet/net/EventLoop.h>
76
#include <brynet/net/TCPService.h>
8-
#include <brynet/net/ListenThread.h>
9-
#include <brynet/net/Socket.h>
7+
#include <brynet/net/Wrapper.h>
108

119
using namespace brynet;
1210
using namespace brynet::net;
@@ -23,33 +21,39 @@ int main(int argc, char **argv)
2321
exit(-1);
2422
}
2523

26-
auto server = TcpService::Create();
27-
auto listenThread = ListenThread::Create(false, "0.0.0.0", atoi(argv[1]), [=](TcpSocket::Ptr socket) {
28-
socket->setNodelay();
24+
auto service = TcpService::Create();
25+
service->startWorkerThread(atoi(argv[2]));
2926

30-
auto enterCallback = [](const TcpConnection::Ptr& session) {
31-
total_client_num++;
27+
auto enterCallback = [](const TcpConnection::Ptr& session) {
28+
total_client_num++;
3229

33-
session->setDataCallback([session](const char* buffer, size_t len) {
30+
session->setDataCallback([session](const char* buffer, size_t len) {
3431
session->send(buffer, len);
3532
TotalRecvSize += len;
3633
total_packet_num++;
3734
return len;
38-
});
35+
});
3936

40-
session->setDisConnectCallback([](const TcpConnection::Ptr& session) {
37+
session->setDisConnectCallback([](const TcpConnection::Ptr& session) {
4138
total_client_num--;
42-
});
43-
};
39+
});
40+
};
4441

45-
server->addTcpConnection(std::move(socket),
46-
brynet::net::TcpService::AddSocketOption::AddEnterCallback(enterCallback),
47-
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(1024 * 1024));
48-
});
49-
50-
listenThread->startListen();
51-
52-
server->startWorkerThread(atoi(argv[2]));
42+
wrapper::ListenerBuilder listener;
43+
listener.configureService(service)
44+
.configureSocketOptions({
45+
[](TcpSocket& socket) {
46+
socket.setNodelay();
47+
}
48+
})
49+
.configureConnectionOptions({
50+
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(1024 * 1024),
51+
brynet::net::TcpService::AddSocketOption::AddEnterCallback(enterCallback)
52+
})
53+
.configureListen([=](wrapper::BuildListenConfig config) {
54+
config.setAddr(false, "0.0.0.0", atoi(argv[1]));
55+
})
56+
.asyncRun();
5357

5458
EventLoop mainLoop;
5559
while (true)

‎examples/TestPromiseReceive.cpp‎

Lines changed: 49 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
#include <brynet/net/PromiseReceive.h>
99
#include <brynet/net/http/HttpFormat.h>
1010
#include <brynet/net/ListenThread.h>
11+
#include <brynet/net/Wrapper.h>
1112

1213
using namespace brynet;
1314
using namespace brynet::net;
@@ -21,53 +22,63 @@ int main(int argc, char **argv)
2122
exit(-1);
2223
}
2324

24-
auto server = TcpService::Create();
25-
auto listenThread = ListenThread::Create(false, "0.0.0.0", atoi(argv[1]), [=](TcpSocket::Ptr socket) {
26-
socket->setNodelay();
27-
auto enterCallback = [](const TcpConnection::Ptr& session) {
28-
auto promiseReceive = setupPromiseReceive(session);
29-
auto contentLength = std::make_shared<size_t>();
25+
auto service = TcpService::Create();
26+
service->startWorkerThread(atoi(argv[2]));
3027

31-
promiseReceive->receiveUntil("\r\n", [](const char* buffer, size_t len) {
28+
auto enterCallback = [](const TcpConnection::Ptr& session) {
29+
auto promiseReceive = setupPromiseReceive(session);
30+
auto contentLength = std::make_shared<size_t>();
31+
32+
promiseReceive
33+
->receiveUntil("\r\n", [](const char* buffer, size_t len) {
3234
auto headline = std::string(buffer, len);
3335
std::cout << headline << std::endl;
3436
return false;
35-
})->receiveUntil("\r\n", [promiseReceive, contentLength](const char* buffer, size_t len) {
36-
auto headerValue = std::string(buffer, len);
37-
std::cout << headerValue << std::endl;
38-
if (len > 2)
37+
})
38+
->receiveUntil("\r\n", [promiseReceive, contentLength](const char* buffer, size_t len) {
39+
auto headerValue = std::string(buffer, len);
40+
std::cout << headerValue << std::endl;
41+
if (len > 2)
42+
{
43+
const static std::string ContentLenghtFlag = "Content-Length: ";
44+
auto pos = headerValue.find(ContentLenghtFlag);
45+
if (pos != std::string::npos)
3946
{
40-
const static std::string ContentLenghtFlag = "Content-Length: ";
41-
auto pos = headerValue.find(ContentLenghtFlag);
42-
if (pos != std::string::npos)
43-
{
44-
auto lenStr = headerValue.substr(pos + ContentLenghtFlag.size(), headerValue.size());
45-
*contentLength = std::stoi(lenStr);
46-
}
47-
return true;
47+
auto lenStr = headerValue.substr(pos + ContentLenghtFlag.size(), headerValue.size());
48+
*contentLength = std::stoi(lenStr);
4849
}
49-
return false;
50-
})->receive(contentLength, [session](const char* buffer, size_t len) {
51-
HttpResponse response;
52-
response.setStatus(HttpResponse::HTTP_RESPONSE_STATUS::OK);
53-
response.setContentType("text/html; charset=utf-8");
54-
response.setBody("<html>hello world </html>");
55-
56-
auto result = response.getResult();
57-
session->send(result.c_str(), result.size());
58-
session->postShutdown();
50+
return true;
51+
}
52+
return false;
53+
})->receive(contentLength, [session](const char* buffer, size_t len) {
54+
HttpResponse response;
55+
response.setStatus(HttpResponse::HTTP_RESPONSE_STATUS::OK);
56+
response.setContentType("text/html; charset=utf-8");
57+
response.setBody("<html>hello world </html>");
5958

60-
return false;
61-
});
62-
};
63-
server->addTcpConnection(std::move(socket),
64-
brynet::net::TcpService::AddSocketOption::AddEnterCallback(enterCallback),
65-
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(10));
66-
});
59+
auto result = response.getResult();
60+
session->send(result.c_str(), result.size());
61+
session->postShutdown();
6762

68-
listenThread->startListen();
63+
return false;
64+
});
65+
};
6966

70-
server->startWorkerThread(atoi(argv[2]));
67+
wrapper::ListenerBuilder listener;
68+
listener.configureService(service)
69+
.configureSocketOptions({
70+
[](TcpSocket& socket) {
71+
socket.setNodelay();
72+
}
73+
})
74+
.configureConnectionOptions({
75+
brynet::net::TcpService::AddSocketOption::WithMaxRecvBufferSize(1024 * 1024),
76+
brynet::net::TcpService::AddSocketOption::AddEnterCallback(enterCallback)
77+
})
78+
.configureListen([=](wrapper::BuildListenConfig config) {
79+
config.setAddr(false, "0.0.0.0", atoi(argv[1]));
80+
})
81+
.asyncRun();
7182

7283
EventLoop mainLoop;
7384
while (true)

0 commit comments

Comments
 (0)