IOCPServer_V1.h

Go to the documentation of this file.

// Copyright 2024 libsese
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <sese/security/SSLContext.h>
#include <sese/service/TimerableService_V2.h>
#include <sese/service/UserBalanceLoader.h>
#include <sese/io/ByteBuilder.h>
 
#include <set>
 
namespace sese::iocp::v1 {
 
class Context;
class IOCPServer;
class IOCPService;
 
class IOCPServer {
public:
    virtual ~IOCPServer() = default;
    using DeleteContextCallback = std::function<void(Context *data)>;
 
    IOCPServer();
 
    bool init();
    void shutdown();
    static void postRead(Context *ctx);
    static void postWrite(Context *ctx);
    static void postClose(Context *ctx);
    void postConnect(const net::IPAddress::Ptr &to, const security::SSLContext::Ptr &cli_ctx, void *data = nullptr);
    static void setTimeout(Context *ctx, int64_t seconds);
    static void cancelTimeout(Context *ctx);
    static void onDeleteContext(Context *) {}
    virtual void onAcceptCompleted(Context *ctx) {}
    virtual void onPreRead(Context *ctx) {}
    virtual void onReadCompleted(Context *ctx) {}
    virtual void onWriteCompleted(Context *ctx) {}
    virtual void onTimeout(Context *ctx) {}
    virtual void onPreConnect(Context *ctx) {}
    virtual void onConnected(Context *ctx) {}
    virtual void onAlpnGet(Context *ctx, const uint8_t *in, uint32_t in_length) {}
    int onAlpnSelect(
            const uint8_t **out, uint8_t *out_length,
            const uint8_t *in, uint32_t in_length
    );
 
public:
    void setAddress(const net::IPAddress::Ptr &addr) { balanceLoader.setAddress(addr); }
    void setThreads(size_t threads) { balanceLoader.setThreads(threads); }
    void setServCtx(const security::SSLContext::Ptr &ctx) { IOCPServer::sslCtx = ctx; }
    void setServProtos(const std::string &protos) { IOCPServer::servProtos = protos; }
    void setClientProtos(const std::string &protos) { IOCPServer::clientProtos = protos; }
    void setDeleteContextCallback(const DeleteContextCallback &callback) { IOCPServer::deleteContextCallback = callback; }
    [[nodiscard]] const security::SSLContext::Ptr &getServCtx() const { return IOCPServer::sslCtx; }
    [[nodiscard]] const DeleteContextCallback &getDeleteContextCallback() const { return IOCPServer::deleteContextCallback; };
 
    [[nodiscard]] bool isActiveReleaseMode() const { return activeReleaseMode; }
 
public:
    [[maybe_unused]] void setAcceptTimeout(uint32_t seconds) { balanceLoader.setAcceptTimeout(seconds); }
    [[maybe_unused]] void setDispatchTimeout(uint32_t seconds) { balanceLoader.setDispatchTimeout(seconds); }
 
protected:
    void preConnectCallback(int fd, sese::event::EventLoop *event_loop, Context *ctx);
 
    void setActiveReleaseMode(bool enable) { activeReleaseMode = enable; }
 
    DeleteContextCallback deleteContextCallback = onDeleteContext;
    security::SSLContext::Ptr sslCtx{};
    std::string servProtos{};
    std::string clientProtos{};
    service::UserBalanceLoader balanceLoader;
 
private:
    bool activeReleaseMode = true;
};
 
class Context final : public io::InputStream, public io::OutputStream, public io::PeekableStream {
    friend class IOCPServer;
    friend class IOCPService;
    IOCPServer *self{};
    IOCPService *client{};
    socket_t fd{0};
    void *ssl{};
    bool isConn{false};
    event::BaseEvent *event{};
    service::v2::TimeoutEvent *timeoutEvent{};
    io::ByteBuilder send{8192, 8192};
    io::ByteBuilder recv{8192, 8192};
    void *data{};
 
public:
    int64_t read(void *buffer, size_t length) override;
    int64_t write(const void *buffer, size_t length) override;
    int64_t peek(void *buffer, size_t length) override;
    int64_t trunc(size_t length) override;
    [[nodiscard]] int32_t getFd() const { return static_cast<int32_t>(Context::fd); }
    [[nodiscard]] void *getData() const { return Context::data; }
    [[maybe_unused]] void setData(void *p_data) { Context::data = p_data; }
};
 
class IOCPService final : public service::v2::TimerableService {
public:
    explicit IOCPService(IOCPServer *master, bool active_release_mode);
    ~IOCPService() override;
 
    void postRead(Context *ctx);
    void postWrite(Context *ctx);
    void postClose(Context *ctx);
    static void onAcceptCompleted(Context *ctx);
    static void onPreRead(Context *ctx);
    static void onReadCompleted(Context *ctx);
    static void onWriteCompleted(Context *ctx);
    static void onTimeout(Context *ctx);
    static void onConnected(Context *ctx);
    static void onAlpnGet(Context *ctx, const uint8_t *in, uint32_t in_length);
    static int alpnCallbackFunction(
            void *ssl,
            const uint8_t **out, uint8_t *out_length,
            const uint8_t *in, uint32_t in_length,
            IOCPService *service
    );
 
private:
    void onAccept(int fd) override;
    void onRead(event::BaseEvent *event) override;
    void onWrite(event::BaseEvent *event) override;
    void onClose(event::BaseEvent *event) override;
    void onTimeout(service::v2::TimeoutEvent *event) override;
 
    event::BaseEvent *createEventEx(int fd, unsigned int events, void *data);
    void freeEventEx(sese::event::BaseEvent *event);
 
    void releaseContext(Context *ctx);
 
    static int64_t read(int fd, void *buffer, size_t len, void *ssl);
    static int64_t write(int fd, const void *buffer, size_t len, void *ssl);
 
    IOCPServer *master{};
    std::set<event::BaseEvent *> eventSet;
};
 
} // namespace sese::iocp::v1