TEST_F(StreamingRpcTest, server_send_data_before_run_done) {
const int N = 10000;
SendNAfterAcceptStream after_accept(N);
brpc::StreamOptions opt;
opt.max_buf_size = -1;
brpc::Server server;
MyServiceWithStream service(opt, &after_accept);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
OrderedInputHandler handler;
brpc::StreamOptions request_stream_options;
brpc::StreamId request_stream;
brpc::Controller cntl;
request_stream_options.handler = &handler;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
// wait flushing all the pending messages
while (handler._expected_next_value != N) {
usleep(100);
}
ASSERT_EQ(0, brpc::StreamClose(request_stream));
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
ASSERT_EQ(0, handler.idle_times());
}
TEST_F(StreamingRpcTest, idle_timeout) {
HandlerControl hc;
OrderedInputHandler handler(&hc);
hc.block = true;
brpc::StreamOptions opt;
opt.handler = &handler;
opt.idle_timeout_ms = 2;
const int N = 10000;
opt.max_buf_size = sizeof(uint32_t) * N;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::StreamOptions request_stream_options;
request_stream_options.max_buf_size = sizeof(uint32_t) * N;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
usleep(10 * 1000 + 800);
ASSERT_EQ(0, brpc::StreamClose(request_stream));
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
// ASSERT_TRUE(handler.idle_times() >= 4 && handler.idle_times() <= 6)
// << handler.idle_times();
ASSERT_EQ(0, handler._expected_next_value);
}
/*++
StreamCreateFile
Creates a APR file I/O stream.
Arguments:
file - Pointer to a APR file handle.
close - If this argument is true, the APR file handle will be closed when
the stream is closed. If this argument is false, the APR file handle
will remain open when the stream is closed.
pool - Pointer to a memory pool.
Return Values:
If the function succeeds, the return value is a pointer to a STREAM structure.
If the function fails, the return value is null.
--*/
STREAM *
StreamCreateFile(
apr_file_t *file,
bool_t close,
apr_pool_t *pool
)
{
ASSERT(file != NULL);
ASSERT(pool != NULL);
return StreamCreate(file, FileRead, FileWrite, FileFlush,
(close != FALSE) ? FileClose : NULL, pool);
}
TEST_F(StreamingRpcTest, sanity) {
brpc::Server server;
MyServiceWithStream service;
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, NULL));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
usleep(10);
brpc::StreamClose(request_stream);
server.Stop(0);
server.Join();
}
TEST_F(StreamingRpcTest, auto_close_if_host_socket_closed) {
HandlerControl hc;
OrderedInputHandler handler(&hc);
hc.block = true;
brpc::StreamOptions opt;
opt.handler = &handler;
const int N = 10000;
opt.max_buf_size = sizeof(uint32_t) * N;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::StreamOptions request_stream_options;
request_stream_options.max_buf_size = sizeof(uint32_t) * N;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
{
brpc::SocketUniquePtr ptr;
ASSERT_EQ(0, brpc::Socket::Address(request_stream, &ptr));
brpc::Stream* s = (brpc::Stream*)ptr->conn();
ASSERT_TRUE(s->_host_socket != NULL);
s->_host_socket->SetFailed();
}
usleep(100);
butil::IOBuf out;
out.append("test");
ASSERT_EQ(EINVAL, brpc::StreamWrite(request_stream, out));
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
ASSERT_EQ(0, handler.idle_times());
ASSERT_EQ(0, handler._expected_next_value);
}
/*++
StreamCreateTextConsole
Creates a text console I/O stream.
Arguments:
console - Console type.
pool - Pointer to a memory pool.
Return Values:
If the function succeeds, the return value is a pointer to a STREAM structure.
If the function fails, the return value is null.
--*/
STREAM *
StreamCreateTextConsole(
int console,
apr_pool_t *pool
)
{
#ifdef WINDOWS
DWORD type;
HANDLE handle;
ASSERT(pool != NULL);
switch (console) {
case CONSOLE_INPUT:
type = STD_INPUT_HANDLE;
break;
case CONSOLE_OUTPUT:
type = STD_OUTPUT_HANDLE;
break;
case CONSOLE_ERROR:
type = STD_ERROR_HANDLE;
break;
default:
return NULL;
}
// Retrieve standard device handle
handle = GetStdHandle(type);
if (handle == INVALID_HANDLE_VALUE) {
return NULL;
}
// There is no close callback because closing the handle returned
// by GetStdHandle() would close the standard device.
return StreamCreate(handle, TextConsoleRead,
TextConsoleWrite, TextConsoleFlush, NULL, pool);
#else
// TODO: See if there's anything special when writing
// UTF-8 text to stdout/stderr on *nix systems.
return StreamCreateBinaryConsole(console, pool);
#endif // WINDOWS
}
TEST_F(StreamingRpcTest, ping_pong) {
PingPongHandler resh;
brpc::StreamOptions opt;
opt.handler = &resh;
const int N = 10000;
opt.max_buf_size = sizeof(uint32_t) * N;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::StreamOptions request_stream_options;
PingPongHandler reqh;
reqh._expected_next_value = 1;
request_stream_options.handler = &reqh;
request_stream_options.max_buf_size = sizeof(uint32_t) * N;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
int send = 0;
butil::IOBuf out;
out.append(&send, sizeof(send));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out));
usleep(10 * 1000);
ASSERT_EQ(0, brpc::StreamClose(request_stream));
while (!resh.stopped() || !reqh.stopped()) {
usleep(100);
}
ASSERT_FALSE(resh.failed());
ASSERT_FALSE(reqh.failed());
ASSERT_EQ(0, resh.idle_times());
ASSERT_EQ(0, reqh.idle_times());
}
TEST_F(StreamingRpcTest, received_in_order) {
OrderedInputHandler handler;
brpc::StreamOptions opt;
opt.handler = &handler;
opt.messages_in_batch = 100;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::StreamOptions request_stream_options;
request_stream_options.max_buf_size = 0;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
brpc::ScopedStream stream_guard(request_stream);
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream=" << request_stream;
const int N = 10000;
for (int i = 0; i < N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i;
}
ASSERT_EQ(0, brpc::StreamClose(request_stream));
server.Stop(0);
server.Join();
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
ASSERT_EQ(0, handler.idle_times());
ASSERT_EQ(N, handler._expected_next_value);
}
TEST_F(StreamingRpcTest, block) {
HandlerControl hc;
OrderedInputHandler handler(&hc);
hc.block = true;
brpc::StreamOptions opt;
opt.handler = &handler;
const int N = 10000;
opt.max_buf_size = sizeof(uint32_t) * N;
brpc::Server server;
MyServiceWithStream service(opt);
ASSERT_EQ(0, server.AddService(&service, brpc::SERVER_DOESNT_OWN_SERVICE));
ASSERT_EQ(0, server.Start(9007, NULL));
brpc::Channel channel;
ASSERT_EQ(0, channel.Init("127.0.0.1:9007", NULL));
brpc::Controller cntl;
brpc::StreamId request_stream;
brpc::ScopedStream stream_guard(request_stream);
brpc::StreamOptions request_stream_options;
request_stream_options.max_buf_size = sizeof(uint32_t) * N;
ASSERT_EQ(0, StreamCreate(&request_stream, cntl, &request_stream_options));
test::EchoService_Stub stub(&channel);
stub.Echo(&cntl, &request, &response, NULL);
ASSERT_FALSE(cntl.Failed()) << cntl.ErrorText() << " request_stream="
<< request_stream;
for (int i = 0; i < N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i;
}
// sync wait
int dummy = 102030123;
butil::IOBuf out;
out.append(&dummy, sizeof(dummy));
ASSERT_EQ(EAGAIN, brpc::StreamWrite(request_stream, out));
hc.block = false;
ASSERT_EQ(0, brpc::StreamWait(request_stream, NULL));
// wait flushing all the pending messages
while (handler._expected_next_value != N) {
usleep(100);
}
// block hanlder again to test async wait
hc.block = true;
// async wait
for (int i = N; i < N + N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i;
}
out.clear();
out.append(&dummy, sizeof(dummy));
ASSERT_EQ(EAGAIN, brpc::StreamWrite(request_stream, out));
hc.block = false;
std::pair<bool, int> p = std::make_pair(false, 0);
usleep(10);
brpc::StreamWait(request_stream, NULL, on_writable, &p);
while (!p.first) {
usleep(100);
}
ASSERT_EQ(0, p.second);
// wait flushing all the pending messages
while (handler._expected_next_value != N + N) {
usleep(100);
}
usleep(1000);
LOG(INFO) << "Starting block";
hc.block = true;
for (int i = N + N; i < N + N + N; ++i) {
int network = htonl(i);
butil::IOBuf out;
out.append(&network, sizeof(network));
ASSERT_EQ(0, brpc::StreamWrite(request_stream, out)) << "i=" << i - N - N;
}
out.clear();
out.append(&dummy, sizeof(dummy));
ASSERT_EQ(EAGAIN, brpc::StreamWrite(request_stream, out));
timespec duetime = butil::microseconds_from_now(1);
p.first = false;
LOG(INFO) << "Start wait";
brpc::StreamWait(request_stream, &duetime, on_writable, &p);
while (!p.first) {
usleep(100);
}
ASSERT_TRUE(p.first);
EXPECT_EQ(ETIMEDOUT, p.second);
hc.block = false;
ASSERT_EQ(0, brpc::StreamClose(request_stream));
while (!handler.stopped()) {
usleep(100);
}
ASSERT_FALSE(handler.failed());
ASSERT_EQ(0, handler.idle_times());
ASSERT_EQ(N + N + N, handler._expected_next_value);
}
