How to Load Test TCP Protocol Services With JMeter

In TCP protocol services, clients send text or binary messages to the service and receive responses from it. Apache JMeter™’s TCP Sampler and TCP Sampler Config elements load test these types of services.

This blog post explains how to test a simple TCP server that works in the echo mode (the server responds with the same data that has been sent to it). The JAR file and java code of this TCP server can be downloaded from here and launched on your local network. In our JMeter script, we will send data to the server via TCP sampler, get responses from the server and analyze them. Then, we will add a TCP Sampler Config.

Let’s get started.

The TCP Sampler

Add a thread group to a new JMeter test plan: Right click > Add > Threads > Thread Group.

Add the TCP sampler as a child element to the thread group: Right click > Sampler > TCP Sampler.

There are three implementations of the TCP sampler in JMeter: one for exchanging text data and two others for exchanging binary data with the tested service.

Each of the implementations is provided by a certain class, which is a "template" or a group of attributes of an object. Enter the name of the class into the TCPClient class name field of the TCP sampler.

The class names, as they are given in the JMeter documentation, are:

• TCPClientImpl. This is a basic class for implementation of the text messages exchange. Text messages are provided as a constant or as variable strings of different charsets in the Text to send field of the TCP sampler.
• BinaryTCPClientImpl. This is a class for the implementation of the exchange of the text messages. Binary messages in the form of the hex encoded constant or variable values are provided in the ‘Text to send’ field of the TCP sampler.
• LengthPrefixedBinaryTCPClientImpl. This class is similar to the previous one, but byte data to send is prefixed with the binary length byte. 

The Basic Class Implementation

 Let’s use the basic implementation of the TCP server in our script.

The TCPclient class name field has the name of the class. In this case, it is TCPClientImpl. As this is the default class name, it may be left out. 

The server name or IP is where the simple TCP server is launched. The Port field is the port the TCP server listens to.

The text to send message contains the text that is sent to the server. To demonstrate that the Text to send field is able to process JMeter variables and functions, I’ve changed the loop count parameter in the thread group to 2 and added the ${__iterationNum()} function to the TCP sampler text. This function prints out the number of current iteration of the currently executed thread group. 

Add a View Results Tree listener to the thread group monitor responses from the TCP server: Right click > Add > Listener > View Results Tree.

Save the script, launch a simple TCP server application with the same port parameter that is configured in the script, and launch the script.

Open the View Results Tree Listener. As was mentioned above, the tested TCP server works in the echo mode but adds an information string with the packet number processed to each request. In the screenshot below, you can see the response of the TCP sampler:

These are all required configuration settings that have to be applied to the TCP sampler. But in some cases, when we have to take into account some specific parameters of the network or tested server, we need to apply additional settings:

• The Connect timeout parameter determines the maximum time in milliseconds the particular TCP sampler waits for the establishment of the connection from the server.
• The Response timeout parameter determines the maximum time the particular TCP sampler waits for the response from the server. If you need to consider the network propagation time or the server response time, you may tune the sampler with these parameters in order to avoid receiving too many timed out samplers.
• The Re-use connection parameter instructs the script to use the same connection for sending data; otherwise, the connection established in the previous session will be used.
• The Close connection parameter instructs the script to close connection and open a new one each time the new data is sent.
• If the Set NoDelay parameter is set, small messages, even those the size of only 1 byte, are sent in a separate packet. Otherwise, if this parameter is cleared, a number of small messages is combined in one packet before sending them.
• The SO_LINGER option can be enabled in the socket to cause the script to block the close the connection call for a number of seconds, specified in this field until all final data is delivered to the destination station.

The Binary Class Implementation 

If we need to exchange binary data with TCP server, we need to use BynaryTCPClientImpl class and specify this class name in the TCPclient class name field of the TCP sampler. The binary data is entered into the Text to send field in the hex encoded format, as it’s shown in the screenshot below. 

Let’s add an additional TCP sampler that sends binary data to the TCP server. The sampler is shown in the screenshot below:

In the Text to send field, let’s send a sequence of two digits hex numbers that represent a sequence of bytes, and see how the TCP sampler response is represented. The sequence of bytes should end with the value that is less than 20. In this example, the binary data in the hex-encoded format that is sent to the TCP server is 63646f0a.

The View Result Tree listener displays the received data from the TCP sampler in the hex-encoded format without converting it to chars: 

The hex encoded data in the response is 5061636b657420333a200a63646f0a. The data that was sent to the TCP server is at the end and underlined. Before it appears the hex encoded sequence, which represents information about packet number — each 2 digits is ACSII code in hex format. 

The Length Prefixed Binary Class Implementation 

The length prefixed binary TCP client implementation is similar to the binary implementation, with the difference that the number of bytes sent is inserted before each message. JMeter inserts this number automatically before each message that it sends to the TCP server. The TCP server, in turn, calculates the number of bytes in the response it sends to JMeter and inserts this number before the message. This fact should be taken into account. 

The TCP Sampler Config

Like the HTTP request defaults config element that defines common HTTP parameters for all HTTP samplers in a script, the TCP Sampler Config element defines common parameters for all TCP samplers that are used in a script.

Add the TCP Sampler Config to the script before the thread group and place common parameters, such as the server name and port number, and remove these parameters from the TCP samplers from before.

The TCP sampler can be used together with all preprocessors, postprocessors and assertion elements to make scripts configurable and provide the response analysis.

Modify the script so that it reads text data from files, adds data to the TCP sampler, extracts some data from the response, and asserts against some values. To do that, add the BeanShell preprocessor that will read data from files and feed them to the TCP sampler. 

The added preprocessor is shown on the screenshot below:

 The preprocessor code: 

import java.io.*;
import org.apache.jmeter.protocol.tcp.sampler.*;

String textToSend = "";
String fline = "";

     FileReader fR = new FileReader("${fname}");
     BufferedReader bR = new BufferedReader(fR);

     while((fline = bR.readLine())!= null){
     textToSend = textToSend + fline;
     }
sampler.setRequestData(textToSend);

To output the TCP Response packet number to the system log and to assert against the text Packet in each response, add a BeanShell PostProcessor, Regular Expression Extractor elements, and an assertion. 

The regular expression extractor, extracts the packet number, using the pattern Packet (.+): and places it to the variable packNum. 

The BeanShell postprocessor prints this variable out to the system log, using function print(${packNum}).

 This assertion asserts each response, that they contain string about packet number. The pattern, that is used is Packet \d\d. 

As you can see, you can work with the TCP sampler by using JMeter-provided implementations. If you need to use more specific processing algorithms for communications over TCP, you may implement them in your own class. All that you need is to extend your class from an existing class, for example from BinaryTCPClientImpl class, implement what you need and then insert the name of the created class to the TCP client class name field of the TCP sampler.