IoCore Class Reference

The IO core, which services input, routes responses, and executes the Player update routine periodically. More...

#include <io.hpp>

Inheritance diagram for IoCore:

Collaboration diagram for IoCore:

Public Member Functions
	IoCore (Player &player)
	Constructs an IoCore. More...
	IoCore (const IoCore &)=delete
	Deleted copy constructor.
IoCore &	operator= (const IoCore &)=delete
	Deleted copy-assignment.
void	Run (const std::string &host, const std::string &port)
	Runs the reactor. More...
void	Accept (uv_stream_t *server)
	Accepts a new connection. More...
void	Remove (size_t id)
	Removes a connection. More...
void	UpdatePlayer ()
	Performs a player update cycle. More...
void	Respond (size_t id, const Response &response) const override
	Outputs a response. More...
void	Shutdown ()
	Shuts down the IoCore by terminating all IO loop tasks.
Public Member Functions inherited from ResponseSink
virtual	~ResponseSink ()=default
	Empty virtual destructor for ResponseSink.

Private Member Functions
void	InitAcceptor (const std::string &address, const std::string &port)
	Initialises a TCP acceptor on the given address and port. More...
void	InitUpdateTimer ()
	Sets up a periodic timer to run the playd update loop.
void	InitSignals ()
	Initialises playd's signal handling. More...
size_t	NextConnectionID ()
	Acquires the next available connection ID. More...
void	ExpandPool ()
	Adds a new connection slot to the connection pool. More...
void	Broadcast (const Response &response) const
	Sends the given response to all connections. More...
void	Unicast (size_t id, const Response &response) const
	Sends the given response to the identified connection. More...

Private Attributes
uv_loop_t *	loop
	The loop this IoCore is using.
uv_signal_t	sigint
	The libuv handle for the Ctrl-C signal.
uv_tcp_t	server
	The libuv handle for the TCP server.
uv_timer_t	updater
	The libuv handle for the update timer.
Player &	player
	The player.
std::vector< std::shared_ptr< Connection > >	pool
	The set of connections inside this IoCore.
std::vector< size_t >	free_list
	A list of free 1-indexed slots inside pool. More...

Static Private Attributes
static const uint16_t	PLAYER_UPDATE_PERIOD = 5
	The period between player updates.

Detailed Description

The IO core, which services input, routes responses, and executes the Player update routine periodically.

The IO core also maintains a pool of connections which can be sent responses via their IDs inside the pool. It ensures that each connection is given an ID that is unique up until the removal of said connection.

Definition at line 39 of file io.hpp.

Constructor & Destructor Documentation

IoCore()

IoCore::IoCore ( Player &  player )

explicit

Constructs an IoCore.

Parameters

player

The player to which update requests, commands, and new connection state dump requests shall be sent.

Definition at line 170 of file io.cpp.

                             : loop(nullptr), player(player)
{
}

Member Function Documentation

Accept()

void IoCore::Accept

(

uv_stream_t *

server

)

Accepts a new connection.

This accepts the connection, and adds it to this IoCore's connection pool.

This should be called with a server that has just received a new connection.

Parameters

server

Pointer to the libuv server accepting connections.

Definition at line 190 of file io.cpp.

References Response::IAMA, loop, MSG_OHAI_BIFROST, MSG_OHAI_PLAYD, NextConnectionID(), Response::NOREQUEST, Response::OHAI, player, pool, Respond(), Response::Success(), UvAlloc(), UvCloseCallback(), and UvReadCallback().

{
    assert(server != nullptr);
    assert(this->loop != nullptr);

    auto client = new uv_tcp_t();
    uv_tcp_init(this->loop, client);

    // libuv does the 'nonzero is error' thing here
    if (uv_accept(server, (uv_stream_t *)client)) {
        uv_close((uv_handle_t *)client, UvCloseCallback);
        return;
    }

    auto id = this->NextConnectionID();
    auto conn = std::make_shared<Connection>(*this, client, this->player, id);
    client->data = static_cast<void *>(conn.get());
    this->pool[id - 1] = std::move(conn);

    // Begin initial responses
    this->Respond(id, Response(Response::NOREQUEST, Response::Code::OHAI)
                              .AddArg(std::to_string(id))
                              .AddArg(MSG_OHAI_BIFROST)
                              .AddArg(MSG_OHAI_PLAYD));
    this->Respond(id, Response(Response::NOREQUEST, Response::Code::IAMA)
                              .AddArg("player/file"));
    this->player.Dump(id, Response::NOREQUEST);
    this->Respond(id, Response::Success(Response::NOREQUEST));
    // End initial responses

    uv_read_start((uv_stream_t *)client, UvAlloc, UvReadCallback);
}

Broadcast()

void IoCore::Broadcast ( const Response &  response ) const

private

Sends the given response to all connections.

Parameters

response

The response to broadcast.

Definition at line 316 of file io.cpp.

References Response::Pack(), and pool.

Referenced by Respond().

{
    Debug() << "broadcast:" << response.Pack() << std::endl;

    // Copy the connection by value, so that there's at least one
    // active reference to it throughout.
    for (const auto c : this->pool) {
        if (c) c->Respond(response);
    }
}

ExpandPool()

void IoCore::ExpandPool ( )

private

Adds a new connection slot to the connection pool.

This is called by NextConnectionID when the number of currently running connections is larger than the number of existing pool slots, and will eventually fail (when the number of simultaneous connections reaches absurd proportions).

Definition at line 243 of file io.cpp.

References free_list, MSG_TOO_MANY_CONNS, and pool.

Referenced by NextConnectionID().

{
    // If we already have SIZE_MAX-1 simultaneous connections, we bail out.
    // Since this is at least 65,534, and likely to be 2^32-2 or 2^64-2,
    // this is incredibly unlikely to happen and probably means someone's
    // trying to denial-of-service an audio player.
    //
    // Why -1?  Because slot 0 in the connection pool is reserved for
    // broadcasts.
    bool full = this->pool.size() == (SIZE_MAX - 1);
    if (full) throw InternalError(MSG_TOO_MANY_CONNS);

    this->pool.emplace_back(nullptr);
    // This isn't an off-by-one error; slots index from 1.
    this->free_list.push_back(this->pool.size());
}

InitAcceptor()

void IoCore::InitAcceptor ( const std::string &  address, const std::string &  port  )

private

Initialises a TCP acceptor on the given address and port.

Parameters

address	The IPv4 address on which the TCP server should listen.
port	The TCP port on which the TCP server should listen.

Definition at line 349 of file io.cpp.

References loop, MSG_IO_CANNOT_ALLOC, server, and UvListenCallback().

Referenced by Run().

{
    assert(this->loop != nullptr);

    if (uv_tcp_init(this->loop, &this->server)) {
        throw InternalError(MSG_IO_CANNOT_ALLOC);
    }
    this->server.data = static_cast<void *>(this);
    assert(this->server.data != nullptr);

    struct sockaddr_in bind_addr;
    uv_ip4_addr(address.c_str(), std::stoi(port), &bind_addr);
    uv_tcp_bind(&this->server, (const sockaddr *)&bind_addr, 0);

    int r = uv_listen((uv_stream_t *)&this->server, 128, UvListenCallback);
    if (r) {
        throw NetError("Could not listen on " + address + ":" + port +
                       " (" + std::string(uv_err_name(r)) + ")");
    }

    Debug() << "Listening at" << address << "on" << port << std::endl;
}

InitSignals()

void IoCore::InitSignals ( )

private

Initialises playd's signal handling.

We trap SIGINT, and the equivalent emulated signal on Windows, to make playd close gracefully when Ctrl-C is sent.

Definition at line 372 of file io.cpp.

References loop, MSG_IO_CANNOT_ALLOC, player, sigint, and UvSigintCallback().

Referenced by Run().

{
    int r = uv_signal_init(this->loop, &this->sigint);
    if (r) {
        throw InternalError(MSG_IO_CANNOT_ALLOC + ": " +
                            std::string(uv_err_name(r)));
    }

    // We pass the player, not the IoCore.
    // This is so the SIGINT handler can tell the player to quit,
    // which then tells us to shutdown
    this->sigint.data = static_cast<void *>(&this->player);
    assert(this->sigint.data != nullptr);
    uv_signal_start(&this->sigint, UvSigintCallback, SIGINT);
}

NextConnectionID()

size_t IoCore::NextConnectionID ( )

private

Acquires the next available connection ID.

This ID may have been assigned to a connection in the past, but is guaranteed not to match any currently assigned IDs.

Returns

size_t A fresh ID for use.

Definition at line 223 of file io.cpp.

References ExpandPool(), free_list, and pool.

Referenced by Accept().

{
    // We'll want to try and use an existing, empty ID in the connection
    // pool.  If there aren't any (we've exceeded the maximum-so-far number
    // of simultaneous connections), we expand the pool.
    if (this->free_list.empty()) this->ExpandPool();
    assert(!this->free_list.empty());

    // Acquire some free ID, and ensure that the ID cannot be re-used until
    // replaced onto the free list by the connection's removal.
    size_t id = this->free_list.back();
    this->free_list.pop_back();

    // client_slot should be at least 1, because of the above.
    assert(0 < id);
    assert(id <= this->pool.size());

    return id;
}

Remove()

void IoCore::Remove

(

size_t

id

)

Removes a connection.

As the IoCore owns the Connection, it will be destroyed by this operation.

Parameters

id	The ID of the connection to remove.

Definition at line 260 of file io.cpp.

References free_list, and pool.

Referenced by Connection::Depool().

{
    assert(0 < slot && slot <= this->pool.size());

    // Don't remove if it's already a nullptr, because we'd end up with the
    // slot on the free list twice.
    if (this->pool.at(slot - 1)) {
        this->pool[slot - 1] = nullptr;
        this->free_list.push_back(slot);
    }

    assert(!this->pool.at(slot - 1));
}

Respond()

void IoCore::Respond ( size_t  id, const Response &  response  ) const

overridevirtual

Outputs a response.

Parameters

id	The ID of the client of the ResponseSink receiving this response. Use 0 for broadcasts.
response	The Response to output.

Reimplemented from ResponseSink.

Definition at line 305 of file io.cpp.

References Broadcast(), pool, and Unicast().

Referenced by Accept().

{
    if (this->pool.empty()) return;

    if (id == 0) {
        this->Broadcast(response);
    } else {
        this->Unicast(id, response);
    }
}

Run()

void IoCore::Run	(	const std::string &	host,
		const std::string &	port
	)

Runs the reactor.

It will block until it terminates.

Parameters

host	The IP host to which IoCore will bind.
port	The TCP port to which IoCore will bind.

Exceptions

NetError

Thrown if IoCore cannot bind to host or port.

Definition at line 174 of file io.cpp.

References InitAcceptor(), InitSignals(), InitUpdateTimer(), loop, and MSG_IO_CANNOT_ALLOC.

Referenced by main().

{
    this->loop = uv_default_loop();
    if (this->loop == nullptr) throw InternalError(MSG_IO_CANNOT_ALLOC);

    this->InitAcceptor(host, port);
    this->InitSignals();
    this->InitUpdateTimer();

    uv_run(this->loop, UV_RUN_DEFAULT);

    // We presume all of the open handles have been closed in Shutdown().
    // We need only close the loop.
    uv_loop_close(this->loop);
}

Unicast()

void IoCore::Unicast ( size_t  id, const Response &  response  ) const

private

Sends the given response to the identified connection.

Parameters

id	The ID of the recipient connection.
response	The response to broadcast.

Definition at line 327 of file io.cpp.

References Response::Pack(), and pool.

Referenced by Respond().

{
    assert(0 < id && id <= this->pool.size());

    Debug() << "unicast @" << std::to_string(id) << ":" << response.Pack()
            << std::endl;

    auto c = this->pool.at(id - 1);
    if (c) c->Respond(response);
}

UpdatePlayer()

void IoCore::UpdatePlayer

(

)

Performs a player update cycle.

If the player is closing, IoCore will announce this fact to all current connections, close them, and end the I/O loop.

Definition at line 274 of file io.cpp.

References player, Shutdown(), and Player::Update().

{
    bool running = this->player.Update();
    if (!running) this->Shutdown();
}

Member Data Documentation

free_list

std::vector<size_t> IoCore::free_list

private

A list of free 1-indexed slots inside pool.

These slots may be re-used instead of creating a new slot.

Definition at line 118 of file io.hpp.

Referenced by ExpandPool(), NextConnectionID(), and Remove().

---

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

• src/io.hpp
• src/io.cpp