How to assign API path by listener (port)?

[requinham]

I am using drogon C++ framework to develop a Restful server. I define two HttpController one for administration and another for applicative apis. I defined two listeners (two ports) in config file and I want to restrict access admin through one listener and access applicative api through the other.
Is there a parameter to specify listener or do I need to code something (middleware, filter, etc.) that implement all the logic?

[an-tao]

Currently, all handlers are registered globally to every listener, with no capability for listener-specific handler registration. To address this limitation, I recommend implementing an AOP pre-routing advice or a filter to encapsulate the necessary logic.

[requinham]

@an-tao thank you for your confirmation so if we have to use filter, middleware, I share this code for everyone who wants to create quickly filters for this needs:

Put your port in custom_config part of drogon config.json

#pragma once
#include <drogon/HttpFilter.h>
#include <drogon/HttpRequest.h>
#include <drogon/HttpResponse.h>
#include <drogon/utils/FunctionTraits.h>
#include <drogon/HttpAppFramework.h>
#include <json/value.h>
#include <drogon/drogon.h>
#include <stdexcept>

template <typename ConfigTag>
class NamedPortFilter : public drogon::HttpFilter<NamedPortFilter<ConfigTag>>
{
public:
    NamedPortFilter()
    {
        static bool initialized = false;
        static uint16_t s_port = 0;

        if (!initialized)
        {
            auto config = drogon::app().getCustomConfig();

            // The ConfigTag struct can hold a static const char* that we use to retrieve the config key
            constexpr auto key = ConfigTag::Key;
            if (!config.isMember(key))
            {
                LOG_FATAL << "Missing key '" << key << "' in config!";
                throw std::runtime_error("Missing port config key");
            }
            s_port = config[key].asUInt();
            // Fallback if not assigned or malformed
            if (s_port == 0)
            {
                s_port = ConfigTag::DefaultPortValue; // default value in general
            }
            initialized = true;
        }

        port_ = s_port;
    }

    void doFilter(const drogon::HttpRequestPtr &req,
                  drogon::FilterCallback &&fcb,
                  drogon::FilterChainCallback &&fccb) override
    {
        if (req->getLocalAddr().toPort() != port_)
        {
            auto resp = drogon::HttpResponse::newNotFoundResponse();
            fcb(resp);
            return;
        }
        fccb();
    }

protected:
    uint16_t port_;
};

struct AdminPortTag
{
    static constexpr const char *Key = "AdminPort";
    static constexpr const uint16_t DefaultPortValue = 8005;
};
struct ApplicativePortTag
{
    static constexpr const char *Key = "applicativePort";
    static constexpr const uint16_t DefaultPortValue = 8004;
};

// Now define my lovely filters
template class NamedPortFilter<AdminPortTag>;
template class NamedPortFilter<ApplicativePortTag>;