Connection Class Reference

A TCP connection from a client. More...

#include <io.hpp>

Collaboration diagram for Connection:

Public Member Functions
	Connection (IoCore &parent, uv_tcp_t *tcp, Player &player, size_t id)
	Constructs a Connection. More...
	~Connection ()
	Destructs a Connection. More...
	Connection (const Connection &)=delete
	Connection cannot be copied.
Connection &	operator= (const Connection &)=delete
	Connection cannot be copy-assigned.
void	Respond (const Response &response)
	Emits a Response via this Connection. More...
void	Read (ssize_t nread, const uv_buf_t *buf)
	Processes a data read on this connection. More...
void	Shutdown ()
	Gracefully shuts this connection down. More...
void	Depool ()
	Removes this connection from its connection pool. More...
std::string	Name ()
	Retrieves a name for this connection. More...

Private Member Functions
Response	RunCommand (const std::vector< std::string > &msg)
	Handles a tokenised command line. More...

Private Attributes
IoCore &	parent
	The pool on which this connection is running.
uv_tcp_t *	tcp
	The libuv handle for the TCP connection.
Tokeniser	tokeniser
	The Tokeniser to which data read on this connection should be sent.
Player &	player
	The Player to which finished commands should be sent.
size_t	id
	The Connection's ID in the connection pool.

Detailed Description

A TCP connection from a client.

This class wraps a libuv TCP stream representing a client connection, allowing it to be sent responses (directly, or via a broadcast), removed from its IoCore, and queried for its name.

Definition at line 186 of file io.hpp.

Constructor & Destructor Documentation

Connection()

Connection::Connection	(	IoCore &	parent,
		uv_tcp_t *	tcp,
		Player &	player,
		size_t	id
	)

Constructs a Connection.

Parameters

parent	The connection pool to which this Connection belongs.
tcp	The underlying libuv TCP stream.
player	The player to which read commands should be sent.
id	The ID of this Connection in the IoCore.

Definition at line 392 of file io.cpp.

References Name().

    : parent(parent), tcp(tcp), tokeniser(), player(player), id(id)
{
    Debug() << "Opening connection from" << Name() << std::endl;
}

~Connection()

Connection::~Connection

(

)

Destructs a Connection.

This causes libuv to close and free the libuv TCP stream.

Definition at line 398 of file io.cpp.

References Name(), tcp, and UvCloseCallback().

{
    Debug() << "Closing connection from" << Name() << std::endl;
    uv_close(reinterpret_cast<uv_handle_t *>(this->tcp), UvCloseCallback);
}

Member Function Documentation

Depool()

void Connection::Depool

(

)

Removes this connection from its connection pool.

Since the pool may contain a shared reference to this connection, calling this can result in the connection being destructed.

Definition at line 535 of file io.cpp.

References parent, and IoCore::Remove().

Referenced by Read().

{
    this->parent.Remove(this->id);
}

Name()

std::string Connection::Name

(

)

Retrieves a name for this connection.

This will be of the form "HOST:PORT", unless errors occur.

Returns

The Connection's name.

Definition at line 429 of file io.cpp.

References tcp.

Referenced by Connection(), Read(), and ~Connection().

{
    // Warning: fairly low-level Berkeley sockets code ahead!
    // (Thankfully, libuv makes sure the appropriate headers are included.)

    // Using this instead of struct sockaddr is advised by the libuv docs,
    // for IPv6 compatibility.
    struct sockaddr_storage s;
    auto sp = (struct sockaddr *)&s;

    // Turns out if you don't do this, Windows (and only Windows?) is upset.
    socklen_t namelen = sizeof(s);

    int pe = uv_tcp_getpeername(this->tcp, sp, (int *)&namelen);
    // These std::string()s are needed as, otherwise, the compiler would
    // think we're trying to add const char*s together.  We need AT LEAST
    // ONE of the sides of the first + to be a std::string.
    if (pe) return "<error@peer: " + std::string(uv_strerror(pe)) + ">";

    // Now, split the sockaddr into host and service.
    char host[NI_MAXHOST];
    char serv[NI_MAXSERV];

    // We use NI_NUMERICSERV to ensure a port number comes out.
    // Otherwise, we could get a (likely erroneous) string description of
    // what the network stack *thinks* the port is used for.
    int ne = getnameinfo(sp, namelen, host, sizeof(host), serv,
                         sizeof(serv), NI_NUMERICSERV);
    // See comment for above error.
    if (ne) return "<error@name: " + std::string(gai_strerror(ne)) + ">";

    auto id = std::to_string(this->id);
    return id + std::string("!") + host + std::string(":") + serv;
}

Read()

void Connection::Read	(	ssize_t	nread,
		const uv_buf_t *	buf
	)

Processes a data read on this connection.

Parameters

nread	The number of bytes read.
buf	The buffer containing the read data.

Definition at line 464 of file io.cpp.

References Depool(), Tokeniser::Feed(), Name(), Respond(), RunCommand(), and tokeniser.

{
    assert(buf != nullptr);

    // Did the connection hang up?  If so, de-pool it.
    // De-pooling the connection will usually lead to the connection being
    // destroyed.
    if (nread == UV_EOF) {
        this->Depool();
        return;
    }

    // Did we hit any other read errors?  Also de-pool, but log the error.
    if (nread < 0) {
        Debug() << "Error on" << Name() << "-" << uv_err_name(nread)
                << std::endl;
        this->Depool();
        return;
    }

    // Make sure we actually have some data to read!
    if (buf->base == nullptr) return;

    // Everything looks okay for reading.
    auto cmds = this->tokeniser.Feed(std::string(buf->base, nread));
    for (auto cmd : cmds) {
        if (cmd.empty()) continue;

        Response res = RunCommand(cmd);
        this->Respond(res);
    }

    delete[] buf->base;
}

Respond()

void Connection::Respond

(

const Response &

response

)

Emits a Response via this Connection.

Parameters

response

The response to send.

Definition at line 404 of file io.cpp.

References Response::Pack(), tcp, and UvWriteCallback().

Referenced by Read().

{
    // Pack provides us the response's wire format, except the newline.
    // We can provide that here.
    auto string = response.Pack();
    string.push_back('\n');

    unsigned int l = string.length();

    // Make a libuv buffer and pour the request into it.
    // The onus is on UvRespondCallback to free buf.base.
    auto buf = uv_buf_init(new char[l], l);
    assert(buf.base != nullptr);
    string.copy(buf.base, l);

    // Make a write request.
    // Since the callback must free the buffer, pass it through as data.
    // The callback will also free req.
    auto req = new uv_write_t;
    req->data = static_cast<void *>(buf.base);

    uv_write((uv_write_t *)req, (uv_stream_t *)this->tcp, &buf, 1,
             UvWriteCallback);
}

RunCommand()

Response Connection::RunCommand ( const std::vector< std::string > &  msg )

private

Handles a tokenised command line.

Parameters

msg	A vector of command words representing a command line.

Returns

A final response returning whether the command succeeded.

Definition at line 499 of file io.cpp.

References Player::Dump(), Player::Eject(), Player::End(), Response::Invalid(), Player::Load(), MSG_CMD_INVALID, MSG_CMD_SHORT, player, Player::Pos(), and Player::SetPlaying().

Referenced by Read().

{
    // First of all, figure out what the tag of this command is.
    // The first word is always the tag.
    auto tag = cmd[0];
    if (cmd.size() <= 1) return Response::Invalid(tag, MSG_CMD_SHORT);

    // The next words are the actual command, and any other arguments.
    auto word = cmd[1];
    auto nargs = cmd.size() - 2;

    if (nargs == 0) {
        if ("play" == word) return this->player.SetPlaying(tag, true);
        if ("stop" == word) return this->player.SetPlaying(tag, false);
        if ("end" == word) return this->player.End(tag);
        if ("eject" == word) return this->player.Eject(tag);
        if ("dump" == word) return this->player.Dump(id, tag);
    } else if (nargs == 1) {
        if ("fload" == word) return this->player.Load(tag, cmd[2]);
        if ("pos" == word) return this->player.Pos(tag, cmd[2]);
    }

    return Response::Invalid(tag, MSG_CMD_INVALID);
}

Shutdown()

void Connection::Shutdown

(

)

Gracefully shuts this connection down.

This is similar to (and implemented in terms of) Depool, but waits for all writes to finish first.

Definition at line 524 of file io.cpp.

References tcp, and UvShutdownCallback().

{
    auto req = new uv_shutdown_t;
    assert(req != nullptr);

    req->data = this;

    uv_shutdown(req, reinterpret_cast<uv_stream_t *>(this->tcp),
                UvShutdownCallback);
}

---

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

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