Implementando um Servidor / Cliente com protocolo HTTP com Apache Thrift

Eu sou novo em economia de apache. Eu queria usá-lo para me ajudar a implementar um servidor que aceita entrada de um cliente, analisá-lo e, com base nisso, direcioná-lo para a função adequada que, por sua vez, retornaria uma resposta para essa solicitação específica.

Por exemplo:

1. O cliente envia: / get_list / 1 (deve retornar os valores da lista # 1 do servidor)
2. O servidor analisa a entrada para o seguinte: get_list && 1
3. O servidor mapeia isso para um get_list_req que é uma estrutura que tem apenas um parâmetro: i32_t id (que neste caso seria 1)
4. O servidor envia isso para a função getListReq que deve retornar a estrutura get_list_resp que tem 1 parâmetro: list list_content.

Agora eu defini as estruturas necessárias em mylist.thrift:

struct TGetListRequest {
    1: i32_t id,
}
struct TGetListResponse {
    1: string response_code, //FAIL or SUCCESS
    2: list<string> nodes, 
}

service TmyListService {

    TGetListResponse getListReq( 1:TGetListRequest arg ),
}

Agora, isso gera os arquivos necessários:

TmyListService_server.skeleton.cpp 
TmyListService.cpp
TmyListService.h
mylistconstants.cpp
mylistconstants.h
mylisttypes.cpp
mylisttypes.h

O conteúdo do primeiro arquivo é copiado para TmyListService_server.cpp onde a classe é implementada com seu método: getListReq da seguinte maneira:

class TGetListRequestHandler: public TGetListRequestIf {
public:
    TGetListResponse getListReq(TGetListRequest arg){
        ...
    }
};

Forneci nele o seguinte código para iniciar o servidor na função main ():

int main(int argc, char **argv)  {
  int port = 9090;
  shared_ptr<TmyListServiceHandler> handler(new TmyListServiceHandler());
  shared_ptr<TProcessor> processor(new TmyListServiceProcessor(handler));
  shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
  shared_ptr<TTransportFactory> transportFactory(new  TBufferedTransportFactory());
  shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());

  TSimpleServer server(processor, serverTransport, transportFactory,     protocolFactory);
  server.serve();
  return 0;
}

Agora vem a parte complicada para mim:

1. Onde posso implementar a análise da entrada proveniente de um cliente para o servidor? Disseram-me que é uma implementação simples usando thrift sem a necessidade de escrever seu nosso analisador ou usar um gerador de analisador? Eu não consigo descobrir isso? Onde estou dizendo ao meu servidor o que fazer com a entrada, ou seja, para qual função Req devo direcioná-la?

2. Em termos de implementação do cliente, tenho o seguinte:

   int main(int argc, char **argv) {
    boost::shared_ptr<TSocket> socket(new TSocket("localhost", 9090));
    boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
    boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
   
    TmyListServiceClient client(protocol);
    TGetListRequest arg;
    arg.id = 1;
    TGetListResponse argz;
    transport->open();
    client.send_getListReq( arg );
    printf("DONE SEDNING");
    client.recv_getListReq( argz );
    transport->close();
   
   return 0;
   }
   

Basicamente, isso não faz nada além de abrir a conexão do cliente. Ele não aceita nenhuma entrada. Tenho certeza de que isso também está relacionado à implementação da lógica de processamento no servidor primeiro, mas o que devo fazer aqui para ter um cliente pronto para ser testado no servidor?