#include <boost/lexical_cast.hpp>
#include <boost/test/minimal.hpp>
#include <RCF/FilterService.hpp>
#include <RCF/RcfServer.hpp>
#include <RCF/OpenSslEncryptionFilter.hpp>
#include <RCF/TcpEndpoint.hpp>
#include <RCF/ZlibCompressionFilter.hpp>
#include <RCF/test/EndpointFactories.hpp>
#include <RCF/test/TransportFactories.hpp>
#include <RCF/util/AutoBuild.hpp>
#include <RCF/util/CommandLine.hpp>
#include <RCF/util/PortNumbers.hpp>
#include "Test_Performance.hpp"
int test_main(int argc, char **argv)
{
util::CommandLineOption<std::string> scert("scert", TEMP_DIR "server.pem", "OpenSSL server certificate");
util::CommandLineOption<std::string> spwd("spwd", "mt2316", "OpenSSL server certificate password");
util::CommandLineOption<std::string> ccert("ccert", TEMP_DIR "client.pem", "OpenSSL client certificate");
util::CommandLineOption<std::string> cpwd("cpwd", "mt2316", "OpenSSL client certificate password");
util::CommandLineOption<int> calls( "calls", 1000, "number of calls");
util::CommandLineOption<int> test( "test", 0, "which test to run, 0 to run them all");
util::CommandLine::getSingleton().parse(argc, argv);
std::string clientCertificateFile = ccert;
std::string clientCertificateFilePassword = cpwd;
std::string serverCertificateFile = scert;
std::string serverCertificateFilePassword = spwd;
int requestedTest = test;
int currentTest = 0;
if (requestedTest == 0)
{
// test all serialization protocols over a TCP transport
std::string ip = "localhost";
int port = util::Ports::getNext();
RCF::TcpEndpoint serverEndpoint(port);
RCF::TcpEndpoint clientEndpoint(ip, port);
RCF::RcfServer server(serverEndpoint);
server.bind<I_X>( boost::shared_ptr<X>(new X) );
server.start();
std::string title = "TcpEndpoint transport: ";
runClientTests(clientEndpoint, calls, title);
}
// test all transports, against the standard serialization protocol
for (unsigned int i=0; i<RCF::getTransportFactories().size(); ++i)
{
RCF::TransportFactoryPtr transportFactoryPtr = RCF::getTransportFactories()[i];
std::pair<RCF::ServerTransportPtr, RCF::ClientTransportAutoPtrPtr> transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
RCF::writeTransportTypes(std::cout, *serverTransportPtr, *clientTransportAutoPtr);
std::string s0 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
s0 = s0 + s0;
s0 = s0 + s0;
s0 = s0 + s0;
int serializationProtocol = 1;
++currentTest;
if (requestedTest == 0 || requestedTest == currentTest)
{
std::string title = "Test " + boost::lexical_cast<std::string>(currentTest) + ": ";
runPerformanceTest(
title,
clientTransportAutoPtr,
serverTransportPtr,
RCF::Twoway,
s0,
serializationProtocol,
std::vector<RCF::FilterFactoryPtr>(),//filterFactories,
std::vector<RCF::FilterPtr>(),
std::vector<RCF::FilterPtr>(),
calls);
}
}
std::string s0 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
s0 = s0 + s0;
s0 = s0 + s0;
s0 = s0 + s0;
int serializationProtocol = 1;
// test compression and encryption filters, over TCP
{
std::vector<std::vector<RCF::FilterPtr> > payloadFilterChains;
std::vector<RCF::FilterPtr> payloadFilterChain;
payloadFilterChain.clear();
payloadFilterChain.push_back( RCF::FilterPtr(new RCF::ZlibStatefulCompressionFilter()) );
payloadFilterChains.push_back(payloadFilterChain);
payloadFilterChain.clear();
payloadFilterChain.push_back( RCF::FilterPtr(new RCF::ZlibStatelessCompressionFilter()) );
payloadFilterChains.push_back(payloadFilterChain);
std::vector<std::vector<RCF::FilterPtr> > transportFilterChains;
std::vector<RCF::FilterPtr> transportFilterChain;
transportFilterChain.clear();
transportFilterChain.push_back( RCF::FilterPtr(new RCF::ZlibStatefulCompressionFilter()) );
transportFilterChains.push_back(transportFilterChain);
transportFilterChain.clear();
transportFilterChain.push_back( RCF::FilterPtr(new RCF::ZlibStatelessCompressionFilter()) );
transportFilterChains.push_back(transportFilterChain);
transportFilterChain.clear();
transportFilterChain.push_back( RCF::FilterPtr(new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword)) );
transportFilterChains.push_back(transportFilterChain);
transportFilterChain.clear();
transportFilterChain.push_back( RCF::FilterPtr(new RCF::ZlibStatelessCompressionFilter()) );
transportFilterChain.push_back( RCF::FilterPtr(new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword)) );
transportFilterChains.push_back(transportFilterChain);
transportFilterChain.clear();
transportFilterChain.push_back( RCF::FilterPtr(new RCF::ZlibStatefulCompressionFilter()) );
transportFilterChain.push_back( RCF::FilterPtr(new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword)) );
transportFilterChains.push_back(transportFilterChain);
std::vector<RCF::FilterFactoryPtr> filterFactories;
filterFactories.push_back(RCF::FilterFactoryPtr( new RCF::ZlibStatelessCompressionFilterFactory() ));
filterFactories.push_back(RCF::FilterFactoryPtr( new RCF::ZlibStatefulCompressionFilterFactory() ));
filterFactories.push_back(RCF::FilterFactoryPtr( new RCF::OpenSslEncryptionFilterFactory(serverCertificateFile, serverCertificateFilePassword) ));
// test payload filters
for (unsigned int i=0; i<payloadFilterChains.size(); ++i)
{
RCF::TcpEndpoint tcpEndpoint("localhost", util::Ports::getNext());
RCF::ServerTransportPtr serverTransportPtr( tcpEndpoint.createServerTransport().release() );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( tcpEndpoint.createClientTransport() );
++currentTest;
if (requestedTest == 0 || requestedTest == currentTest)
{
std::string title = "Test " + boost::lexical_cast<std::string>(currentTest) + ": ";
runPerformanceTest(
title,
clientTransportAutoPtr,
serverTransportPtr,
RCF::Twoway,
s0,
serializationProtocol,
filterFactories,
payloadFilterChains[i],
std::vector<RCF::FilterPtr>(),
calls);
}
}
// test transport filters
for (unsigned int i=0; i<transportFilterChains.size(); ++i)
{
#ifdef RCF_USE_BOOST_ASIO
RCF::TransportFactoryPtr transportFactoryPtr( new RCF::TcpAsioTransportFactory() );
#elif defined BOOST_WINDOWS
RCF::TransportFactoryPtr transportFactoryPtr( new RCF::TcpIocpTransportFactory() );
#else
#error no supported server transports
#endif
std::pair<RCF::ServerTransportPtr, RCF::ClientTransportAutoPtrPtr> transports = transportFactoryPtr->createTransports();
RCF::ServerTransportPtr serverTransportPtr( transports.first );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );
++currentTest;
if (requestedTest == 0 || requestedTest == currentTest)
{
std::string title = "Test " + boost::lexical_cast<std::string>(currentTest) + ": ";
runPerformanceTest(
title,
clientTransportAutoPtr,
serverTransportPtr,
RCF::Twoway,
s0,
serializationProtocol,
filterFactories,
std::vector<RCF::FilterPtr>(),
transportFilterChains[i],
calls);
}
}
}
// test oneway invocations
{
RCF::TcpEndpoint tcpEndpoint("localhost", util::Ports::getNext());
RCF::ServerTransportPtr serverTransportPtr( tcpEndpoint.createServerTransport().release() );
RCF::ClientTransportAutoPtr clientTransportAutoPtr( tcpEndpoint.createClientTransport() );
++currentTest;
if (requestedTest == 0 || requestedTest == currentTest)
{
std::string title = "Test " + boost::lexical_cast<std::string>(currentTest) + ": ";
runPerformanceTest(
title,
clientTransportAutoPtr,
serverTransportPtr,
RCF::Oneway,
s0,
serializationProtocol,
std::vector<RCF::FilterFactoryPtr>(),
std::vector<RCF::FilterPtr>(),
std::vector<RCF::FilterPtr>(),
calls);
}
}
return boost::exit_success;
}