Introduction | Authentic Node.js WebSocket Server Workshop 2024 for Everyone, No Libraries

Book Overview & Buying
Table Of Contents

Authentic Node.js WebSocket Server Workshop 2024 for Everyone, No Libraries

By : SkillZone

5 (1)

Buy this Video

Authentic Node.js WebSocket Server Workshop 2024 for Everyone, No Libraries

5 (1)

By: SkillZone

Buy this Video

Overview of this book

Learn how to create a fully functional WebSocket server in Node.js—without using any libraries. Starting with the HTTP handshake upgrade, this course guides you through the step-by-step process of building real-time, two-way communication. You’ll configure an HTTP server, establish WebSocket connections, and ensure compliance with RFC 6455 for universal compatibility. Dive into handling incoming WebSocket data frames and headers. Explore key tasks like extracting bytes, calculating payload lengths, and unmasking data to meet protocol standards. Along the way, you’ll learn practical debugging techniques to manage data payloads and optimize your server for seamless real-time communication. In the final sections, master control frame handling, including ping, pong, and close frames, to gracefully manage WebSocket closures. With a focus on error handling and connection management, this course prepares you to create servers that can tackle real-world demands. By the end, you’ll have the skills to build efficient, full-duplex WebSocket servers in Node.js, ready to support any real-time project—no third-party libraries required.

Introduction

To build a WebSocket server, we need to be RFC compliant

Creating a NodeJS Server

Overview of HTML and CSS

Setting up our HTTP server

Creating custom modules and finishing off the HTTP server

Implementing basic error handling

Using "Run and Debug" to examine the forEach loop

Testing our error handling code

Establishing a WebSocket Connection

Using the 'upgrade' event listener to receive three important objects

Examining the request object in the terminal

Reading the client's opening handshake request headers

Sending a "400 Bad Request" response if the client handshake headers fail

Generate the server response headers object

Extracting the Sec-WebSocket-Key and using the crypto module

Timeout! What is SHA-hashing and the crypto module?

Generate the Sec-WebSocket-Accept value and send back headers to the client

Testing our code and opening up a valid WebSocket connection

Receiving WebSocket Data

Setting up our file for the next goal

The socket object inherits from the stream.Duplex class

Defining our data event handler

Quick cut - adding the 'end' event listener to our socket object

Define the processBuffer() function

The WebSocket binary frame structure

Coding the task management looping function

Extract the first 2 bytes of data from the WebSocket data frame

What are Buffers?

Why is the letter "a" sent as 7 bytes?

Using the Debugger tool to analyze code

Extracting the FIN bit

Bitwise operators

Extracting the MASK, OPCODE and initial LENGTH information

Setting up code to extract the payload length details

The 3 categories of payload lengths

Calculating the payload length

Payload length checks

Extract the Masking Key

Define the getPayload() method

Extract one full frame of data (masked)

Unmasking the frame payload

What is the modulus operand?

Create a persistent fragments array and check for more frames (FIN bit check)

SMALL payloads - Using the debugger to analyze logic

Fixing the error in our consumePayload() method

Adding a prepopulate button to the HTML

MEDIUM Payloads - Using the debugger to analyze logic

LARGE Payloads: Part 1 of 3. Understanding getLength() logic

LARGE Payloads: Part 2 of 3. Waiting for additional chunks

LARGE Payloads: Part 3 of 3. Processing the entire payload into _fragments

Improvements, comments, and adding opcode checks

Advanced - chunk size variation between debugger vs live environment

Improving our _getInfo() method

Sending WebSocket Data

Getting project files ready to send data to the client

Calculating the size of the variable-length header field

Create the binary frame buffer blueprint

Creating the first byte of the frame

Bitwise shift operators

Populate the frame header with data

Sending the frame to the client

Testing whether the client received the frame

Creating a reset() function

Using debugger tool to examine code

Displaying the WebSocket message on the client-side

Responding to a Closure Frame

Setting up project code and defining our mini-goal

Closing handshake

Extracting the body (closure code and reason) of the close frame

Close Frame Structure

Construct the payload buffer for the close frame

Completing and sending the final close frame back to the client

Testing our code

Using Wireshark to master the TCP closure process

Checking for "ping" and "pong" data type, and payloads larger than max size

Extracting the server response from the CloseEvent object

Sending a closure frame if the masking bit is not set correctly by the client

Check whether client has sent a closure code

Displaying default closure message (for normal closure event)

Fixing comments and removing server response text when a new connection is made

Server side validation for text

Fixing the refresh issue killing the server

Authentic Node.js WebSocket Server Workshop 2024 for Everyone, No Libraries

By : SkillZone

Authentic Node.js WebSocket Server Workshop 2024 for Everyone, No Libraries

By: SkillZone

Overview of this book

Confirmation

Buy this book with your credits?

Submit Your Feedback

Create a Free Account To Continue Reading

Sign in to activate your 7-day free access