tsung笔记之主从资源协调篇 -凯发k8网页登录

只有一台物理机的tsung master启动方式

没有物理从机，主从节点都在一台机器上，需要设置use_controller_vm="true"。相比tsung集群，单一节点tsung启动就很简单，主从之间不需要ssh通信，直接内部调用。

local_launcher([host],logdir,config) ->
    ?logf("start a launcher on the controller beam ~p~n", [host], ?notice),
    logdirenc = encode_filename(logdir),
    %% set the application spec (read the app file and update some env. var.)
    {ok, {_,_,appspec}} = load_app(tsung),
    {value, {env, oldenv}} = lists:keysearch(env, 1, appspec),
    newenv = [ {debug_level,?config(debug_level)}, {log_file,logdirenc}],
    repkeyfun = fun(tuple, list) ->  lists:keyreplace(element(1, tuple), 1, list, tuple) end,
    env = lists:foldl(repkeyfun, oldenv, newenv),
    newappspec = lists:keyreplace(env, 1, appspec, {env, env}),
    ok = application:load({application, tsung, newappspec}),
    case application:start(tsung) of
        ok ->
            ?log("application started, activate launcher, ~n", ?info),
            application:set_env(tsung, debug_level, config#config.loglevel),
            case config#config.ports_range of
                {min, max} ->
                    application:set_env(tsung, cport_min, min),
                    application:set_env(tsung, cport_max, max);
                undefined ->
                    ""
            end,
            ts_launcher_static:launch({node(), host, []}),
            ts_launcher:launch({node(), host, [], config#config.seed}),
            1 ;
        {error, reason} ->
            ?logf("can't start launcher application (reason: ~p) ! aborting!~n",[reason],?emerg),
            {error, reason}
    end.

用户生成控制

用户和会话控制

每一个tsung client运行着一个ts_launch/ts_launch_static本地注册模块，掌控终端模拟用户生成和会话控制。

• 向主节点ts_config_server请求隶属于当前从机节点的会话信息
• 启动模拟终端用户ts_client
• 控制下一个模拟终端用户ts_client需要等待时间，也是控制从机用户生成速度
• 执行是否需要切换到新的阶段会话
• 控制模拟终端用户是否已经达到了设置的maxusers上限
  • 到上限，自身使命完成，关闭自身
• 源码位于 tsung-1.6.0/src/tsung 目录下

主机按照xml配置生成全局用户产生速率，从机按照自身权重分配的速率进行单独控制，这也是任务分解的具体呈现。

用户生成速度控制

在tsung中用户生成速度称之为强度，根据所配置的load属性进行配置

关键属性：

• interarrival，生成压测用户的时间间隔
• arrivalrate：单位时间内生成用户数量
• 两者最终都会被转换为生成用户强度系数值是0.25
• 这个是总的强度值，但需要被各个tsung client分解

parse(element = #xmlelement{name=users, attributes=attrs},
      conf = #config{arrivalphases=[cura | alist]}) ->
    max = getattr(integer,attrs, maxnumber, infinity),
    ?logf("maximum number of users ~p~n",[max],?info),
    unit  = getattr(string,attrs, unit, "second"),
    intensity = case {getattr(float_or_integer,attrs, interarrival),
                      getattr(float_or_integer,attrs, arrivalrate)  } of
                    {[],[]} ->
                        exit({invalid_xml,"arrival or interarrival must be specified"});
                    {[], rate}  when rate > 0 ->
                        rate / to_milliseconds(unit,1);
                    {interarrival,[]} when interarrival > 0 ->
                        1/to_milliseconds(unit,interarrival);
                    {_value, _value2} ->
                        exit({invalid_xml,"arrivalrate and interarrival can't be defined simultaneously"})
                end,
    lists:foldl(fun parse/2,
        conf#config{arrivalphases = [cura#arrivalphase{maxnumber = max,
                                                        intensity=intensity}
                               |alist]},
                element#xmlelement.content);

tsung_controller对每一个tsung client生成用户强度分解为 clientintensity = phaseintensity * weight / totalweight，而1000 * clientintensity就是易读的每秒生成用户速率值。

get_client_cfg(arrival=#arrivalphase{duration = duration,
                                     intensity= phaseintensity,
                                     curnumber= curnumber,
                                     maxnumber= maxnumber },
               {totalweight,client,islast} ) ->
    weight = client#client.weight,
    clientintensity = phaseintensity * weight / totalweight,
    nusers = round(case maxnumber of
                       infinity -> %% only use the duration to set the number of users
                           duration * clientintensity;
                       _ ->
                           tmpmax = case {islast,curnumber == maxnumber} of
                                        {true,_} ->
                                            maxnumber-curnumber;
                                        {false,true} ->
                                            0;
                                        {false,false} ->
                                            lists:max([1,trunc(maxnumber * weight / totalweight)])
                                    end,
                           lists:min([tmpmax, duration*clientintensity])
                   end),
    ?logf("new arrival phase ~p for client ~p (last ? ~p): will start ~p users~n",
          [arrival#arrivalphase.phase,client#client.host, islast,nusers],?notice),
    {arrival#arrivalphase{curnumber=curnumber nusers}, {clientintensity, nusers, duration}}.

前面讲到每一个tsung client被分配用户数公式为：min(duration * clientintensity, maxnumber * weight / totalweight)：

• 避免总人数超出限制
• 阶段phase持续时长所产生用户数和tsung client分配用户数不至于产生冲突，一种协调策略

再看一下launch加载一个终端用户时，会自动根据当前分配用户生成压力系数获得ts_stats:exponential(intensity)下一个模拟用户产生等待生成的最长时间，单位为毫秒。

do_launch({intensity, myhostname, phaseid})->
    %%get one client
    %%set the profile of the client
    case catch ts_config_server:get_next_session({myhostname, phaseid} ) of
        {'exit', {timeout, _ }} ->
            ?log("get_next_session failed (timeout), skip this session !~n", ?err),
            ts_mon:add({ count, error_next_session }),
            error;
        {ok, session} ->
            ts_client_sup:start_child(session),
            x = ts_stats:exponential(intensity),
            ?debugf("client launched, wait ~p ms before launching next client~n",[x]),
            {ok, x};
        error ->
            ?logf("get_next_session failed for unexpected reason [~p], abort !~n", [error],?err),
            ts_mon:add({ count, error_next_session }),
            exit(shutdown)
    end.

ts_stats:exponential逻辑引入了指数计算：

exponential(param) ->
    -math:log(random:uniform())/param.

继续往下看吧，隐藏了部分无关代码：

launcher(timeout, state=#launcher{nusers        = users,
                                  phase_nusers  = phaseusers,
                                  phases        = phases,
                                  phase_id      = id,
                                  started_users = started,
                                  intensity     = intensity}) ->
    beforelaunch = ?now,
    case do_launch({intensity,state#launcher.myhostname,id}) of
        {ok, wait} ->
                            ...
                        {continue} ->
                            now=?now,
                            launchduration = ts_utils:elapsed(beforelaunch, now),
                            %% to keep the rate of new users as expected,
                            %% remove the time to launch a client to the next
                            %% wait.
                            newwait = case wait > launchduration of
                                          true -> trunc(wait - launchduration);
                                          false -> 0
                                      end,
                            ?debugf("real wait = ~p (was ~p)~n", [newwait,wait]),
                            {next_state,launcher,state#launcher{nusers = users-1, started_users=started 1} , newwait}
                            ...
        error ->
            % retry with the next user, wait randomly a few msec
            rndwait = random:uniform(?next_after_failed_timeout),
            {next_state,launcher,state#launcher{nusers = users-1} , rndwait}
    end.

下一个用户生成需要等待wait - launchduration毫秒时间。

给出一个采样数据，只有一个从机，并且用户产生速度1秒一个，共产生10个用户：

采集日志部分，记录了wait时间值，其实总体时间还需要加上launchduration（虽然这个值很小）：

ts_launcher:(7:<0.63.0>) client launched, wait 678.5670934164623 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 810.2982455546687 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 1469.2208436232288 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 986.7202548184069 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 180.7484423006169 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 1018.9190235965457 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 1685.0156394273606 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 408.53992361334065 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 204.40900996137086 ms before launching next client
ts_launcher:(7:<0.63.0>) client launched, wait 804.6040921461512 ms before launching next client

总体来说，每一个用户生成间隔间不是固定值，是一个大约值，有偏差，但接近于目标设定（1000毫秒生成一个用户标准间隔）。

执行模拟终端用户会话流程

关于会话的说明：

• 一个session元素中的定义一系列请求-响应等交互行为称之为一次完整会话
• 一个模拟用户需要执行一次完整会话，然后生命周期完成，然后结束

模拟终端用户模块是ts_client（状态机），挂载在ts_client_sup下，由ts_launcher/ts_launcher_static调用ts_client_sup:start_child(session)启动，是压测任务的最终执行者，承包了所有脏累差的活：

• 所有下一步需要执行的会话指令都需要向主机的ts_config_server请求
• 执行会话指令
• 具体协议调用相应协议插件，比如ts_mqtt组装会话消息
• 建立网络socket连接，封装众多网络通道
• 发送请求数据，处理响应
• 记录并发送监控数据和日志



小结

简单梳理主从之间启动方式，从机数量分配策略，以具体压测任务如何在从机上分配和运行等内容。