A Delphi webserver can receive multipe calls? - multithreading

Question

I have a webserver made in Delphi which is responsible to fetch data from MySQL server and retrieve formatted in JSON. Here is a simple example of how it fetches the list of loteamentos from the DB.
type
TWM = class(TWebModule)
...
procedure WMactLoteamentosAction(Sender: TObject; Request: TWebRequest;
Response: TWebResponse; var Handled: Boolean);
...
procedure TWM.WMactLoteamentosAction(Sender: TObject; Request: TWebRequest;
Response: TWebResponse; var Handled: Boolean);
var
qryLoteamentos: TFDQuery;
JsonArray: TJSONArray;
JsonObject: TJSONObject;
begin
Response.ContentType := APPLICATION_JSON + '; ' + CHARSET_UTF8;
// Search for loteamentos
qryLoteamentos := TFDQuery.Create(nil);
with qryLoteamentos do
begin
Connection := FDConnection;
Active := False;
SQL.Clear;
Open('SELECT * FROM ' + T_LOTEAMENTO);
if qryLoteamentos.RecordCount > 0 then
begin
JsonArray := TJSONArray.Create;
try
First;
while not Eof do
begin
JsonObject := TJSONObject.Create;
CapturarCamposLoteamento(JsonObject, qryLoteamentos);
JsonArray.AddElement(JsonObject);
Next;
end;
finally
Response.Content := JsonArray.ToString;
JsonArray.DisposeOf;
end;
end
else
handleEmptyResponse(Response);
end;
end;
The logic of the method doesn't matter too much, it just matters that it fetch a table from the database and retrieve it in JSON.
The application will be running in a machine, the MySQL will be from this machine's localhost and the user will access the webserver by an external IP and the port.
Therefore, if the server is running on port 9070 in a machine which external IP is for example 45.65.89.187
The method will be called in the following way:
GET -> http://45.65.89.187/loteamentos
It will retrieve for me something like this:
[{"id":1,"nome":"RESIDENCIAL ...","metros":"348516,57"},
{"id":2,"nome":"RESIDENCIAL ...","metros":"215465,65"}]
Questions
My question is, suppose 100 people are using my API on their phone. Imagine 100 people calling this same endpoint /loteamentos multiple times. Wouldn't it crash the server?
I wonder that people calling the same endpoint at the same time doesn't create a line in the same Thread and disturb the server? Shouldn't I put the webserver to run in MultiThreading?
What I've done
I tested calling the endpoints from the webserver multiple times in 4 phones. The webserver start running at 2MB, after multiple calls it goes up to 40MB in a couple of minutes. Then, I stop calling it, but it keeps on 40MB and does not get lower.

Answer 1

A WebBroker application will create the first instance of TWebModule when the first request from a client comes in.
Whenever a 2nd HTTP request of a client arrives at the WebBroker application, the WebBroker framework will search if the previously created WebModule instance is idle (idle = it is not executing a request action handler).
If there are no idle instances of WebModule then a new TWebModule will be instantiated.
The code for that is in Web.WebReq.pas, function TWebRequestHandler.ActivateWebModules: TComponent;
By default a WebBroker application will create up to 32 TWebModule instances when the load is high. That number 32 is defined by the property Application.MaxConnections.
Be aware that simultanious requests are already multithreaded, and all the code in your request handlers must be thread safe.
A single TWebModule instance will only serve 1 request at a time, any other concurrent requests will be served by other instances of your TWebModule.
With the possibility of having multiple TWebModule instances serving requests in parallel, the queries in a single TWebModule instance should use their own dedicated DB connection instance.
While testing the load handling you could add a long Sleep(10000) to have many busy web request handlers, and check how your application responds. It's then easy to hit the limit of Application.MaxConnections, resulting in an exception.
Your webserver might consume 40MB because the WebBroker framework has created for instance 10 TWebModule instances when the load was at it's peak (Application.InactiveConnections + Application.ActiveConnections = 10). If your TWebModule allocates objects in it's constructor, or if it has many components in it's DFM then they will all persist.
Be also aware that any client-specific data should not reside in the TWebModule itself when the request is finished. Client A might be served by TWebModule instance 1 during the first request, and by instance 2 serves Client B simultaniously.
In the next simultanious request, Client A might be served by instance 2 and Client B by instance 1.

Answer 2

Am using plain webBroker under Delphi 10.1
I have a server that accepts a Json String. I parse it and send the same data back to the client.
My assumption is Webbroker by default has 32 threads that will be created progressively as concurrent requests from client start hitting the server and stop at 32 (refer web.webreq.pas)
To test this scenario I have created a simple Client program that has a For-loop that will keep firing at the the server with a request that will carry a JSon String.
For 10,000 requests it takes about 14 seconds. Only ONE instance of the webModule gets created...which is fine because the for loop sends the request in a serial and SYNCHRONOUS mode.
When I run another parallel instance of the client program, the 2nd instance of the WebModule gets created....fair enough. When I run one more parallel instance of the client the, 3rd instance of the WebModule gets created....so on and so forth
Now is the interesting part....
Remember the time taken for 10K request which is 14 seconds when only my first Client program was running? I am observing the following - As I increase the number of concurrent clients, the time taken to process also increases It actually takes 42 seconds to complete (30K requests in total) when 3 Client programs fire requests concurrently.
If the Server was truly Multi-threaded as claimed, then at least up to 32 concurrent client requests the time taken should be the SAME to process individual 10K records from each client, right?
Can you pls clarify if Web Broker is truly Multi-threaded? And if so what is it I am missing?
I have attached both the Client and the Server source here.
**Client Code follows
enter code here
unit URestclient;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, REST.Types, REST.Client,
Data.Bind.Components, Data.Bind.ObjectScope, Vcl.StdCtrls, JsonTools, system.DateUtils;
type
TForm21 = class(TForm)
RESTClient1: TRESTClient;
RESTRequest1: TRESTRequest;
RESTResponse1: TRESTResponse;
Button1: TButton;
Memo1: TMemo;
Label2: TLabel;
Edit1: TEdit;
Edit2: TEdit;
Label1: TLabel;
Label3: TLabel;
Label4: TLabel;
Edit3: TEdit;
procedure Button1Click(Sender: TObject);
private
procedure AfterRun;
function SendJSonDataToIVR(MachineID, JS: String): boolean;
{ Private declarations }
public
{ Public declarations }
end;
var
Form21: TForm21;
RESTClient: TRESTClient;
RESTRequest: TRESTRequest;
RESTResponse: TRESTResponse;
N: TJSONnode;
JS : String;
i : integer;
implementation
{$R *.dfm}
procedure TForm21.AfterRun;
begin
Memo1.Lines.Add(RESTResponse.content);
end;
procedure TForm21.Button1Click(Sender: TObject);
var
st, et : TDatetime;
S : String;
begin
Label2.caption := 'Started!';
Label2.Repaint;
memo1.Clear;
JS := '{"CallStatus":"t","CallType":"N","BookingType":"I","CallerType":"C","RoomNo":"1788882",'
+'"Channel":"1191","OriginalChannel":"1191","MobileNumber":"09123456789","DialTry":"1","MaxTry":"1"'
+',"ServerID":"3","StartTime":"2020-10-13 10:41:40","EndTime":"2020-10-13 10:41:40",'
+'"TransferNumber":"","Dstatus":"","userid":"1"}';
S := 'http://' + trim(edit2.text) + ':' + trim(edit1.text) + '/tconnected';
st := now;
for i := 0 to strtoint(trim(Edit3.Text)) do
SendJSonDataToIVR(S, JS);
et := now;
Label2.Caption := 'Time Taken (in ms) ' + MilliSecondsBetween(et, st).ToString;
end;
Function TForm21.SendJSonDataToIVR(MachineID : String; JS : String) : boolean;
begin
SendJSonDataToIVR := false;
RESTClient := TRESTClient.Create('nil');
RESTRequest := TRESTRequest.Create(nil);
RESTRequest.Client := RESTClient;
RESTClient.BaseURL := MachineID;
RESTRequest.ClearBody;
RESTRequest.AddBody(JS, ctAPPLICATION_JSON);
RESTRequest.Method := TRESTRequestMethod.rmPost;
RESTResponse := TRESTResponse.Create(nil);
RESTRequest.Response := RESTResponse;
RESTRequest.Execute();
//Memo1.Lines.Add(RESTResponse.content);
// RESTRequest.ExecuteAsync(AfterRun, true, True);
end;
end.
**Server Code follows
unit wmTConnected;
interface
uses
System.SysUtils, System.Classes, Web.HTTPApp, JSontools,
Data.DB,
FireDAC.Stan.Def,
FireDAC.Phys.PG,
FireDAC.Phys.PGDef,
FireDAC.DApt,
FireDAC.Stan.Async,
FireDAC.Stan.Option,
FireDAC.Comp.Client, FireDAC.Stan.Intf,
FireDAC.Stan.Error, FireDAC.UI.Intf, FireDAC.Phys.Intf, FireDAC.Stan.Pool,
FireDAC.Phys, FireDAC.ConsoleUI.Wait;
type
TWebModule2 = class(TWebModule)
procedure WebModule2TConnectedAction(Sender: TObject; Request: TWebRequest;
Response: TWebResponse; var Handled: Boolean);
private
{ Private declarations }
procedure ParseJson(var Request: TWebRequest);
public
{ Public declarations }
end;
var
WebModuleClass: TComponentClass = TWebModule2;
N : TJsonNode;
implementation
{%CLASSGROUP 'System.Classes.TPersistent'}
{$R *.dfm}
procedure TWebModule2.ParseJson(var Request: TWebRequest);
begin
N := TJsonNode.Create;
try
N.Parse(Request.Content);
except
begin
Response.Content := 'Something went wrong during parsing of Incoming Json from Client machine';
end;
end;//try
end;
procedure TWebModule2.WebModule2TConnectedAction(Sender: TObject;
Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
begin
ParseJson(Request);
writeln(Timetostr(now));
Response.Content := Request.Content;
end;
end.
Unit JsonTools follows
type
TJsonNode = class
public
{ A parent node owns all children. Only destroy a node if it has no parent.
To destroy a child node use Delete or Clear methods instead. }
destructor Destroy; override;
{ GetEnumerator adds 'for ... in' statement support }
function GetEnumerator: TJsonNodeEnumerator;
{ Loading and saving methods }
procedure LoadFromStream(Stream: TStream);
procedure SaveToStream(Stream: TStream);
procedure LoadFromFile(const FileName: string);
procedure SaveToFile(const FileName: string);
{ Convert a json string into a value or a collection of nodes. If the
current node is root then the json must be an array or object. }
procedure Parse(const Json: string);
{ The same as Parse, but returns true if no exception is caught }
function TryParse(const Json: string): Boolean;
{ Add a child node by node kind. If the current node is an array then the
name parameter will be discarded. If the current node is not an array or
object the Add methods will convert the node to an object and discard
its current value.
Note: If the current node is an object then adding an existing name will
overwrite the matching child node instead of adding. }
function Add(const Name: string; K: TJsonNodeKind = nkObject): TJsonNode; overload;
function Add(const Name: string; B: Boolean): TJsonNode; overload;
function Add(const Name: string; const N: Double): TJsonNode; overload;
function Add(const Name: string; const S: string): TJsonNode; overload;
{ Delete a child node by index or name }
procedure Delete(Index: Integer); overload;
procedure Delete(const Name: string); overload;
{ Remove all child nodes }
procedure Clear;
{ Get a child node by index. EJsonException is raised if node is not an
array or object or if the index is out of bounds.
See also: Count }
function Child(Index: Integer): TJsonNode; overload;
{ Get a child node by name. If no node is found nil will be returned. }
function Child(const Name: string): TJsonNode; overload;
{ Search for a node using a path string }
function Find(const Path: string): TJsonNode;
{ Format the node and all its children as json }
function ToString: string; override;
{ Root node is read only. A node the root when it has no parent. }
property Root: TJsonNode read GetRoot;
{ Parent node is read only }
property Parent: TJsonNode read FParent;
{ Kind can also be changed using the As methods:
Note: Changes to Kind cause Value to be reset to a default value. }
property Kind: TJsonNodeKind read FKind write SetKind;
{ Name is unique within the scope }
property Name: string read GetName write SetName;
{ Value of the node in json e.g. '[]', '"hello\nworld!"', 'true', or '1.23e2' }
property Value: string read GetValue write Parse;
{ The number of child nodes. If node is not an object or array this
property will return 0. }
property Count: Integer read GetCount;
{ AsJson is the more efficient version of Value. Text returned from AsJson
is the most compact representation of the node in json form.
Note: If you are writing a services to transmit or receive json data then
use AsJson. If you want friendly human readable text use Value. }
property AsJson: string read GetAsJson write Parse;
{ Convert the node to an array }
property AsArray: TJsonNode read GetAsArray;
{ Convert the node to an object }
property AsObject: TJsonNode read GetAsObject;
{ Convert the node to null }
property AsNull: TJsonNode read GetAsNull;
{ Convert the node to a bool }
property AsBoolean: Boolean read GetAsBoolean write SetAsBoolean;
{ Convert the node to a string }
property AsString: string read GetAsString write SetAsString;
{ Convert the node to a number }
property AsNumber: Double read GetAsNumber write SetAsNumber;
end;