NET_WebEndpoint.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_WebEndpoint.h
 *
 * COMMENTS:
 *   Holds information about an endpoint. This is typically used as the
 *   information for responding to a request.
 */

#ifndef __NET_WEBENDPOINT_H__
#define __NET_WEBENDPOINT_H__

#include "NET_API.h"

#include <NET/NET_WebStream.h>

#include <UT/UT_Assert.h>
#include <UT/UT_StopWatch.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_SharedPtr.h>

#include <SYS/SYS_AtomicInt.h>

#include <atomic>

class NET_WebTaskHandler;

class NET_API NET_WebEndpoint
{
public:
    enum State
    {
        kNORMAL, // This is the first time runnin
        kDEATH
    };
    using Id = int32;

    NET_WebEndpoint();
    NET_WebEndpoint(
            bool is_secure,
            NET_WebStreamPtr stream,
            bool has_read_access,
            bool has_write_access,
            unsigned short client_ip[4]);
    ~NET_WebEndpoint();

    NET_WebEndpoint(const NET_WebEndpoint &) = delete;
    NET_WebEndpoint &operator=(const NET_WebEndpoint &) = delete;
    NET_WebEndpoint(NET_WebEndpoint &&) = delete;
    NET_WebEndpoint &operator=(NET_WebEndpoint &&) = delete;

    bool operator==(const NET_WebEndpoint &other) const
    {
        return myId == other.myId;
    }
    bool operator!=(const NET_WebEndpoint &other) const
    {
        return !(*this == other);
    }

    bool initialize(UT_UniquePtr<UT_NetSocket> socket, int port);

    void getClientIp(unsigned short ip[4]) const;

    UT_StringHolder clientIpStr() const;

    int port() const
    {
        // Dont use the port from the stream. The port is the way to identify
        // who this endpoint belongs to so we need to make sure we keeps
        // this value as a constant.
        return myPort;
    }

    bool hasValidStream() const { return myStream && myStream->isValid(); }

    void debugPrint() const;

    int getFD() const
    {
        if (!hasValidStream())
            return -1;
        return myStream->getFD();
    }

    Id getId() const { return myId; }

    SYS_FORCE_INLINE bool isAlive() const
    {
        return myIsAlive.load(std::memory_order_seq_cst);
    }
    SYS_FORCE_INLINE void setIsAlive(bool is_alive)
    {
        myIsAlive.store(is_alive, std::memory_order_seq_cst);
    }
    SYS_FORCE_INLINE bool isProcessing() const
    {
        return myProcessCount.load() > 0;
    }
    SYS_FORCE_INLINE void markProcessing()
    {
        UT_VERIFY(myProcessCount.exchangeAdd(1) >= 0);
    }
    SYS_FORCE_INLINE void markFinishedProcessing()
    {
        UT_VERIFY(myProcessCount.exchangeAdd(-1) >= 0);
    }

    /// We are about to placed on the queue for processing
    void startProcessQueue() { myWatch.start(); }

    NET_WebStreamPtr myStream;
    bool myIsSecure;
    bool myHasReadAccess;
    bool myHasWriteAccess;

    unsigned short myClientIp[4];
    State myState;

    void setNewHandler(UT_UniquePtr<NET_WebTaskHandler> handler);
    void process();

    unsigned taskCount() const { return myTaskCount; }

    int64 calcElapsedTime(time_t now) const;

    // This is really only used for debugging
    const char* handlerClassName();
private:
    unsigned myTaskCount;
    int myPort;

    std::atomic_bool myIsAlive;
    // This indicates if this endpoint is already being processed
    SYS_AtomicInt32 myProcessCount;
    Id myId;
    static SYS_AtomicCounter theIdCounter;
    UT_UniquePtr<NET_WebTaskHandler> myHandler;
    UT_StopWatch myWatch;
};

using NET_WebEndpointPtr = UT_SharedPtr<NET_WebEndpoint>;

#endif // __NET_WEBENDPOINT_H__