вторник, 16 апреля 2013 г.

Собственный плагин tsung

Давно хотел написать про tsung - замечательный инструмент для нагрузочного тестирования сервера. Замечательных сторон у tsung много, я назову три основные:
  1. Поддержка большого числа протоколов и типов серверов, среди них http, jabber, SOAP, LDAP, MySQL, Postgres, NFS и др.
  2. Очень гибкая настройка сценариев тестирования, основанная на XML
  3. Высокая скорость работы и возможность создания ботнетов из клиентов
Последнее качество обеспечивается тем, что tsung написан на Erlang.

Но что делать, если мы хотим протестировать наш собственный кастомный протокол, используя все вкусности, который предоставляет tsung? Ответ: написать плагин для tsung. Судя по всему раньше в сети была некая инструкция или статья о том, как это сделать, но сейчас она недоступна. Все, что я нашел, это небольшая статья с общими тезисами, расположенная здесь. Однако, ее оказалось достаточно для начала работы.

Итак, приступим к созданию тестового плагина tsung. Прежде всего определимся с протоколом. Пусть клиент посылает произвольную строку, а сервер вычисляет ее md5 хэш и возвращает исходную строку и хэш. Детали таковы - клиент и сервер сериализуют посылаемые данные во внутренние структуры с помощью boost::serialization. Для указания размера сериализованного архива перед его посылкой и тот и другой отправляют сначала 4 байта со значением размера. После ответа клиенту сервер тут же закрывает соединение.

Данные для сериализации поместим в файл data.h:
#ifndef DATA_H
#define DATA_H

#include <string>
#include <boost/serialization/string.hpp>

struct  Request
{
    std::string  value;

    template < typename  Archive >
    void  serialize( Archive &  ar, unsigned int  /* version */ )
    {
        ar & value;
    }
};

struct  Reply
{
    std::string  value;

    std::string  md5hex;

    template < typename  Archive >
    void  serialize( Archive &  ar, unsigned int  /* version */ )
    {
        ar & value;
        ar & md5hex;
    }
};

#endif
Тут все просто. Сервер построим на основе асинхронной модели boost::asio. Я опять-таки не буду вдаваться в подробности, поскольку это один из примеров, которые можно найти здесь, адаптированный под наш протокол. Для вычисления md5 хэша использована библиотека OpenSSL.
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/cstdint.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <openssl/md5.h>
#include <arpa/inet.h>

#include "data.h"

using namespace  boost::asio;
using            boost::asio::ip::tcp;

namespace
{
    void  calc_md5hex( unsigned char  src[ MD5_DIGEST_LENGTH ],
                       char  dst[ MD5_DIGEST_LENGTH * 2 ] )
    {
        std::sprintf( dst, "%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x"
                           "%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
                      src[ 0 ],  src[ 1 ],  src[ 2 ],  src[ 3 ],
                      src[ 4 ],  src[ 5 ],  src[ 6 ],  src[ 7 ],
                      src[ 8 ],  src[ 9 ],  src[ 10 ], src[ 11 ],
                      src[ 12 ], src[ 13 ], src[ 14 ], src[ 15 ] );
    }
}

class  Session
{
    public:
        explicit Session( io_service &  io ) : socket_( io ), size_( 0 )
        {
        }

        tcp::socket &  socket( void )
        {
            return socket_;
        }

        void  start( void )
        {
            async_read( socket_, buffer( data_, sizeof( boost::uint32_t ) ),
                        boost::bind( &Session::handle_read_size, this,
                                     placeholders::error,
                                     placeholders::bytes_transferred ) );
        }

    private:
        void handle_read_size( const boost::system::error_code &  error,
                               size_t  bytes_transferred )
        {
            if ( ! error )
            {
                size_ =  *( ( boost::uint32_t * )data_ );

                async_read( socket_, buffer( data_, ntohl( size_ ) ),
                            boost::bind( &Session::handle_read, this,
                                         placeholders::error,
                                         placeholders::bytes_transferred ) );
            }
            else
            {
                delete this;
            }
        }

        void handle_read( const boost::system::error_code &  error,
                          size_t  bytes_transferred )
        {
            if ( ! error )
            {
                std::istringstream  message_str;
                Request             request;

                message_str.str( std::string( data_, bytes_transferred ) );

                {
                    boost::archive::binary_iarchive  archive( message_str );
                    archive >> request;
                }

                std::ostringstream  reply_str;
                unsigned char       md5sum[ MD5_DIGEST_LENGTH ];
                char                md5hex[ MD5_DIGEST_LENGTH * 2 ];

                MD5( ( unsigned char * )request.value.c_str(),
                     request.value.size(), md5sum );

                calc_md5hex( md5sum, md5hex );

                Reply  reply = { request.value, md5hex };

                {
                    boost::archive::binary_oarchive  archive( reply_str );
                    archive << reply;
                }

                std::string  data( reply_str.str() );

                if ( data.size() > max_length )
                    throw std::runtime_error( "Too big message" );

                std::memcpy( data_, data.c_str(), data.size() );

                size_ = htonl( data.size() );

                async_write( socket_,
                             buffer( &size_, sizeof( boost::uint32_t ) ),
                             boost::bind( &Session::handle_write_size, this,
                                          boost::asio::placeholders::error,
                                          bytes_transferred ) );
            }
            else
            {
                delete this;
            }
        }

        void handle_write_size( const boost::system::error_code &  error,
                                size_t  size )
        {
            if ( ! error )
            {
                async_write( socket_, buffer( data_, ntohl( size_ ) ),
                             boost::bind( &Session::handle_write, this,
                                          boost::asio::placeholders::error ) );
            }
            else
            {
                delete this;
            }
        }

        void handle_write( const boost::system::error_code &  error )
        {
            if ( ! error )
            {
                socket_.shutdown( tcp::socket::shutdown_both );
            }
            else
            {
                delete this;
            }
        }
    private:
        enum { max_length = 1024 };

    private:
        tcp::socket      socket_;

        char             data_[ max_length ];

        boost::uint32_t  size_;
};

class  Server
{
    public:
        Server( io_service &  io, short  port ) : io_( io ),
            acceptor_( io_, tcp::endpoint( tcp::v4(), port ) )
        {
            start_accept();
        }

    private:
        void  start_accept( void )
        {
            Session *  new_session = new Session( io_ );

            acceptor_.async_accept( new_session->socket(),
                                    boost::bind( &Server::handle_accept, this,
                                        new_session, placeholders::error ) );
        }

        void  handle_accept( Session *  new_session,
                                    const boost::system::error_code &  error )
        {
            if ( ! error )
            {
                new_session->start();
            }
            else
            {
                delete new_session;
            }

            start_accept();
        }

    private:
        io_service &   io_;

        tcp::acceptor  acceptor_;
};

int  main( int  argc, char *  argv[] )
{
    try
    {
        if ( argc != 2 )
        {
            std::cerr << "Usage: server <port>\n";

            return 1;
        }

        io_service  io_;

        Server  serv( io_, std::atoi( argv[ 1 ] ) );

        io_.run();
    }
    catch ( const std::exception &  e )
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}
Теперь напишем элементарный тестовый синхронный клиент (файл client.cc).
#include <cstring>
#include <sstream>
#include <iostream>
#include <boost/asio.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/cstdint.hpp>
#include <arpa/inet.h>

#include "data.h"

using namespace  boost::asio;
using            boost::asio::ip::tcp;

namespace
{
    enum { max_length = 1024 };
}

int  main( int  argc, char *  argv[] )
{
    try
    {
        if ( argc != 3 )
        {
            std::cerr << "Usage: client <host> <port>\n";

            return 1;
        }

        io_service  io_;

        tcp::resolver            resolver( io_ );
        tcp::resolver::query     query( tcp::v4(), argv[ 1 ], argv[ 2 ] );
        tcp::resolver::iterator  iterator( resolver.resolve( query ) );
        tcp::socket              sock( io_ );

        connect( sock, iterator );

        std::cout << "Enter message: ";

        char  message[ max_length ];

        std::cin.getline( message, max_length );

        std::ostringstream  message_str;
        Request             request = { message };

        {
            boost::archive::binary_oarchive  archive( message_str );
            archive << request;
        }

        std::string  data( message_str.str() );

        if ( data.size() > max_length )
            throw std::runtime_error( "Too big message" );

        boost::uint32_t  size( htonl( data.size() ) );

        write( sock, buffer( &size, sizeof( boost::uint32_t ) ) );
        write( sock, buffer( data.c_str(), data.size() ) );

        size_t    reply_length( read( sock, buffer( message,
                                                sizeof( boost::uint32_t ) ) ) );

        if ( reply_length != sizeof( boost::uint32_t ) )
            throw std::runtime_error( "Error while reading message size" );

        size = ntohl( *( ( boost::uint32_t * )message ) );

        reply_length = read( sock, buffer( message, size ) );

        if ( reply_length != size )
            throw std::runtime_error( "Error while reading message" );

        std::istringstream  reply_str;
        Reply               reply;

        reply_str.str( std::string( message, size ) );

        {
            boost::archive::binary_iarchive  archive( reply_str );
            archive >> reply;
        }

        std::cout << "Reply is: {'" << reply.value << "', '" << reply.md5hex <<
                "'}" << std::endl;
    }
    catch ( const std::exception &  e )
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}
Скомпилируем сервер и клиент и запустим их на выполнение.
g++ -Wall -g -o server server.cc -lboost_system-mt -lboost_serialization-mt \
        -lcrypto -lpthread
g++ -Wall -g -o client client.cc -lboost_system-mt -lboost_serialization-mt \
         -lpthread
./server 5555
(я разбил команды g++ на две строки, чтобы они уместились по ширине в колонку блога), в другом терминале запустим клиент:
./client localhost 5555
Enter message: Hello world!
Reply is: {'Hello world!', '86fb269d190d2c85f6e0468ceca42a20'}
Отлично, работает. Однако, для тестирования с помощью tsung тестовый клиент нам не нужен, поскольку tsung должен сам уметь отправлять клиентские запросы на сервер. Поскольку tsung написан на Erlang, а привязку к boost::serialization вряд ли получится просто реализовать на Erlang, то нам понадобится интерфейс erl_nif (NIF расшифровывается как Native Implemented Functions). Хороший пример его использования можно найти здесь. Поместим наш C++ интерфейс в файл erl_nif.cc:
#include <erl_nif.h>

#include <cstring>
#include <sstream>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/cstdint.hpp>
#include <arpa/inet.h>

#include "data.h"

namespace
{
    enum { max_length = 1024 };
}

extern "C"
{
    static ERL_NIF_TERM  request( ErlNifEnv *  env, int  argc,
                                  const ERL_NIF_TERM  argv[] )
    {
        if ( argc < 1 )
            return enif_make_badarg( env );

        char    message[ max_length + sizeof( boost::uint32_t ) ];
        size_t  len( 0 );

        if ( ( len = enif_get_string( env, argv[ 0 ],
                                      message + sizeof( boost::uint32_t ),
                                      max_length, ERL_NIF_LATIN1 ) ) <= 0 )
            return enif_make_badarg( env );

        std::ostringstream  message_str;
        Request             request = { message + sizeof( boost::uint32_t ) };

        {
            boost::archive::binary_oarchive  archive( message_str );
            archive << request;
        }

        std::string        data( message_str.str() );
        boost::uint32_t *  size( ( boost::uint32_t * )&message[ 0 ] );

        *size = htonl( data.size() );

        ErlNifBinary       result;

        enif_alloc_binary( sizeof( boost::uint32_t ) + ntohl( *size ), &result );

        std::memcpy( message + sizeof( boost::uint32_t ), data.c_str(),
                     data.size() );
        std::memcpy( result.data, message,
                     sizeof( boost::uint32_t ) + ntohl( *size ) );

        result.size = sizeof( boost::uint32_t ) + ntohl( *size );

        return enif_make_binary( env, &result );
    }

    static ERL_NIF_TERM  response( ErlNifEnv *  env, int  argc,
                                   const ERL_NIF_TERM  argv[] )
    {
        if ( argc < 1 )
            return enif_make_badarg( env );

        ERL_NIF_TERM  message( argv[ 0 ] );

        if ( ! enif_is_binary( env, message ) )
            return enif_make_badarg( env );

        ErlNifBinary    bin;

        enif_inspect_binary( env, message, &bin );

        if ( bin.size < sizeof( boost::uint32_t ) )
            return enif_make_badarg( env );

        //boost::uint32_t *  size( ( boost::uint32_t * )&bin.data );

        //if ( bin.size != sizeof( boost::uint32_t ) + ntohl( *size ) )
            //return enif_make_badarg( env );

        std::istringstream  reply_str;
        Reply               reply;

        reply_str.str( std::string(
                                ( char * )bin.data + sizeof( boost::uint32_t ),
                                bin.size - sizeof( boost::uint32_t ) ) );

        {
            boost::archive::binary_iarchive  archive( reply_str );
            archive >> reply;
        }

        ErlNifBinary  value;
        ErlNifBinary  md5hex;

        enif_alloc_binary( reply.value.size(), &value );
        std::memcpy( value.data, reply.value.c_str(), reply.value.size() );
        value.size = reply.value.size();

        enif_alloc_binary( reply.md5hex.size(), &md5hex );
        std::memcpy( md5hex.data, reply.md5hex.c_str(), reply.md5hex.size() );
        md5hex.size = reply.md5hex.size();

        return enif_make_tuple2( env, enif_make_binary( env, &value ),
                                 enif_make_binary( env, &md5hex ) );
    }

    static ErlNifFunc  ts_p_md5hex_funcs[] =
    {
        { "request", 1, request },
        { "response", 1, response }
    };
}

ERL_NIF_INIT( ts_p_md5hex_nif, ts_p_md5hex_funcs, NULL, NULL, NULL, NULL )
Здесь нужны небольшие пояснения, хотя сам код достаточно прозрачен. Во-первых, здесь мы определили две эрланговские функции request() и response() и задали имя будущего эрланговского модуля ts_p_md5hex_nif (в данном случае я использую p_, подразумевая слово plugin, хотя это увеличит в дальнейшем размеры имен в коде на Erlang). Эти определения реализуются в самой последней строке приведенного кода. Запрос в функции request() отличается от аналога из client.cc тем, что размер и сериализованный архив посылаются в одном запросе, но это не должно быть существенным различием. Функция request() возвращает буфер типа ErlNifBinary, готовый к отправке на сервер. Функция response() наоборот, парсит ответ сервера и возвращает кортеж (tuple), содержащий в себе исходную строку и вычисленный хэш. Вычисление размера архива (первые 4 байта в ответе сервера) в функции response() закомментировано, так как этот размер нам не нужен - сервер сам разрывает соединение после посылки ответа, и tsung это легко обнаружит самостоятельно.

Компилируем erl_nif.cc в разделяемую библиотеку ts_p_md5hex_nif.so (не забудьте предварительно установить Erlang, причем не старше версии R14B, поскольку erl_nif в более старых версиях не поддерживается).
g++ -Wall -fPIC -shared -o ts_p_md5hex_nif.so -I/usr/lib64/erlang/usr/include \
 erl_nif.cc -lboost_system-mt -lboost_serialization-mt -lpthread
Теперь напишем эрланговский интерфейс к erl_nif.cc, назовем его ts_p_md5hex_nif.erl.
-module(ts_p_md5hex_nif).
-author('garuda @ blogspot.com').

-export([request/1response/1]).

-on_load(init/0).

init() ->
    ok = erlang:load_nif("./ts_p_md5hex_nif"0).

request(_Value->
    exit(nif_library_not_loaded).

response(_Content->
    exit(nif_library_not_loaded).
Все, интерфейс erl_nif готов. Осталось написать собственно модуль для tsung. И здесь мы будем следовать шагам, упомянутым в статье, ссылку на которую я привел в самом начале. Прежде всего нужно скачать исходники tsung. Далее переходим в директорию с исходниками и добавляем определения для нашего модуля, который мы назовем p_md5hex в файл tsung-1.0.dtd. Я не хочу приводить здесь файл целиком, а diff получается очень широким, поэтому скажу лишь, что в список type из ATTLIST session и список new_type из ATTLIST change_type нужно добавить слово ts_p_md5hex, а в список ELEMENT request - слово p_md5hex. Кроме того нужно добавить описание элемента p_md5hex:
<!ELEMENT p_md5hex EMPTY >
<!ATTLIST p_md5hex
    value  CDATA   #REQUIRED
>
Этот элемент будет использоваться в XML сценариях в определении тэгов request, значение value - это строка, которую мы будем передавать в запросе. Элементы ts_p_md5hex будут использоваться в тэгах session и, если понадобится, change_type для определения протокола сессии.

Теперь нужно создать эрланговский хедер-файл ts_p_md5hex.hrl, в котором будет описан тип данных p_md5hex с единственным полем value. Файл должен находится в директории include/ относительно корня исходников tsung.
-vc('$Id$ ').
-author('garuda @ blogspot.com').

-recordp_md5hex, {
          value,
          bug %% see comment after member 'bug' in ts_raw.hrl
} ).
Как видим, элемент value оказался не единственным, второй элемент bug нужен из-за какого-то бага внутри tsung -  комментарий рядом с ним предлагает посмотреть описание бага в другом файле. Без этого поля наш плагин действительно не заработает.

Теперь создадим исходник для поддержки парсинга конфигурации ts_config_p_md5hex.erl в директории src/tsung_controller/.
-module(ts_config_p_md5hex).
-vc('$Id$ ').
-author('garuda @ blogspot.com').

-export([parse_config/2]).

-include("ts_profile.hrl").
-include("ts_config.hrl").
-include("ts_p_md5hex.hrl").

-include("xmerl.hrl").

%%----------------------------------------------------------------------
%% Function: parse_config/2
%% Purpose:  parse a request defined in the XML config file
%% Args:     Element, Config
%% Returns:  List
%%----------------------------------------------------------------------
%% Parsing other elements
parse_config(Element = #xmlElement{name=dyn_variable}, Conf = #config{}) ->
    ts_config:parse(Element,Conf);

parse_config(Element = #xmlElement{name=p_md5hexattributes=Attrs},
             Config=#config{curid = Idsession_tab = Tab,
                            sessions = [CurS | _], dynvar=DynVar,
                            subst    = SubstFlagmatch=MatchRegExp}) ->
    Req = case ts_config:getAttr(string,Attrsdatasizeof
               [] ->
                   Value = ts_config:getAttr(stringAttrsvalue),
                   #p_md5hex{value=Value}
          end,
    ts_config:mark_prev_req(Id-1TabCurS),
    Msg=#ts_request{ack     = parse,
                    subst   = SubstFlag,
                    match   = MatchRegExp,
                    param   = Req},
    ets:insert(Tab,{{CurS#session.idId},Msg#ts_request{endpage=true,
                                                         dynvar_specs=DynVar}}),
    lists:foldlfun(A,B)->ts_config:parse(A,Bend,
                 Config#config{dynvar=[]},
                 Element#xmlElement.content);

%% Parsing other elements
parse_config(Element = #xmlElement{}, Conf = #config{}) ->
    ts_config:parse(Element,Conf);

%% Parsing non #xmlElement elements
parse_config(_Conf = #config{}) ->
    Conf.
Тут мне трудно что-либо прокомментировать за исключением того, что файл создан как комбинация исходников ts_config_raw.erl (как не очень большого по размеру) и ts_config_http.erl (как наиболее подходящего для нашего протокола). Единственное, что важно - элемент ack в конструкторе #ts_request должен быть равен parse.

Теперь собственно наш модуль ts_p_md5hex.erl, который следует разместить в директории src/tsung/.
-module(ts_p_md5hex).
-author('garuda @ blogspot.com').

-behavior(ts_plugin).

-include("ts_profile.hrl").
-include("ts_p_md5hex.hrl").

-export([init_dynparams/0,
         add_dynparams/4,
         get_message/2,
         session_defaults/0,
         dump/2,
         parse/2,
         parse_bidi/2,
         parse_config/2,
         decode_buffer/2,
         new_session/0,
         md5hex/1]).

%%----------------------------------------------------------------------
%% Function: session_defaults/0
%% Purpose:  default parameters for session (ack_type and persistent)
%% Returns:  {ok, true|false}
%%----------------------------------------------------------------------
session_defaults() ->
    {oktrue}.

%%----------------------------------------------------------------------
%% Function: decode_buffer/0
%% Purpose:  decode buffer for matching or dyn_variables
%% Returns:  decoded buffer
%%----------------------------------------------------------------------
decode_buffer(Buffer, #p_md5hex{}) ->
    Buffer.

%%----------------------------------------------------------------------
%% Function: new_session/0
%% Purpose:  initialize session information
%% Returns:  record or []
%%----------------------------------------------------------------------
new_session() ->
    #p_md5hex{}.

%%----------------------------------------------------------------------
%% Function: parse/2
%% Purpose:  Parse the given data and return a new state
%% Args:     Data (binary), State (record)
%% Returns:  NewState (record)
%%----------------------------------------------------------------------
parse(closedState->
    {State#state_rcv{ack_done = true}, [], true};

parse(DataState->
    {State#state_rcv{datasize = size(Data)}, [], false}.

parse_bidi(DataState->
    ts_plugin:parse_bidi(Data,State).

dump(A,B->
    ts_plugin:dump(A,B).

%%----------------------------------------------------------------------
%% Function: get_message/1
%% Purpose:  Build a message/request
%% Args:     #p_md5hex
%% Returns:  binary
%%----------------------------------------------------------------------
get_message(#p_md5hex{value=Value}, #state_rcv{session=S}) ->
    Packet=ts_p_md5hex_nif:request(Value),
    {PacketS}.

%%----------------------------------------------------------------------
%% Function: parse_config/2
%% Purpose:  parse tags in the XML config file related to the protocol
%% Returns:  List
%%----------------------------------------------------------------------
parse_config(ElementConf->
    ts_config_p_md5hex:parse_config(ElementConf).

%%----------------------------------------------------------------------
%% Function: add_dynparams/4
%% Purpose:  add dynamic parameters to build the message
%%----------------------------------------------------------------------
add_dynparams(_, [], Param_Host->
    Param;

add_dynparams(trueDynDataOldReq_Host->
    subst(OldReqDynData#dyndata.dynvars);

add_dynparams(_Subst_DynDataParam_Host->
    Param.

%%----------------------------------------------------------------------
%% Function: subst/2
%% Purpose:  Replace on the fly dynamic element of the request.
%%----------------------------------------------------------------------
subst(Req=#p_md5hex{value=Value}, DynData->
    Req#p_md5hex{value=ts_search:subst(ValueDynData)}.

init_dynparams() ->  #dyndata{}.

%%----------------------------------------------------------------------
%% Function: md5hex/1
%% Purpose:  Retrieve md5hex message from the request.
%%----------------------------------------------------------------------
md5hex(Data->
    element(2ts_p_md5hex_nif:response(Data)).
Здесь больше комментариев, чем кода. В модуле tsung должны быть определены все функции, перечисленные в секции export, за исключением последней md5hex(), которую мы добавили сами и планируем использовать для проверки правильности ответа сервера в XML сценарии. Реализация почти всех этих функций соответствует минимальному стандарту, который можно увидеть в файле ts_raw.erl в этой же директории. Исключение составляют две важные функции: get_message() и parse(). Функция get_message() создает запрос к серверу с помощью функции request() из нашего пакета ts_p_md5hex_nif, а функция parse() парсит ответ сервера. В нашем случае parse() просто добавляет размер полученных данных в поле datasize записи state_rcv (без этого размер принятых данных будет неверно рассчитан как нулевой), а при закрытии соединения сервером правильно завершает обработку  принятых данных на стороне tsung. Функция md5hex() парсит ответ сервера с помощью ts_p_md5hex_nif:response() и возвращает второй элемент кортежа (т.е. md5 хэш).

Перед сборкой tsung надо перенести файл ts_p_md5hex_nif.erl в директорию src/tsung/. После этого собираем и устанавливаем tsung стандартной цепочкой ./configure; make; make install.

После установки tsung настала пора протестировать наш плагин. Для этого создаем какую-нибудь директорию, например ~/tsung-runtime, копируем в нее библиотеку ts_p_md5hex_nif.so (в модуле ts_p_md5hex_nif.erl мы определили, что будем искать библиотеку в текущей рабочей директории) и переходим в нее. Создаем простой тестовый сценарий в файле scenario.xml.
<?xml version="1.0"?>
<!DOCTYPE tsung SYSTEM "/usr/local/share/tsung/tsung-1.0.dtd" [] >
<tsung loglevel="info">
  <clients>
    <client host="localhost" use_controller_vm="true"/>
  </clients>

  <servers>
    <server host="192.168.0.2" port="5555" type="tcp"></server>
  </servers>

  <load>
    <arrivalphase phase="1" duration="60" unit="second">
      <users arrivalrate="10" unit="second"></users>
    </arrivalphase>
    <arrivalphase phase="2" duration="60" unit="second">
      <users arrivalrate="20" unit="second"></users>
    </arrivalphase>
  </load>

  <sessions>
    <session name="md5hex_1" probability="50" type="ts_p_md5hex">
      <request>
        <match do='continue' when='match' apply_to_content='ts_p_md5hex:md5hex'>
          827ccb0eea8a706c4c34a16891f84e7b
        </match>
        <p_md5hex value="12345"/>
      </request>
    </session>
    <session name="md5hex_2" probability="50" type="ts_p_md5hex">
      <request>
        <match do='continue' when='match' apply_to_content='ts_p_md5hex:md5hex'>
          1e01ba3e07ac48cbdab2d3284d1dd0fa
        </match>
        <p_md5hex value="67890"/>
      </request>
    </session>
  </sessions>
</tsung>
На домашней странице tsung имеется прекрасный раздел с документацией, в котором можно изучить все тонкости написания сценариев. В данном сценарии используется единственный клиент, запускаемый на локальном хосте. Предполагается, что сервер запущен на хосте с адресом 192.168.0.2 (просто localhost здесь не сработает) и прослушивает порт 5555. Определены две стадии тестирования длительностью по 60 секунд, в первой стадии каждую секунду посылаются 10 новых запросов на сервер, во второй - 20. Запросы имеют тип ts_p_md5hex и равновероятно отправляют сериализованные значения 12345 или 67890. Хэш в ответе проверяется с помощью вызова функции ts_p_md5hex:md5hex() внутри тэгов match путем сопоставления с заранее посчитанным значением.

Запускаем tsung:
tsung -f scenario.xml -l ~/tmp/log/ start
и переходим в директорию с результатами (tsung выводит ее на экран). Внутри этой директории запускаем скрипт /usr/lib/tsung/bin/tsung_stats.pl, который генерирует статистический отчет, содержащий помимо сухих цифр некоторое количество замечательных картинок. Этот скрипт можно запускать неоднократно во время работы сценария или после того, как тестирование завершилось. Вот несколько картинок с результатами теста:

Длительность запроса и установки соединения:

Скорость генерации запросов:

Сетевой трафик:
Запросы, соответствующие условиям тэга match:

На втором, третьем и четвертом рисунках видно наличие двух фаз теста по 60 секунд каждая. На первом рисунке видно, что один запрос в среднем занимал чуть более одной миллисекунды, а скорость установки соединения равнялась половине миллисекунды, при этом увеличение нагрузки во второй фазе не отразилось на этих цифрах. На втором рисунке видно, что в первой фазе в среднем генерировалось 10 запросов в секунду, а во второй - 20, что соответствует сценарию теста. На третьем рисунке показан объем исходящего и входящего трафиков, соотношения кривых соответствуют нашему протоколу взаимодействия (ответ сервера примерно в два раза больше клиентского запроса). Четвертый рисунок показывает, что все ответы сервера были с правильно рассчитанным md5 хэшем.

Исходники здесь.