问“跟踪”与Thrift的连接
EN

Stack Overflow用户

提问于 2010-04-14 19:14:30

回答 2查看 711关注 0票数 1

我正在尝试使用Thrift创建一个游戏，这样客户端就是玩家，服务器管理棋盘，就像this一样。然而，我不明白Facebook的Thrift服务器如何“跟踪”用户，也就是说，当我在their service上调用attack()时，我不需要再次表明自己的身份。

根据生成的服务器存根的建议，没有办法做到这一点：

int main(int argc, char **argv) {
  int port = 9090;
  shared_ptr<ConnectFourHandler> handler(new ConnectFourHandler());
  shared_ptr<TProcessor> processor(new ConnectFourProcessor(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;
}

在该示例中，只为服务器创建了一个处理程序，服务器接受连接。

如果所有请求都只通过每个服务器的一个处理程序进行路由，那么Facebook如何能够跟踪连接到服务器的客户端？

c++

rpc

thrift

回答 2

Stack Overflow用户

发布于 2011-04-13 11:59:05

试试server.setServerEventHandler。它将在新客户端连接时调用您的代码，让您有机会创建特定于连接的上下文对象。

票数 0

Stack Overflow用户

发布于 2018-07-31 19:06:38

因为thrift为每个连接使用唯一的线程，所以可以使用线程id将两者链接在一起。据我所知，节俭本身是无法做到这一点的。如果thrift将上下文字段向下传递到每个处理程序函数，这将是可能的。

下面是一个使用线程id的示例：

#include <map>
#include <thread>

typedef struct {
    // you would put your connection specific variables here
} ConnectionContext;

// You could reverse these types if you had more than one
// context per thrift connection, eg. your service involved opening
// or connecting to more than one thing per thrift connection
std::map<std::thread::id, ConnectionContext> threadContextMap;

class OurEventHandler : public server::TServerEventHandler {
public:
OurEventHandler() :
    NumClients_(0)
{}

//Called before the server begins -
//virtual void preServe() {}

//createContext may return a user-defined context to aid in cleaning
//up client connections upon disconnection. This example dispenses
//with contextual information and returns NULL.
virtual void* createContext(shared_ptr<protocol::TProtocol> input, 
shared_ptr<protocol::TProtocol> output)
{
    printf("Client connected (total %d)\n", ++NumClients_);

    auto this_id = std::this_thread::get_id();
    std::cout << "connected thread " << this_id << std::endl;

    return NULL;
}

//Called when an client has disconnected, either naturally or by error.
virtual void deleteContext(void* serverContext, 
shared_ptr<protocol::TProtocol>input, shared_ptr<protocol::TProtocol>output)
{
    printf("Client disconnected (total %d)\n", --NumClients_);

    auto this_id = std::this_thread::get_id();
    std::cout << "disconnected thread " << this_id << std::endl;

    auto context = threadContextMap[this_id];

    // TODO: Perform your context specific cleanup code here
}

protected:
    uint32_t NumClients_;
};


class yourRpcHandler : virtual public service_rpcIf
{
public:
    yourRpcHandler() :
    {
        // Your initialization goes here
    }

    void SomeMethod()
    {
        auto context = threadContextMap[std::this_thread::get_id()];

        // TODO: use the context as you see fit
    }
};

int main(int argc, char **argv)
{
    int port = 9090;
    printf("Listening on port %d\n", port);

    auto rpcHandler = new yourRpcHandler();
    shared_ptr<yourRpcHandler> handler(rpcHandler);
    shared_ptr<TProcessor> processor(new yourRpcProcessor(handler));
    shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
    shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());

    TThreadedServer server(processor, serverTransport, transportFactory, protocolFactory);
    shared_ptr<OurEventHandler> EventHandler(new OurEventHandler());

    server.setServerEventHandler(EventHandler);
    server.serve();
    return 0;
}