blob: e4b3b472837404de8854ee8eaf5faf9b415156a3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
#include <seastar/core/reactor.hh>
#include <seastar/testing/test_case.hh>
#include <seastar/testing/test_runner.hh>
#include <seastar/net/ip.hh>
using namespace seastar;
using namespace net;
SEASTAR_TEST_CASE(test_connection_attempt_is_shutdown) {
ipv4_addr server_addr("172.16.0.1");
auto unconn = make_socket();
auto f = unconn
.connect(make_ipv4_address(server_addr))
.then_wrapped([] (auto&& f) {
try {
f.get();
BOOST_REQUIRE(false);
} catch (...) {}
});
unconn.shutdown();
return f.finally([unconn = std::move(unconn)] {});
}
SEASTAR_TEST_CASE(test_unconnected_socket_shutsdown_established_connection) {
// Use a random port to reduce chance of conflict.
// TODO: retry a few times on failure.
std::default_random_engine& rnd = testing::local_random_engine;
auto distr = std::uniform_int_distribution<uint16_t>(12000, 65000);
auto sa = make_ipv4_address({"127.0.0.1", distr(rnd)});
return do_with(engine().net().listen(sa, listen_options()), [sa] (auto& listener) {
auto f = listener.accept();
auto unconn = make_socket();
auto connf = unconn.connect(sa);
return connf.then([unconn = std::move(unconn)] (auto&& conn) mutable {
unconn.shutdown();
return do_with(std::move(conn), [] (auto& conn) {
return do_with(conn.output(1), [] (auto& out) {
return out.write("ping").then_wrapped([] (auto&& f) {
try {
f.get();
BOOST_REQUIRE(false);
} catch (...) {}
});
});
});
}).finally([f = std::move(f)] () mutable {
return std::move(f);
});
});
}
SEASTAR_TEST_CASE(test_accept_after_abort) {
std::default_random_engine& rnd = testing::local_random_engine;
auto distr = std::uniform_int_distribution<uint16_t>(12000, 65000);
auto sa = make_ipv4_address({"127.0.0.1", distr(rnd)});
return do_with(seastar::server_socket(engine().net().listen(sa, listen_options())), [] (auto& listener) {
using ftype = future<accept_result>;
promise<ftype> p;
future<ftype> done = p.get_future();
auto f = listener.accept().then_wrapped([&listener, p = std::move(p)] (auto f) mutable {
f.ignore_ready_future();
p.set_value(listener.accept());
});
listener.abort_accept();
return done.then([] (ftype f) {
return f.then_wrapped([] (ftype f) {
BOOST_REQUIRE(f.failed());
if (f.available()) {
f.ignore_ready_future();
}
});
});
});
}
|
