let socket handle handle more socket stuff

very simple Socket/SimpleSocket
stop using fastos sockets in websocket experimental code
stop using fastos sockets in vbench

3 files changed, 84 insertions, 88 deletions

diff --git a/vespalib/src/tests/net/socket/socket_client.cpp b/vespalib/src/tests/net/socket/socket_client.cpp
index e12fe5330d0..fd4abd2813d 100644
--- a/vespalib/src/tests/net/socket/socket_client.cpp
+++ b/vespalib/src/tests/net/socket/socket_client.cpp
@@ -11,7 +11,7 @@
 
 using namespace vespalib;
 
-vespalib::string read_msg(Socket &socket) {
+vespalib::string read_msg(SocketHandle &socket) {
     vespalib::string msg;
     for (;;) {
         char c;
@@ -27,7 +27,7 @@ vespalib::string read_msg(Socket &socket) {
     }
 }
 
-void write_msg(Socket &socket, const vespalib::string &msg) {
+void write_msg(SocketHandle &socket, const vespalib::string &msg) {
     for (size_t i = 0; i < msg.size(); ++i) {
         ssize_t ret = socket.write(&msg[i], 1);
         if (ret != 1) {
@@ -53,14 +53,15 @@ int main(int argc, char **argv) {
             fprintf(stderr, "  %s\n", addr.spec().c_str());
         }
     }
-    Socket::UP socket = Socket::connect(SocketSpec::from_host_port(host, port));
-    if (!socket->valid()) {
+    SocketHandle socket = SocketSpec::from_host_port(host, port).client_address().connect();
+    if (!socket.valid()) {
         fprintf(stderr, "connect failed\n");
         return 1;
     }
     fprintf(stderr, "connected to: %s (local address: %s)\n",
-            socket->peer_address().spec().c_str(), socket->address().spec().c_str());
-    write_msg(*socket, "hello from client\n");
-    fprintf(stderr, "message from server: '%s'\n", read_msg(*socket).c_str());
+            SocketAddress::peer_address(socket.get()).spec().c_str(),
+            SocketAddress::address_of(socket.get()).spec().c_str());
+    write_msg(socket, "hello from client\n");
+    fprintf(stderr, "message from server: '%s'\n", read_msg(socket).c_str());
     return 0;
 }
diff --git a/vespalib/src/tests/net/socket/socket_server.cpp b/vespalib/src/tests/net/socket/socket_server.cpp
index ff8d77f317d..c14c69caa70 100644
--- a/vespalib/src/tests/net/socket/socket_server.cpp
+++ b/vespalib/src/tests/net/socket/socket_server.cpp
@@ -12,7 +12,7 @@
 
 using namespace vespalib;
 
-vespalib::string read_msg(Socket &socket) {
+vespalib::string read_msg(SocketHandle &socket) {
     vespalib::string msg;
     for (;;) {
         char c;
@@ -28,7 +28,7 @@ vespalib::string read_msg(Socket &socket) {
     }
 }
 
-void write_msg(Socket &socket, const vespalib::string &msg) {
+void write_msg(SocketHandle &socket, const vespalib::string &msg) {
     for (size_t i = 0; i < msg.size(); ++i) {
         ssize_t ret = socket.write(&msg[i], 1);
         if (ret != 1) {
@@ -39,8 +39,8 @@ void write_msg(Socket &socket, const vespalib::string &msg) {
 }
 
 int main(int, char **) {
-    ServerSocket::UP server = ServerSocket::listen(SocketSpec::from_port(0));
-    if (!server->valid()) {
+    ServerSocket server(0);
+    if (!server.valid()) {
         fprintf(stderr, "listen failed, exiting\n");
         return 1;
     }
@@ -52,18 +52,19 @@ int main(int, char **) {
             fprintf(stderr, "  %s\n", addr.spec().c_str());
         }
     }
-    fprintf(stderr, "listening to %s\n", server->address().spec().c_str());
+    fprintf(stderr, "listening to %s\n", server.address().spec().c_str());
     fprintf(stderr, "client command: ./vespalib_socket_client_app %s %d\n",
-            HostName::get().c_str(), server->address().port());
+            HostName::get().c_str(), server.address().port());
     fprintf(stderr, "use ^C (SIGINT) to exit\n");
     SignalHandler::INT.hook();
     while (!SignalHandler::INT.check()) {
-        Socket::UP socket = server->accept();
-        if (socket->valid()) {
+        SocketHandle socket = server.accept();
+        if (socket.valid()) {
             fprintf(stderr, "got connection from: %s (local address: %s)\n",
-                    socket->peer_address().spec().c_str(), socket->address().spec().c_str());
-            fprintf(stderr, "message from client: '%s'\n", read_msg(*socket).c_str());
-            write_msg(*socket, "hello from server\n");
+                    SocketAddress::peer_address(socket.get()).spec().c_str(),
+                    SocketAddress::address_of(socket.get()).spec().c_str());
+            fprintf(stderr, "message from client: '%s'\n", read_msg(socket).c_str());
+            write_msg(socket, "hello from server\n");
         } else {
             fprintf(stderr, "(got invalid socket from accept)\n");
         }
diff --git a/vespalib/src/tests/net/socket/socket_test.cpp b/vespalib/src/tests/net/socket/socket_test.cpp
index bf0a5a2f273..c4b1e5286b2 100644
--- a/vespalib/src/tests/net/socket/socket_test.cpp
+++ b/vespalib/src/tests/net/socket/socket_test.cpp
@@ -74,7 +74,7 @@ vespalib::string get_meta(const SocketAddress &addr) {
     return meta;
 }
 
-vespalib::string read_bytes(Socket &socket, size_t wanted_bytes) {
+vespalib::string read_bytes(SocketHandle &socket, size_t wanted_bytes) {
     char tmp[64];
     vespalib::string result;
     while (result.size() < wanted_bytes) {
@@ -88,7 +88,7 @@ vespalib::string read_bytes(Socket &socket, size_t wanted_bytes) {
     return result;
 }
 
-void verify_socket_io(bool is_server, Socket &socket) {
+void verify_socket_io(bool is_server, SocketHandle &socket) {
     vespalib::string server_message = "hello, this is the server speaking";
     vespalib::string client_message = "please pick up, I need to talk to you";
     if(is_server) {
@@ -104,7 +104,7 @@ void verify_socket_io(bool is_server, Socket &socket) {
     }
 }
 
-Socket::UP connect_sockets(bool is_server, ServerSocket &server_socket) {
+SocketHandle connect_sockets(bool is_server, ServerSocket &server_socket) {
     if (is_server) {
         return server_socket.accept();
     } else {
@@ -113,7 +113,7 @@ Socket::UP connect_sockets(bool is_server, ServerSocket &server_socket) {
         auto client = SocketSpec(spec).client_address();
         fprintf(stderr, "connecting to '%s' (server: %s) (client: %s)\n",
                 spec.c_str(), get_meta(server).c_str(), get_meta(client).c_str());
-        return Socket::connect(SocketSpec(spec));
+        return client.connect();
     }
 }
 
@@ -187,84 +187,79 @@ TEST("local client/server addresses") {
     fprintf(stderr, "server(tcp/123): %s (%s)\n", server.spec().c_str(), get_meta(server).c_str());
 }
 
-struct ServerWrapper {
-    ServerSocket::UP server;
-    ServerWrapper(const vespalib::string &spec) : server(ServerSocket::listen(SocketSpec(spec))) {}
-};
-
-TEST_MT_FF("require that basic socket io works", 2, ServerWrapper("tcp/0"), TimeBomb(60)) {
+TEST_MT_FF("require that basic socket io works", 2, ServerSocket("tcp/0"), TimeBomb(60)) {
     bool is_server = (thread_id == 0);
-    Socket::UP socket = connect_sockets(is_server, *f1.server);
-    TEST_DO(verify_socket_io(is_server, *socket));
+    SocketHandle socket = connect_sockets(is_server, f1);
+    TEST_DO(verify_socket_io(is_server, socket));
 }
 
 TEST_MT_FF("require that basic unix domain socket io works (path)", 2,
-           ServerWrapper("ipc/file:my_socket"), TimeBomb(60))
+           ServerSocket("ipc/file:my_socket"), TimeBomb(60))
 {
     bool is_server = (thread_id == 0);
-    Socket::UP socket = connect_sockets(is_server, *f1.server);
-    TEST_DO(verify_socket_io(is_server, *socket));
+    SocketHandle socket = connect_sockets(is_server, f1);
+    TEST_DO(verify_socket_io(is_server, socket));
 }
 
 TEST_MT_FF("require that basic unix domain socket io works (name)", 2,
-           ServerWrapper(make_string("ipc/name:my_socket-%d", int(getpid()))), TimeBomb(60))
+           ServerSocket(make_string("ipc/name:my_socket-%d", int(getpid()))), TimeBomb(60))
 {
     bool is_server = (thread_id == 0);
-    Socket::UP socket = connect_sockets(is_server, *f1.server);
-    TEST_DO(verify_socket_io(is_server, *socket));
+    SocketHandle socket = connect_sockets(is_server, f1);
+    TEST_DO(verify_socket_io(is_server, socket));
 }
 
-TEST_MT_FF("require that server accept can be interrupted", 2, ServerWrapper("tcp/0"), TimeBomb(60)) {
+TEST_MT_FF("require that server accept can be interrupted", 2, ServerSocket("tcp/0"), TimeBomb(60)) {
     bool is_server = (thread_id == 0);
     if (is_server) {
         fprintf(stderr, "--> calling accept\n");
-        Socket::UP socket = f1.server->accept();
+        SocketHandle socket = f1.accept();
         fprintf(stderr, "<-- accept returned\n");
-        EXPECT_TRUE(!socket->valid());
+        EXPECT_TRUE(!socket.valid());
     } else {
         std::this_thread::sleep_for(std::chrono::milliseconds(500));
         fprintf(stderr, "--- closing server socket\n");
-        f1.server->shutdown();
+        f1.shutdown();
     }
 }
 
 TEST("require that socket file is removed by server socket when destructed") {
     remove_file("my_socket");
-    ServerSocket::UP server = ServerSocket::listen(SocketSpec("ipc/file:my_socket"));
-    EXPECT_TRUE(server->valid());
+    ServerSocket server("ipc/file:my_socket");
+    EXPECT_TRUE(server.valid());
     EXPECT_TRUE(is_socket("my_socket"));
-    server.reset();
+    server = ServerSocket("invalid");
     EXPECT_TRUE(!is_socket("my_socket"));
 }
 
 TEST("require that socket file is only removed on destruction if it is a socket") {
     remove_file("my_socket");
-    ServerSocket::UP server = ServerSocket::listen(SocketSpec("ipc/file:my_socket"));
-    EXPECT_TRUE(server->valid());
+    ServerSocket server("ipc/file:my_socket");
+    EXPECT_TRUE(server.valid());
     EXPECT_TRUE(is_socket("my_socket"));
     replace_file("my_socket", "hello\n");
-    server.reset();
+    server = ServerSocket("invalid");
     EXPECT_TRUE(is_file("my_socket"));
     remove_file("my_socket");
 }
 
 TEST("require that a server socket will fail to listen to a path that is already a regular file") {
     replace_file("my_socket", "hello\n");
-    ServerSocket::UP server = ServerSocket::listen(SocketSpec("ipc/file:my_socket"));
-    EXPECT_TRUE(!server->valid());
-    server.reset();
+    ServerSocket server("ipc/file:my_socket");
+    EXPECT_TRUE(!server.valid());
+    server = ServerSocket("invalid");
     EXPECT_TRUE(is_file("my_socket"));
     remove_file("my_socket");
 }
 
 TEST("require that a server socket will fail to listen to a path that is already taken by another server") {
     remove_file("my_socket");
-    ServerSocket::UP server1 = ServerSocket::listen(SocketSpec("ipc/file:my_socket"));
-    ServerSocket::UP server2 = ServerSocket::listen(SocketSpec("ipc/file:my_socket"));
-    EXPECT_TRUE(server1->valid());
-    EXPECT_TRUE(!server2->valid());
+    ServerSocket server1("ipc/file:my_socket");
+    ServerSocket server2("ipc/file:my_socket");
+    EXPECT_TRUE(server1.valid());
+    EXPECT_TRUE(!server2.valid());
     EXPECT_TRUE(is_socket("my_socket"));
-    server1.reset();
+    server1 = ServerSocket("invalid");
     EXPECT_TRUE(!is_socket("my_socket"));
 }
 
@@ -275,55 +270,54 @@ TEST("require that a server socket will remove an old socket file if it cannot b
         EXPECT_TRUE(is_socket("my_socket"));
     }
     EXPECT_TRUE(is_socket("my_socket"));
-    ServerSocket::UP server = ServerSocket::listen(SocketSpec("ipc/file:my_socket"));
-    EXPECT_TRUE(server->valid());
-    server.reset();
+    ServerSocket server("ipc/file:my_socket");
+    EXPECT_TRUE(server.valid());
+    server = ServerSocket("invalid");
     EXPECT_TRUE(!is_socket("my_socket"));
 }
 
 TEST("require that two server sockets cannot have the same abstract unix domain socket name") {
     vespalib::string spec = make_string("ipc/name:my_socket-%d", int(getpid()));
-    ServerSocket::UP server1 = ServerSocket::listen(SocketSpec(spec));
-    ServerSocket::UP server2 = ServerSocket::listen(SocketSpec(spec));
-    EXPECT_TRUE(server1->valid());
-    EXPECT_TRUE(!server2->valid());
+    ServerSocket server1(spec);
+    ServerSocket server2(spec);
+    EXPECT_TRUE(server1.valid());
+    EXPECT_TRUE(!server2.valid());
 }
 
 TEST("require that abstract socket names are freed when the server socket is destructed") {
     vespalib::string spec = make_string("ipc/name:my_socket-%d", int(getpid()));
-    ServerSocket::UP server1 = ServerSocket::listen(SocketSpec(spec));
-    EXPECT_TRUE(server1->valid());
-    server1.reset();
-    ServerSocket::UP server2 = ServerSocket::listen(SocketSpec(spec));
-    EXPECT_TRUE(server2->valid());
+    ServerSocket server1(spec);
+    EXPECT_TRUE(server1.valid());
+    server1 = ServerSocket("invalid");
+    ServerSocket server2(spec);
+    EXPECT_TRUE(server2.valid());
 }
 
 TEST("require that abstract sockets do not have socket files") {
     vespalib::string name = make_string("my_socket-%d", int(getpid()));
-    vespalib::string spec = make_string("ipc/name:%s", name.c_str());
-    ServerSocket::UP server = ServerSocket::listen(SocketSpec(spec));
-    EXPECT_TRUE(server->valid());
+    ServerSocket server(SocketSpec::from_name(name));
+    EXPECT_TRUE(server.valid());
     EXPECT_TRUE(!is_socket(name));
     EXPECT_TRUE(!is_file(name));    
 }
 
 TEST_MT_FFF("require that abstract and file-based unix domain sockets are not in conflict", 4,
-            ServerWrapper(make_string("ipc/file:my_socket-%d", int(getpid()))),
-            ServerWrapper(make_string("ipc/name:my_socket-%d", int(getpid()))), TimeBomb(60))
+            ServerSocket(make_string("ipc/file:my_socket-%d", int(getpid()))),
+            ServerSocket(make_string("ipc/name:my_socket-%d", int(getpid()))), TimeBomb(60))
 {
     bool is_server = ((thread_id % 2) == 0);
-    ServerSocket &server_socket = ((thread_id / 2) == 0) ? *f1.server : *f2.server;
-    Socket::UP socket = connect_sockets(is_server, server_socket);
-    TEST_DO(verify_socket_io(is_server, *socket));
+    ServerSocket &server_socket = ((thread_id / 2) == 0) ? f1 : f2;
+    SocketHandle socket = connect_sockets(is_server, server_socket);
+    TEST_DO(verify_socket_io(is_server, socket));
 }
 
 TEST("require that sockets can be set blocking and non-blocking") {
     SocketHandle handle(socket(my_inet(), SOCK_STREAM, 0));
     test::SocketOptionsVerifier verifier(handle.get());
     EXPECT_TRUE(!SocketOptions::set_blocking(-1, true));
-    EXPECT_TRUE(SocketOptions::set_blocking(handle.get(), true));
+    EXPECT_TRUE(handle.set_blocking(true));
     TEST_DO(verifier.verify_blocking(true));
-    EXPECT_TRUE(SocketOptions::set_blocking(handle.get(), false));
+    EXPECT_TRUE(handle.set_blocking(false));
     TEST_DO(verifier.verify_blocking(false));
 }
 
@@ -331,9 +325,9 @@ TEST("require that tcp nodelay can be enabled and disabled") {
     SocketHandle handle(socket(my_inet(), SOCK_STREAM, 0));
     test::SocketOptionsVerifier verifier(handle.get());
     EXPECT_TRUE(!SocketOptions::set_nodelay(-1, true));
-    EXPECT_TRUE(SocketOptions::set_nodelay(handle.get(), true));
+    EXPECT_TRUE(handle.set_nodelay(true));
     TEST_DO(verifier.verify_nodelay(true));
-    EXPECT_TRUE(SocketOptions::set_nodelay(handle.get(), false));
+    EXPECT_TRUE(handle.set_nodelay(false));
     TEST_DO(verifier.verify_nodelay(false));
 }
 
@@ -341,9 +335,9 @@ TEST("require that reuse addr can be set and cleared") {
     SocketHandle handle(socket(my_inet(), SOCK_STREAM, 0));
     test::SocketOptionsVerifier verifier(handle.get());
     EXPECT_TRUE(!SocketOptions::set_reuse_addr(-1, true));
-    EXPECT_TRUE(SocketOptions::set_reuse_addr(handle.get(), true));
+    EXPECT_TRUE(handle.set_reuse_addr(true));
     TEST_DO(verifier.verify_reuse_addr(true));
-    EXPECT_TRUE(SocketOptions::set_reuse_addr(handle.get(), false));
+    EXPECT_TRUE(handle.set_reuse_addr(false));
     TEST_DO(verifier.verify_reuse_addr(false));
 }
 
@@ -352,9 +346,9 @@ TEST("require that ipv6_only can be set and cleared") {
         SocketHandle handle(socket(my_inet(), SOCK_STREAM, 0));
         test::SocketOptionsVerifier verifier(handle.get());
         EXPECT_TRUE(!SocketOptions::set_ipv6_only(-1, true));
-        EXPECT_TRUE(SocketOptions::set_ipv6_only(handle.get(), true));
+        EXPECT_TRUE(handle.set_ipv6_only(true));
         TEST_DO(verifier.verify_ipv6_only(true));
-        EXPECT_TRUE(SocketOptions::set_ipv6_only(handle.get(), false));
+        EXPECT_TRUE(handle.set_ipv6_only(false));
         TEST_DO(verifier.verify_ipv6_only(false));
     } else {
         fprintf(stderr, "WARNING: skipping ipv6_only test since ipv6 is disabled");
@@ -365,9 +359,9 @@ TEST("require that tcp keepalive can be set and cleared") {
     SocketHandle handle(socket(my_inet(), SOCK_STREAM, 0));
     test::SocketOptionsVerifier verifier(handle.get());
     EXPECT_TRUE(!SocketOptions::set_keepalive(-1, true));
-    EXPECT_TRUE(SocketOptions::set_keepalive(handle.get(), true));
+    EXPECT_TRUE(handle.set_keepalive(true));
     TEST_DO(verifier.verify_keepalive(true));
-    EXPECT_TRUE(SocketOptions::set_keepalive(handle.get(), false));
+    EXPECT_TRUE(handle.set_keepalive(false));
     TEST_DO(verifier.verify_keepalive(false));
 }
 
@@ -375,13 +369,13 @@ TEST("require that tcp lingering can be adjusted") {
     SocketHandle handle(socket(my_inet(), SOCK_STREAM, 0));
     test::SocketOptionsVerifier verifier(handle.get());
     EXPECT_TRUE(!SocketOptions::set_linger(-1, true, 0));
-    EXPECT_TRUE(SocketOptions::set_linger(handle.get(), true, 0));
+    EXPECT_TRUE(handle.set_linger(true, 0));
     TEST_DO(verifier.verify_linger(true, 0));
-    EXPECT_TRUE(SocketOptions::set_linger(handle.get(), true, 10));
+    EXPECT_TRUE(handle.set_linger(true, 10));
     TEST_DO(verifier.verify_linger(true, 10));
-    EXPECT_TRUE(SocketOptions::set_linger(handle.get(), false, 0));
+    EXPECT_TRUE(handle.set_linger(false, 0));
     TEST_DO(verifier.verify_linger(false, 0));
-    EXPECT_TRUE(SocketOptions::set_linger(handle.get(), false, 10));
+    EXPECT_TRUE(handle.set_linger(false, 10));
     TEST_DO(verifier.verify_linger(false, 0));
 }