Web sockets

Web sockets provide a persistent connection that enables data to be sent and received in real-time, without the need for constant polling. This technology is particularly valuable for applications that require instant updates, such as chat applications, live notifications, or online gaming.

Real-time interaction

Real-time interaction is an essential aspect of modern web applications. Consider a chat application where messages appear instantly for all users or a live dashboard displaying real-time updates. Web sockets facilitate this by allowing data to be pushed from the server to the client or vice versa, creating a dynamic user experience.

Let's take a look at a simple example of real-time interaction using web sockets in JavaScript:

// Client-side code

const socket = new WebSocket('ws://example.com/socket');

socket.addEventListener('message', (event) => {

  console.log('Received message:', event.data);

});


// Server-side code (Node.js example)

const WebSocket = require('ws');

const server = new WebSocket.Server({ port: 3000 });


server.on('connection', (socket) => {

  socket.send('Welcome to the real-time world!');

});

In WebSocket, as in any asynchronous communication, it is important to initially establish a connection between the client and the server. Only then can messages be transmitted.

In this example, the server sends a welcome message to the client as soon as a connection is established, demonstrating the real-time nature of web sockets. Here we have a listener - essentially a piece of functionality that monitors a specific message event from the server and outputs it to the console when it is received. This allows the client to receive updates from the server as quickly as possible. In other words, a listener is like a radio tuned to a particular frequency. Without it, no matter how many messages are transmitted at different frequencies, the user will hear nothing. And, conversely, you can take several receivers (listeners) and tune them to the necessary "frequencies" (in this example, events) to receive information only about the events you are interested in.

Web sockets enable instantaneous data transfer between clients and servers. This is one advantage. Additionally, web sockets provide a constant connection. Therefore, the delays associated with reconnections are minimized. Also, the client and server can send messages independently of each other, which is beneficial for interactive applications.

However, these positive aspects come with a downside. Implementing and maintaining web socket connections can be more complex than traditional HTTP requests. Some network configurations can block web socket connections, which affects availability.

Principle of web socket

Web sockets operate on the simple principle of establishing a connection and maintaining it for as long as needed. They use a full-duplex communication channel, allowing data to flow bidirectionally between the client and the server. This is achieved through a handshake process during the initial connection setup.

The fundamental principle that describes how a web socket works is the handshake principle. It is a basic process that occurs when a client wants to establish a connection with a server using web sockets. It's like a secret handshake between friends before they begin sharing information.

Envision you're knocking on a door to speak to someone. In web sockets, this "knocking" is the initial step to verify if the server is open to a conversation. The client sends a distinctive kind of message, called an HTTP request, to the server. This message says, "Hey, I want to chat using web sockets. Are you okay with that?"

• The server receives the request and replies with an HTTP response. It's like the server saying, "Absolutely, I'm ready to chat using web sockets. Let's do it!"

• If everything is okay, the server switches from regular HTTP mode to web socket mode. It's like the door opening wide, signaling that the client and server can now communicate in a more direct and real-time way.

• The client also acknowledges the switch, saying, "Understood! We're on the same page." Now, they both know that the door is open, and they can start sending messages to each other.

To put it simply, the handshake is like the polite conversation at the beginning of a meeting. The client asks if it's okay to use web sockets, the server agrees, and they both switch gears to start a more direct and immediate conversation. Once the handshake is successful, the real-time communication channel is established, allowing the client and server to chat freely. Such a handshake is often used for security reasons, for example, to exchange keys to establish a private connection.

Data transfer formats for web sockets

While web sockets can transfer data in various formats, JSON (JavaScript Object Notation) is a commonly used and easily readable format. JSON is lightweight and easy to parse, making it an ideal choice for web socket communication.

Let's see how JSON can be used for data exchange:

// Client sending JSON data

const message = { user: 'Alice', content: 'Hello, world!' };

socket.send(JSON.stringify(message));


// Server parsing JSON data

socket.on('message', (data) => {

  const parsedData = JSON.parse(data);

  console.log('Received JSON:', parsedData);

});

In this example, the client sends a JSON-formatted message to the server, which then parses the incoming JSON data.

In addition to the JSON format, other formats are also used. For example:

• MessagePack is a binary format that efficiently serializes data. It's more compact than JSON and is designed for fast and efficient encoding and decoding. This can be beneficial when bandwidth is a concern.

• Protocol Buffers (ProtoBuf), developed by Google, is a language-agnostic binary serialization format. They are designed to be more efficient than JSON and can provide smaller message sizes. Protocol Buffers are especially useful in situations where performance and bandwidth are critical.

• While not as common as JSON for web sockets due to its verbosity, XML is still a valid choice for data interchange. It's a markup language that is easily readable and supports complex data structures. In some cases, especially for simple applications or when dealing with textual data, plain text might be sufficient. This can be advantageous for simplicity and ease of debugging.

• Web sockets also support the transmission of raw binary data. This is particularly useful when dealing with media files, images, or other binary data that don't fit well into text-based formats.

The choice of the data format depends on the specific needs of the application, such as the nature of the data, performance considerations, and interoperability requirements.

Encrypting data in web sockets

Encrypting data in web sockets is like putting your messages in a special envelope that only you and the person you're sending it to can open. It adds a layer of security to your conversations, making sure that nobody else can sneak a peek at what you're saying.

Imagine you're sending postcards to a friend, but anyone who sees the postcard can read what's written on it. In standard web sockets (HTTP), your messages are like open postcards, visible to anyone looking. Now, if you want to keep your messages private, you would put them in a special envelope. Encryption is like using this envelope. It scrambles your message in a way that only you and your friend can unscramble it with a secret key.

In web sockets, if you want to have private and secure conversations, you use the "wss://" protocol instead of "ws://". It's like saying, "Let's talk in a secure way." The process of encryption uses special lock-and-key techniques called encryption algorithms. Your message gets locked with a key, and only someone with the right key can unlock and understand it.

Once your web socket connection is using encryption, it's as if you and your friend have a secret language. Even if someone tries to listen in on your conversation, all they hear is a bunch of scrambled words. In simple terms, encrypting data in web sockets is like speaking in a secret code that only you and your friend can understand. It keeps your messages safe from prying eyes and ensures that your online conversations remain confidential and secure.

Here's a simplified example of establishing a secure web socket connection:

// Secure web socket connection

const secureSocket = new WebSocket('wss://example.com/secure-socket');

By using the "wss" protocol, the web socket communication is encrypted, ensuring the confidentiality of the data exchanged.

Conclusion

Many modern web applications heavily rely on real-time features, such as live notifications, instant messaging, and dynamic updates. Protocol features are crucial to understand in order to use this knowledge when testing the corresponding services. For example, WebSocket features add interesting scenarios such as checking for connection interruption/restoration, checking if messages sent through the tunnel are lost, as well as non-functional checks like load and performance, to name a few.