uvco::StreamServerBase< UvStreamType, StreamType > Class Template Reference

#include <stream_server_base.h>

Classes
struct	ConnectionAwaiter_

Public Member Functions
	StreamServerBase (const StreamServerBase &)=delete
	StreamServerBase (StreamServerBase &&)=default
StreamServerBase &	operator= (const StreamServerBase &)=delete
StreamServerBase &	operator= (StreamServerBase &&)=default
	~StreamServerBase ()
MultiPromise< StreamType >	listen (int backlog=128)
AddressHandle	getSockname () const
	Get the address the server is bound to.
void	close ()

Protected Member Functions
	StreamServerBase (std::unique_ptr< UvStreamType > socket)

Protected Attributes
std::unique_ptr< UvStreamType >	socket_

Static Private Member Functions
static void	onNewConnection (uv_stream_t *stream, uv_status status)
	Called by libuv when a new connection arrives.

Detailed Description

template<typename UvStreamType, typename StreamType>
class uvco::StreamServerBase< UvStreamType, StreamType >

Not for use in user code; base class for e.g. UnixServer and TcpServer.

Because accepting connections looks the same for Unix and TCP servers, the behavior is defined here and shared by both. However, the implementation must be generic over the stream type, so the actual stream type is a template parameter.

Constructor & Destructor Documentation

StreamServerBase() [1/3]

template<typename UvStreamType, typename StreamType>

uvco::StreamServerBase< UvStreamType, StreamType >::StreamServerBase ( const StreamServerBase< UvStreamType, StreamType > & )

delete

StreamServerBase() [2/3]

template<typename UvStreamType, typename StreamType>

uvco::StreamServerBase< UvStreamType, StreamType >::StreamServerBase ( StreamServerBase< UvStreamType, StreamType > && )

default

~StreamServerBase()

template<typename UvStreamType, typename StreamType>

uvco::StreamServerBase< UvStreamType, StreamType >::~StreamServerBase

(

)

                                                              {
  // Quasi-sync method.
  close();
}

StreamServerBase() [3/3]

template<typename UvStreamType, typename StreamType>

uvco::StreamServerBase< UvStreamType, StreamType >::StreamServerBase ( std::unique_ptr< UvStreamType > socket )

inlineexplicitprotected

      : socket_{std::move(socket)} {}

Member Function Documentation

close()

template<typename UvStreamType, typename StreamType>

void uvco::StreamServerBase< UvStreamType, StreamType >::close

(

)

Close server and stop accepting client connections. As opposed to many other close() methods, it's synchronous, and therefore needs not be called, as the destructor calls it.

Internally it makes use of the quasi-sync behavior of closeHandle(), making it actually more robust than a coroutine (against dropping etc.)

                                                       {
  if (socket_ != nullptr && !dataIsNull(socket_.get())) {
    auto *awaiter = getData<ConnectionAwaiter_>(socket_.get());
    // Resume listener coroutine and tell it to exit.
    // If awaiter == nullptr, one of two things is true:
    // 1. listener is currently not running
    // 2. listener has yielded and is suspended there: the listener generator
    // will be cancelled when its MultiPromise is dropped.
    awaiter->stop();
  }
  if (socket_ != nullptr && !isClosed(socket_.get())) {
    // closeHandle takes care of freeing the memory if its own promise is
    // dropped.
    closeHandle(socket_.release());
  }
}

getSockname()

template<typename UvStreamType, typename StreamType>

AddressHandle uvco::StreamServerBase< UvStreamType, StreamType >::getSockname ( ) const

nodiscard

Get the address the server is bound to.

                                                                            {
  if constexpr (std::is_same_v<UvStreamType, uv_tcp_t>) {
    struct sockaddr_storage addr{};
    int addrLen = sizeof(addr);
    const uv_status status =
        uv_tcp_getsockname(socket_.get(), (struct sockaddr *)&addr, &addrLen);
    if (status != 0) {
      throw UvcoException{status, "StreamServerBase::getSockname() failed"};
    }
    return AddressHandle{(struct sockaddr *)&addr};
  } else if constexpr (std::is_same_v<UvStreamType, uv_pipe_t>) {
    throw UvcoException{
        UV_ENOSYS,
        "StreamServerBase::getSockname() not implemented for uv_pipe_t"};
  } else {
    static_assert(false);
  }
}

listen()

template<typename UvStreamType, typename StreamType>

MultiPromise< StreamType > uvco::StreamServerBase< UvStreamType, StreamType >::listen

(

int

backlog = 128

)

Return client connections as clients connect.

Raises exceptions if errors occur during accepting or listening.

This generator may not be co_awaited on after having called close().

                                                              {
  BOOST_ASSERT(socket_);
  ConnectionAwaiter_ awaiter{*socket_};
 
  const uv_status listenStatus =
      uv_listen((uv_stream_t *)socket_.get(), backlog,
                StreamServerBase<UvStreamType, StreamType>::onNewConnection);
  if (listenStatus != 0) {
    throw UvcoException{listenStatus,
                        "StreamServerBase::listen(): failed to listen"};
  }
 
  while (true) {
    const bool acceptOk = co_await awaiter;
    if (!acceptOk) {
      // At this point, do not touch socket_->data anymore!
      // This is the result of ConnectionAwaiter_::stop(), and
      // data points to a CloseAwaiter_ object.
      break;
    }
 
    for (auto it = awaiter.accepted_.begin(); it != awaiter.accepted_.end();
         it++) {
      auto &streamSlot = *it;
 
      if (streamSlot.index() == 0) {
        const uv_status status = std::get<0>(streamSlot);
        BOOST_ASSERT(status != 0);
        // When the error is handled, the user code can again call listen()
        // and will process the remaining connections. Therefore, first remove
        // the already processed connections.
        awaiter.accepted_.erase(awaiter.accepted_.begin(), it);
        throw UvcoException{status,
                            "UnixStreamServer failed to accept a connection!"};
      } else {
        // Awkward handlign: if the returned MultiPromise is dropped, we will
        // never return from co_yield. However, dropping may happen after
        // calling `close()`, so we cannot rely on socket_ still existing.
        //
        // `close()` also relies on whether `socket_->data` is `nullptr` or not
        // to decide if the socket has been closed already.
        co_yield std::move(std::get<1>(streamSlot));
      }
    }
    awaiter.accepted_.clear();
  }
}

onNewConnection()

template<typename UvStreamType, typename StreamType>

void uvco::StreamServerBase< UvStreamType, StreamType >::onNewConnection ( uv_stream_t * stream, uv_status status )

staticprivate

Called by libuv when a new connection arrives.

                                           {
  const auto *server = (UvStreamType *)stream;
  auto *connectionAwaiter = getData<ConnectionAwaiter_>(server);
  if (connectionAwaiter == nullptr) {
    return;
  }
  uv_loop_t *const loop = connectionAwaiter->socket_.loop;
 
  if (status == 0) {
    auto clientStream = std::make_unique<UvStreamType>();
    UvStreamInitHelper<UvStreamType>::init(loop, clientStream.get());
    const uv_status acceptStatus =
        uv_accept((uv_stream_t *)server, (uv_stream_t *)clientStream.get());
    if (acceptStatus == 0) {
      connectionAwaiter->accepted_.emplace_back(
          StreamType{std::move(clientStream)});
    } else {
      connectionAwaiter->accepted_.emplace_back(acceptStatus);
    }
  } else {
    connectionAwaiter->accepted_.emplace_back(status);
  }
 
  if (connectionAwaiter->handle_ != nullptr) {
    Loop::enqueue(connectionAwaiter->handle_);
    connectionAwaiter->handle_ = nullptr;
  }
}

operator=() [1/2]

template<typename UvStreamType, typename StreamType>

StreamServerBase & uvco::StreamServerBase< UvStreamType, StreamType >::operator= ( const StreamServerBase< UvStreamType, StreamType > & )

delete

operator=() [2/2]

template<typename UvStreamType, typename StreamType>

StreamServerBase & uvco::StreamServerBase< UvStreamType, StreamType >::operator= ( StreamServerBase< UvStreamType, StreamType > && )

default

Member Data Documentation

socket_

template<typename UvStreamType, typename StreamType>

std::unique_ptr<UvStreamType> uvco::StreamServerBase< UvStreamType, StreamType >::socket_

protected

---

The documentation for this class was generated from the following files:

• uvco/stream_server_base.h
• uvco/stream_server_base_impl.cc