Function connSocketEventHandler

src/connection.cpp:271–339

}

void connSocketEventHandler(struct aeEventLoop *el, int fd, void *clientData, int mask)
{
    UNUSED(el);
    UNUSED(fd);
    connection *conn = (connection*)clientData;

    if (conn->state.load(std::memory_order_relaxed) == CONN_STATE_CONNECTING &&
            (mask & AE_WRITABLE) && conn->conn_handler) {

        int conn_error = connGetSocketError(conn);
        if (conn_error) {
            conn->last_errno = conn_error;
            conn->state.store(CONN_STATE_ERROR, std::memory_order_release);
        } else {
            conn->state.store(CONN_STATE_CONNECTED, std::memory_order_release);
        }

        if (!conn->write_handler) aeDeleteFileEvent(serverTL->el,conn->fd,AE_WRITABLE);

        {
        AeLocker locker;
        locker.arm(nullptr);
        if (!callHandler(conn, conn->conn_handler)) return;
        }
        conn->conn_handler = NULL;
    }

    /* Normally we execute the readable event first, and the writable
     * event later. This is useful as sometimes we may be able
     * to serve the reply of a query immediately after processing the
     * query.
     *
     * However if WRITE_BARRIER is set in the mask, our application is
     * asking us to do the reverse: never fire the writable event
     * after the readable. In such a case, we invert the calls.
     * This is useful when, for instance, we want to do things
     * in the beforeSleep() hook, like fsync'ing a file to disk,
     * before replying to a client. */
    int invert = conn->flags & CONN_FLAG_WRITE_BARRIER;

    int call_write = (mask & AE_WRITABLE) && conn->write_handler;
    int call_read = (mask & AE_READABLE) && conn->read_handler;

    /* Handle normal I/O flows */
    if (!invert && call_read) {
        AeLocker lock;
        if (!(conn->flags & CONN_FLAG_READ_THREADSAFE))
            lock.arm(nullptr);
        
        if (!callHandler(conn, conn->read_handler)) return;
    }
    /* Fire the writable event. */
    if (call_write) {
        AeLocker lock;
        if (!(conn->flags & CONN_FLAG_WRITE_THREADSAFE))
            lock.arm(nullptr);

        if (!callHandler(conn, conn->write_handler)) return;