BroadcastProxy.cpp File Reference

#include <folly/portability/GFlags.h>
#include <folly/init/Init.h>
#include <wangle/bootstrap/AcceptRoutingHandler.h>
#include <wangle/bootstrap/RoutingDataHandler.h>
#include <wangle/bootstrap/ServerBootstrap.h>
#include <wangle/channel/AsyncSocketHandler.h>
#include <wangle/channel/broadcast/BroadcastHandler.h>
#include <wangle/channel/broadcast/BroadcastPool.h>
#include <wangle/channel/broadcast/ObservingHandler.h>
#include <wangle/codec/ByteToMessageDecoder.h>
#include <wangle/codec/MessageToByteEncoder.h>

Go to the source code of this file.

Classes
class	ByteToStringDecoder
class	StringToByteEncoder
class	ClientIPRoutingDataHandler
class	ClientIPRoutingDataHandlerFactory
class	SimpleServerPool
class	SimpleBroadcastPipelineFactory
class	SimpleObservingPipelineFactory

Typedefs
using	SimpleObservingPipeline = ObservingPipeline< std::string >

Functions
	DEFINE_int32 (port, 8080,"Broadcast proxy port")
	DEFINE_int32 (upstream_port, 8081,"Upstream server port")
int	main (int argc, char **argv)

Typedef Documentation

using SimpleObservingPipeline = ObservingPipeline<std::string>

Definition at line 176 of file BroadcastProxy.cpp.

Function Documentation

DEFINE_int32	(	port	,
		8080	,
		"Broadcast proxy port"
	)

DEFINE_int32	(	upstream_port	,
		8081	,
		"Upstream server port"
	)

int main	(	int	argc,
		char **	argv
	)

Definition at line 212 of file BroadcastProxy.cpp.

References folly::init().

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

  auto serverPool = std::make_shared<SimpleServerPool>();

  // A unique BroadcastPipeline for each upstream server to fan-out the
  // upstream messages to ObservingPipelines corresponding to each client.
  auto broadcastPipelineFactory =
      std::make_shared<SimpleBroadcastPipelineFactory>();

  // A unique ObservingPipeline is created for each client to subscribe
  // to the broadcast.
  auto observingPipelineFactory =
      std::make_shared<SimpleObservingPipelineFactory>(
          serverPool, broadcastPipelineFactory);

  // RoutingDataHandlerFactory for creating the RoutingDataHandler that sets
  // client IP as the routing data.
  auto routingHandlerFactory =
      std::make_shared<ClientIPRoutingDataHandlerFactory>();

  ServerBootstrap<SimpleObservingPipeline> server;

  // AcceptRoutingPipelineFactory for creating accept pipelines hash the
  // client connection to a worker thread based on client IP.
  auto acceptPipelineFactory = std::make_shared<
      AcceptRoutingPipelineFactory<SimpleObservingPipeline, std::string>>(
      &server, routingHandlerFactory, observingPipelineFactory);

  server.pipeline(acceptPipelineFactory);
  server.bind(FLAGS_port);
  server.waitForStop();

  return 0;
}