RpcClient.cpp File Reference

#include <gflags/gflags.h>
#include <folly/init/Init.h>
#include <wangle/service/Service.h>
#include <wangle/service/ExpiringFilter.h>
#include <wangle/service/ClientDispatcher.h>
#include <wangle/bootstrap/ClientBootstrap.h>
#include <wangle/channel/AsyncSocketHandler.h>
#include <wangle/codec/LengthFieldBasedFrameDecoder.h>
#include <wangle/codec/LengthFieldPrepender.h>
#include <wangle/channel/EventBaseHandler.h>
#include <wangle/example/rpc/ClientSerializeHandler.h>

Go to the source code of this file.

Classes
class	RpcPipelineFactory
class	BonkMultiplexClientDispatcher

Typedefs
using	SerializePipeline = wangle::Pipeline< IOBufQueue &, Bonk >

Functions
	DEFINE_int32 (port, 8080,"test server port")
	DEFINE_string (host,"::1","test server address")
int	main (int argc, char **argv)

Typedef Documentation

using SerializePipeline = wangle::Pipeline<IOBufQueue&, Bonk>

Definition at line 37 of file RpcClient.cpp.

Function Documentation

DEFINE_int32	(	port	,
		8080	,
		"test server port"
	)

DEFINE_string	(	host	,
		"::1"	,
		"test server address"
	)

int main	(	int	argc,
		char **	argv
	)

For specific protocols, all the following code would be wrapped in a protocol-specific ServiceFactories.

TODO: examples of ServiceFactoryFilters, for connection pooling, etc.

Definition at line 98 of file RpcClient.cpp.

References wangle::ClientBootstrap< Pipeline >::connect(), folly::exceptionStr(), wangle::ClientBootstrap< Pipeline >::group(), folly::init(), and wangle::BaseClientBootstrap< Pipeline >::pipelineFactory().

                                {
  folly::Init init(&argc, &argv);

  ClientBootstrap<SerializePipeline> client;
  client.group(std::make_shared<folly::IOThreadPoolExecutor>(1));
  client.pipelineFactory(std::make_shared<RpcPipelineFactory>());
  auto pipeline = client.connect(SocketAddress(FLAGS_host, FLAGS_port)).get();
  // A serial dispatcher would assert if we tried to send more than one
  // request at a time
  // SerialClientDispatcher<SerializePipeline, Bonk> service;
  // Or we could use a pipelined dispatcher, but responses would always come
  // back in order
  // PipelinedClientDispatcher<SerializePipeline, Bonk> service;
  auto dispatcher = std::make_shared<BonkMultiplexClientDispatcher>();
  dispatcher->setPipeline(pipeline);

  // Set an idle timeout of 5s using a filter.
  ExpiringFilter<Bonk, Xtruct> service(dispatcher, std::chrono::seconds(5));

  try {
    while (true) {
      std::cout << "Input string and int" << std::endl;

      Bonk request;
      std::cin >> request.message;
      std::cin >> request.type;
      service(request).thenValue([request](Xtruct response) {
        CHECK(request.type == response.i32_thing);
        std::cout << response.string_thing << std::endl;
      });
    }
  } catch (const std::exception& e) {
    std::cout << exceptionStr(e) << std::endl;
  }

  return 0;
}