TooTone's questions

Temos usado o excelente cpp-httlib para fazer solicitações REST. Agora gostaríamos de usá-lo para um servidor. Bem no topo da documentação está:

Importante

Esta biblioteca usa E/S de soquete 'bloqueantes'. Se você está procurando uma biblioteca com E/S de soquete 'não bloqueadoras', esta não é a que você quer.

Não tenho certeza do que isso significa em um sentido prático, pois, embora eu entenda os princípios básicos de IP/UDP/TCP etc., não estou familiarizado com programação de socket. Testei o servidor disparando várias solicitações para ele, por exemplo, se a primeira solicitação for implementada dormindo por 30s, uma segunda solicitação "hello world" ainda retorna imediatamente.

Depurando o código, vejo que o thread principal é executado:

    while (svr_sock_ != INVALID_SOCKET) {
      // socket operations 

      if (!task_queue->enqueue(
              [this, sock]() { process_and_close_socket(sock); })) {
        detail::shutdown_socket(sock);
        detail::close_socket(sock);
      }
    }

Os threads de trabalho são executados

      for (;;) {
        std::function<void()> fn;
        {
          // Lock / wait for new request

          fn = pool_.jobs_.front();
          pool_.jobs_.pop_front();
        }
        fn();
      }

ou seja, o thread principal é como um loop de eventos em um aplicativo GUI, recebendo cada solicitação recebida, mas em vez de executar a solicitação em si, ele a coloca em uma fila para que os threads de trabalho a peguem.

Anteriormente eu estava encerrando chamadas para C++ em um servidor web Python FastAPI, o que é bom, mas executar Python e C++ claramente adiciona sobrecarga/complexidade, e não é totalmente simples entender como as solicitações são executadas em relação ao bloqueio global do interpretador. A abordagem direta do C++ usando cpp-httlib parece muito melhor, mas o comentário sobre 'bloquear' E/S de socket me preocupa. O que estou perdendo ao não usar E/S de socket não bloqueantes?

(O servidor será construído para Windows e Linux; no entanto, a produção será Linux.)

Parte do código que estou escrevendo é parametrizado por uma lista de tipos e, nos moldes desta resposta , estou usando uma estrutura wrapper

template <typename... T>
struct types
{
};

para que eu possa escrever código como using MyTypes = types<int, double>e depois usar MyTypescomo parâmetro para gerar outros tipos, como tuplas de funções dos tipos.

Vou ter funções que só devem aceitar tipos da lista como parâmetro. Portanto, o que eu gostaria é de ter um genérico concept IsAnyOfTypes, para poder escrever código como template <typename T> concept MyType = IsAnyOfTypes<T, ListOfTypes >. Como posso escrever esse conceito de forma simples?

Idealmente, eu gostaria de conectar esse conceito/adotar uma abordagem semelhante à IsAnyOfreferência C++ .

template <typename T, typename... U>
concept IsAnyOf = (std::same_as<T, U> || ...);

Eu tenho uma implementação funcional que está usando std::tuple, mas queria uma abordagem mais direta, especialmente porque prefiro não usar modelos recursivos onde posso evitá-lo.

template <template <typename> typename F, typename... T>
static std::tuple<F<T>...> tuple_of_f(types<T...>);
template <template <typename> typename F, typename Types>
using TupleOfF = decltype(tuple_of_f<F>(std::declval<Types>()));

template <typename T, typename Types>
concept IsAnyOfTypes = requires() { std::get<T>(std::declval<TupleOf<Types>>()); };