Load Balancer

Overview

The component TsgcWebSocketLoadBalancerServer allows you to load-balance WebSocket and HTTP protocols. For the WebSocket protocol, it distributes messages across a group of servers and distributes client connections using a random sequence or fewest-connections algorithm.

At a glance

Features

• Native Delphi implementation with full ANSI/Unicode support.

Technical specification

Main properties

The principal published / public properties used to configure and drive the component. Consult the online help for the full list.

Main methods

The principal public methods exposed by the component.

Public events

The component exposes the following published events; consult the online help for full event-handler signatures.

Quick Start

Drop the component on a form, configure the properties below and activate it. The snippet that follows shows the typical OnBeforeSendServerBinding configuration sourced from the online help.

Delphi (VCL / FireMonkey)

procedure OnBeforeSendServerBinding(Connection: TsgcWSConnection;
  var Binding: TsgcWSLoadBalancerServerBinding);
begin
  // force secure WebSocket scheme when the client connected over TLS
  if Connection.IsSSL then
    Binding.Protocol := 'wss';
end;

C++ Builder

void OnBeforeSendServerBinding(TsgcWSConnection *Connection,
  TsgcWSLoadBalancerServerBinding *&Binding)
{
  if (Connection->IsSSL)
    Binding->Protocol = "wss";
}

.NET (C#)

void OnBeforeSendServerBinding(TsgcWSConnection Connection,
  out TsgcWSLoadBalancerServerBinding Binding)
{
  if (Connection.IsSSL)
    Binding.Protocol = "wss";
}

Common scenarios

The following scenarios are lifted verbatim from the online help. Each shows the configuration and method calls needed to drive the component through a specific real-world flow.

1 · Broadcast

Fans a WebSocket message out across every backup server in the cluster, optionally filtered by channel, protocol, or connection GUID list.

oServer.Broadcast('Hello From Server');

oServer->Broadcast("Hello From Server");

oServer.Broadcast("Hello From Server");

2 · DisconnectAll

Disconnects every active client connection and every registered backup server while keeping the load balancer listening for new connections.

oServer.DisconnectAll;

oServer->DisconnectAll();

oServer.DisconnectAll();

3 · OnBinary

Fires when the load balancer itself receives a binary WebSocket frame on one of its downstream sessions.

procedure OnBinary(Connection: TsgcWSConnection; const Data: TMemoryStream);
begin
  Log(Format('Received %d bytes from %s', [Data.Size, Connection.Guid]));
end;

void OnBinary(TsgcWSConnection *Connection, const TMemoryStream *Data)
{
  Log("Received " + IntToStr(Data->Size) + " bytes from " + Connection->Guid);
}

void OnBinary(TsgcWSConnection Connection, TMemoryStream Data)
{
  Console.WriteLine("Received " + Data.Size + " bytes from " + Connection.Guid);
}

4 · OnClientBinary

Fires when a binary frame is received from a downstream client before it is forwarded to the selected backend server.

procedure OnClientBinary(Connection: TsgcWSConnection; Data: TMemoryStream;
  var Handled: Boolean);
begin
  // drop empty frames instead of forwarding them
  Handled := Data.Size = 0;
end;

void OnClientBinary(TsgcWSConnection *Connection, TMemoryStream *Data,
  bool &Handled)
{
  Handled = (Data->Size == 0);
}

void OnClientBinary(TsgcWSConnection Connection, TMemoryStream Data,
  out bool Handled)
{
  Handled = (Data.Size == 0);
}

5 · OnClientConnect

Fires when a downstream client finishes the WebSocket handshake against the load balancer and is paired with a backend server.

procedure OnClientConnect(ServerConnection: TsgcWSConnection;
  ClientConnection: TsgcWSLoadBalancerClientConnection);
begin
  Log(Format('Client %s routed to backend %s',
    [ClientConnection.Guid, ServerConnection.Guid]));
end;

void OnClientConnect(TsgcWSConnection *ServerConnection,
  TsgcWSLoadBalancerClientConnection *ClientConnection)
{
  Log("Client " + ClientConnection->Guid
    + " routed to backend " + ServerConnection->Guid);
}

void OnClientConnect(TsgcWSConnection ServerConnection,
  TsgcWSLoadBalancerClientConnection ClientConnection)
{
  Console.WriteLine("Client " + ClientConnection.Guid
    + " routed to backend " + ServerConnection.Guid);
}

6 · OnClientDisconnect

Fires when a downstream client session is dropped from the load balancer, either because the client left or because the backend terminated.

procedure OnClientDisconnect(ServerConnection: TsgcWSConnection;
  ClientConnection: TsgcWSLoadBalancerClientConnection);
begin
  Log('Client disconnected: ' + ClientConnection.Guid);
end;

void OnClientDisconnect(TsgcWSConnection *ServerConnection,
  TsgcWSLoadBalancerClientConnection *ClientConnection)
{
  Log("Client disconnected: " + ClientConnection->Guid);
}

void OnClientDisconnect(TsgcWSConnection ServerConnection,
  TsgcWSLoadBalancerClientConnection ClientConnection)
{
  Console.WriteLine("Client disconnected: " + ClientConnection.Guid);
}

Sources used to build this document

Every external claim links back to a primary source. The online-help references decode the canonical deep-link the company maintains for this component.