32using namespace std::string_literals;
38RWebWindow::WebConn::~WebConn()
41 fHold->SetTextContent(
"console.log('execute holder script'); if (window) setTimeout (window.close, 1000); if (window) window.close();");
42 fHold->NotifyCondition();
103 for (
auto &conn : lst) {
104 conn->fActive =
false;
105 for (
auto &elem: conn->fEmbed) {
106 elem.second->fMaster.reset();
107 elem.second->fMasterConnId = 0;
108 elem.second->fMasterChannel = -1;
110 conn->fEmbed.clear();
113 fMgr->Unregister(*
this);
126 if (!
fConn.empty()) {
139std::shared_ptr<RWebWindowWSHandler>
158 return fMgr->GetUrl(*
this, remote);
166 return fMgr->GetServer();
176 return fMgr->ShowWindow(*
this, args);
193 connid =
fMgr->ShowWindow(*
this, args);
209 if (entry->fHeadlessMode)
210 return entry->fConnId;
213 for (
auto &conn :
fConn) {
214 if (conn->fHeadlessMode)
215 return conn->fConnId;
232 if (!entry->fHeadlessMode)
233 return entry->fConnId;
236 for (
auto &conn :
fConn) {
237 if (!conn->fHeadlessMode)
238 return conn->fConnId;
251 for (
auto &conn :
fConn) {
252 if (conn->fWSId == wsid)
260 std::shared_ptr<WebConn> key;
261 std::string keyvalue;
270 if (!keyvalue.empty())
282 fConn.emplace_back(key);
284 fConn.emplace_back(std::make_shared<WebConn>(++
fConnCnt, wsid));
297 std::shared_ptr<WebConn> res;
302 for (
size_t n = 0;
n <
fConn.size(); ++
n)
303 if (
fConn[
n]->fWSId == wsid) {
304 res = std::move(
fConn[
n]);
306 res->fActive =
false;
312 for (
auto &elem: res->fEmbed) {
313 elem.second->fMaster.reset();
314 elem.second->fMasterConnId = 0;
315 elem.second->fMasterChannel = -1;
330 std::string query = arg->GetQuery();
332 if (query.compare(0, 4,
"key=") != 0)
335 std::string key = query.substr(4);
337 std::shared_ptr<THttpCallArg> prev;
339 bool found_key =
false;
345 if (entry->fKey == key) {
348 prev = std::move(entry->fHold);
353 for (
auto &conn :
fConn) {
354 if (conn->fKey == key) {
356 prev = std::move(conn->fHold);
364 prev->SetTextContent(
"console.log('execute holder script'); if (window) window.close();");
365 prev->NotifyCondition();
404 connid = entry.fConnId;
406 arg = std::move(entry.fData);
437 auto conn = std::make_shared<WebConn>(++
fConnCnt, headless_mode, key);
456 if (entry->fKey == key)
460 for (
auto &conn :
fConn) {
461 if (conn->fKey == key)
477 return conn ? true :
false;
493 key = std::to_string(rnd.
Integer(0x100000));
494 }
while ((--ntry > 0) &&
HasKey(key));
496 if (ntry <= 0) key.clear();
511 float tmout =
fMgr->GetLaunchTmout();
518 auto pred = [&](std::shared_ptr<WebConn> &
e) {
519 std::chrono::duration<double> diff =
stamp -
e->fSendStamp;
521 if (diff.count() > tmout) {
523 selected.emplace_back(
e);
544 double batch_tmout = 20.;
546 std::vector<std::shared_ptr<WebConn>> clr;
551 auto pred = [&](std::shared_ptr<WebConn> &conn) {
552 std::chrono::duration<double> diff =
stamp - conn->fSendStamp;
554 if ((diff.count() > batch_tmout) && conn->fHeadlessMode) {
555 conn->fActive =
false;
556 clr.emplace_back(conn);
565 for (
auto &entry : clr)
621 fMgr->AssignWindowThreadId(*
this);
667 if (conn->fKeyUsed > 0) {
668 R__LOG_ERROR(
WebGUILog()) <<
"key " << key <<
" was used for establishing connection, call ShowWindow again";
696 bool do_clear_on_close =
false;
697 if (conn->fKeyUsed < 0) {
709 if (do_clear_on_close)
735 char *str_end =
nullptr;
737 unsigned long ackn_oper = std::strtoul(buf, &str_end, 10);
738 if (!str_end || *str_end !=
':') {
743 unsigned long can_send = std::strtoul(str_end + 1, &str_end, 10);
744 if (!str_end || *str_end !=
':') {
749 unsigned long nchannel = std::strtoul(str_end + 1, &str_end, 10);
750 if (!str_end || *str_end !=
':') {
755 Long_t processed_len = (str_end + 1 - buf);
767 std::lock_guard<std::mutex> grd(conn->fMutex);
769 conn->fSendCredits += ackn_oper;
771 conn->fClientCredits = (
int)can_send;
772 conn->fRecvStamp =
stamp;
780 if ((nchannel != 0) || (cdata.find(
"READY=") == 0)) {
793 if ((cdata.find(
"READY=") == 0) && !conn->fReady) {
794 std::string key = cdata.substr(6);
801 if (!key.empty() && !conn->fKey.empty() && (conn->fKey != key)) {
802 R__LOG_ERROR(
WebGUILog()) <<
"Key mismatch after established connection " << key <<
" != " << conn->fKey;
815 }
else if (cdata.compare(0,8,
"CLOSECH=") == 0) {
816 int channel = std::stoi(cdata.substr(8));
817 auto iter = conn->fEmbed.find(channel);
818 if (iter != conn->fEmbed.end()) {
820 conn->fEmbed.erase(iter);
822 }
else if (cdata ==
"GENERATE_KEY") {
831 SubmitData(conn->fConnId,
true,
"NEW_KEY="s + newkey, -1);
837 }
else if (
fPanelName.length() && (conn->fReady < 10)) {
838 if (cdata ==
"PANEL_READY") {
846 }
else if (nchannel == 1) {
848 }
else if (nchannel > 1) {
850 auto embed_window = conn->fEmbed[nchannel];
852 embed_window->ProvideQueueEntry(conn->fConnId,
kind_Data, std::move(cdata));
872 std::lock_guard<std::mutex> grd(conn->fMutex);
873 conn->fDoingSend =
false;
892 if (conn->fSendCredits <= 0) {
897 if (conn->fDoingSend) {
903 buf.reserve(
data.length() + 100);
905 buf.append(std::to_string(conn->fRecvCount));
907 buf.append(std::to_string(conn->fSendCredits));
909 conn->fRecvCount = 0;
910 conn->fSendCredits--;
912 buf.append(std::to_string(chid));
917 }
else if (
data.length()==0) {
918 buf.append(
"$$nullbinary$$");
920 buf.append(
"$$binary$$");
932 std::string hdr,
data;
935 std::lock_guard<std::mutex> grd(conn->fMutex);
937 if (!conn->fActive || (conn->fSendCredits <= 0) || conn->fDoingSend)
return false;
939 if (!conn->fQueue.empty()) {
942 if (!hdr.empty() && !item.
fText)
945 }
else if ((conn->fClientCredits < 3) && (conn->fRecvCount > 1)) {
950 if (hdr.empty())
return false;
952 conn->fDoingSend =
true;
958 res =
fWSHandler->SendCharStarWS(conn->fWSId, hdr.c_str());
964 if (res >=0)
return true;
967 std::lock_guard<std::mutex> grd(conn->fMutex);
968 conn->fDoingSend =
false;
986 for (
auto &conn : arr)
992 }
while (!only_once);
1039 std::string res(
"../");
1040 res.append(
win.GetAddr());
1095 auto sz =
fConn.size();
1129 return ((num >= 0) && (num < (
int)
fConn.size()) &&
fConn[num]->fActive) ?
fConn[num]->fConnId : 0;
1141 for (
auto &conn :
fConn) {
1142 if (connid && (conn->fConnId != connid))
1144 if (conn->fActive || !only_active)
1150 if (!connid || (conn->fConnId == connid))
1189 for (
auto &conn :
fConn) {
1190 if ((conn->fActive || !only_active) && (!connid || (conn->fConnId == connid)))
1191 arr.push_back(conn);
1196 if (!connid || (conn->fConnId == connid))
1197 arr.push_back(conn);
1214 for (
auto &conn : arr) {
1216 std::lock_guard<std::mutex> grd(conn->fMutex);
1218 if (
direct && (!conn->fQueue.empty() || (conn->fSendCredits == 0) || conn->fDoingSend))
1221 if (conn->fQueue.size() >= maxqlen)
1238 std::lock_guard<std::mutex> grd(conn->fMutex);
1239 int len = conn->fQueue.size();
1240 if (
len > maxq) maxq =
len;
1259 auto cnt = arr.size();
1262 bool clear_queue =
false;
1271 for (
auto &conn : arr) {
1277 fname.append(
"msg");
1280 fname.append(
"_ch");
1281 fname.append(std::to_string(chid));
1283 fname.append(txt ?
".txt" :
".bin");
1285 std::ofstream ofs(fname);
1286 ofs.write(
data.c_str(),
data.length());
1298 conn->fSendStamp =
stamp;
1300 std::lock_guard<std::mutex> grd(conn->fMutex);
1303 while (!conn->fQueue.empty())
1307 if (conn->fQueue.size() < maxqlen) {
1309 conn->fQueue.emplace(chid, txt, std::string(
data));
1311 conn->fQueue.emplace(chid, txt, std::move(
data));
1350 std::copy((
const char *)
data, (
const char *)
data +
len, buf.begin());
1351 SubmitData(connid,
false, std::move(buf), 1);
1369 }
else if (
fMgr->IsUseHttpThread()) {
1371 R__LOG_ERROR(
WebGUILog()) <<
"create web window from main thread when THttpServer created with special thread - not supported";
1403 std::thread thrd([
this] {
1501 return fMgr->WaitFor(*
this, check);
1529 return fMgr->WaitFor(*
this, check,
true, duration);
1562 if (arr.size() == 0)
1566 if (arr[0]->fEmbed.find(channel) != arr[0]->fEmbed.end())
1569 arr[0]->fEmbed[channel] = window;
1571 return arr[0]->fConnId;
1581 for (
auto &conn : arr) {
1582 auto iter = conn->fEmbed.find(channel);
1583 if (iter != conn->fEmbed.end())
1584 conn->fEmbed.erase(iter);
1634 window->fMaster = args.
fMaster;
1635 window->fMasterConnId = connid;
1648 return window->Show(args);
#define R__LOG_WARNING(...)
#define R__LOG_ERROR(...)
#define R__LOG_DEBUG(DEBUGLEVEL,...)
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t stamp
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t win
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Holds different arguments for starting browser with RWebDisplayHandle::Display() method.
void SetHeadless(bool on=true)
set headless mode
int fMasterChannel
! used master channel
EBrowserKind GetBrowserKind() const
returns configured browser kind, see EBrowserKind for supported values
std::shared_ptr< RWebWindow > fMaster
! master window
@ kEmbedded
window will be embedded into other, no extra browser need to be started
static int GetBoolEnv(const std::string &name, int dfl=-1)
Parse boolean gEnv variable which should be "yes" or "no".
Represents web window, which can be shown in web browser or any other supported environment.
bool CheckDataToSend(std::shared_ptr< WebConn > &conn)
Checks if one should send data for specified connection Returns true when send operation was performe...
std::vector< std::shared_ptr< WebConn > > ConnectionsList_t
int WaitFor(WebWindowWaitFunc_t check)
Waits until provided check function or lambdas returns non-zero value Check function has following si...
unsigned AddEmbedWindow(std::shared_ptr< RWebWindow > window, int channel)
Add embed window.
std::shared_ptr< RWebWindow > fMaster
! master window where this window is embedded
void CheckInactiveConnections()
Check if there are connection which are inactive for longer time For instance, batch browser will be ...
ConnectionsList_t GetConnections(unsigned connid=0, bool only_active=false) const
returns connection list (or all active connections)
void SetClearOnClose(const std::shared_ptr< void > &handle=nullptr)
Set handle which is cleared when last active connection is closed Typically can be used to destroy we...
std::string fUserArgs
! arbitrary JSON code, which is accessible via conn.getUserArgs() method
int fMasterChannel
! channel id in the master window
void StartThread()
Start special thread which will be used by the window to handle all callbacks One has to be sure,...
float GetOperationTmout() const
Returns timeout for synchronous WebWindow operations.
std::shared_ptr< WebConn > FindConnection(unsigned wsid)
Find connection with specified websocket id.
void SetConnToken(const std::string &token="")
Configures connection token (default none) When specified, in URL of webpage such token should be pro...
unsigned MakeHeadless(bool create_new=false)
Start headless browser for specified window Normally only single instance is used,...
std::string GetUrl(bool remote=true)
Return URL string to access web window.
void CloseConnections()
Closes all connection to clients Normally leads to closing of all correspondent browser windows Some ...
void SetDefaultPage(const std::string &page)
Set content of default window HTML page This page returns when URL address of the window will be requ...
std::thread fWindowThrd
! special thread for that window
int NumConnections(bool with_pending=false) const
Returns current number of active clients connections.
unsigned GetId() const
Returns ID for the window - unique inside window manager.
ConnectionsList_t fConn
! list of all accepted connections
void InvokeCallbacks(bool force=false)
Invoke callbacks with existing data Must be called from appropriate thread.
std::string fProtocolPrefix
! prefix for created files names
std::string GetClientVersion() const
Returns current client version.
void SetConnectCallBack(WebWindowConnectCallback_t func)
Set call-back function for new connection.
WebWindowConnectCallback_t fConnCallback
! callback for connect event
unsigned GetMaxQueueLength() const
Return maximal queue length of data which can be held by window.
void Sync()
Special method to process all internal activity when window runs in separate thread.
void UseServerThreads()
Let use THttpServer threads to process requests WARNING!!! only for expert use Should be only used wh...
void TerminateROOT()
Terminate ROOT session Tries to correctly close THttpServer, associated with RWebWindowsManager After...
unsigned fConnLimit
! number of allowed active connections
void Send(unsigned connid, const std::string &data)
Sends data to specified connection.
bool fCallbacksThrdIdSet
! flag indicating that thread id is assigned
unsigned Show(const RWebDisplayArgs &args="")
Show window in specified location.
THttpServer * GetServer()
Return THttpServer instance serving requests to the window.
unsigned AddDisplayHandle(bool headless_mode, const std::string &key, std::unique_ptr< RWebDisplayHandle > &handle)
Add display handle and associated key Key is random number generated when starting new window When cl...
unsigned fMasterConnId
! master connection id
void AssignThreadId()
Assign thread id which has to be used for callbacks WARNING!!! only for expert use Automatically done...
bool fSendMT
! true is special threads should be used for sending data
void SendBinary(unsigned connid, const void *data, std::size_t len)
Send binary data to specified connection.
static std::shared_ptr< RWebWindow > Create()
Create new RWebWindow Using default RWebWindowsManager.
std::thread::id fCallbacksThrdId
! thread id where callbacks should be invoked
std::chrono::time_point< std::chrono::system_clock > timestamp_t
std::string fClientVersion
! configured client version, used as prefix in scripts URL
bool ProcessBatchHolder(std::shared_ptr< THttpCallArg > &arg)
Process special http request, used to hold headless browser running Such requests should not be repli...
unsigned fConnCnt
! counter of new connections to assign ids
void SetDisconnectCallBack(WebWindowConnectCallback_t func)
Set call-back function for disconnecting.
std::string fPanelName
! panel name which should be shown in the window
void SetDataCallBack(WebWindowDataCallback_t func)
Set call-back function for data, received from the clients via websocket.
unsigned fProtocolConnId
! connection id, which is used for writing protocol
void SetUserArgs(const std::string &args)
Set arbitrary JSON data, which is accessible via conn.getUserArgs() method in JavaScript This JSON co...
static unsigned ShowWindow(std::shared_ptr< RWebWindow > window, const RWebDisplayArgs &args="")
Static method to show web window Has to be used instead of RWebWindow::Show() when window potentially...
void StopThread()
Stop special thread.
WebWindowDataCallback_t fDataCallback
! main callback when data over channel 1 is arrived
void SubmitData(unsigned connid, bool txt, std::string &&data, int chid=1)
Internal method to send data.
~RWebWindow()
RWebWindow destructor Closes all connections and remove window from manager.
void CloseConnection(unsigned connid)
Close specified connection.
unsigned GetConnectionId(int num=0) const
Returns connection id for specified connection sequence number Only active connections are returned -...
std::string GetConnToken() const
Returns configured connection token.
ConnectionsList_t fPendingConn
! list of pending connection with pre-assigned keys
void SetConnLimit(unsigned lmt=0)
Configure maximal number of allowed connections - 0 is unlimited Will not affect already existing con...
void SetPanelName(const std::string &name)
Configure window to show some of existing JSROOT panels It uses "file:rootui5sys/panel/panel....
RWebWindow()
RWebWindow constructor Should be defined here because of std::unique_ptr<RWebWindowWSHandler>
std::shared_ptr< WebConn > FindOrCreateConnection(unsigned wsid, bool make_new, const char *query)
Find connection with given websocket id.
bool fHasWindowThrd
! indicate if special window thread was started
int GetSendQueueLength(unsigned connid) const
Returns send queue length for specified connection.
std::shared_ptr< WebConn > RemoveConnection(unsigned wsid)
Remove connection with given websocket id.
std::shared_ptr< RWebWindowWSHandler > CreateWSHandler(std::shared_ptr< RWebWindowsManager > mgr, unsigned id, double tmout)
Assigns manager reference, window id and creates websocket handler, used for communication with the c...
std::shared_ptr< WebConn > _FindConnWithKey(const std::string &key) const
Find connection with specified key.
bool CanSend(unsigned connid, bool direct=true) const
Returns true if sending via specified connection can be performed.
std::string GetUserArgs() const
Returns configured user arguments for web window See SetUserArgs method for more details.
void RecordData(const std::string &fname="protocol.json", const std::string &fprefix="")
Configures recording of communication data in protocol file Provided filename will be used to store J...
void CheckThreadAssign()
Internal method to verify and thread id has to be assigned from manager again Special case when Proce...
bool HasKey(const std::string &key) const
Returns true if provided key value already exists (in processes map or in existing connections)
unsigned GetDisplayConnection() const
Returns first connection id where window is displayed It could be that connection(s) not yet fully es...
unsigned GetConnLimit() const
returns configured connections limit (0 - default)
std::string GetRelativeAddr(const std::shared_ptr< RWebWindow > &win) const
Returns relative URL address for the specified window Address can be required if one needs to access ...
void Run(double tm=0.)
Run window functionality for specified time If no action can be performed - just sleep specified time...
std::string GetAddr() const
Returns window address which is used in URL.
std::shared_ptr< RWebWindowWSHandler > fWSHandler
! specialize websocket handler for all incoming connections
bool fUseServerThreads
! indicates that server thread is using, no special window thread
std::string fProtocolFileName
! local file where communication protocol will be written
std::shared_ptr< RWebWindowsManager > fMgr
! display manager
void CheckPendingConnections()
Check if started process(es) establish connection.
std::string fConnToken
! value of "token" URL parameter which should be provided for connecting window
std::mutex fInputQueueMutex
! mutex to protect input queue
std::string _MakeSendHeader(std::shared_ptr< WebConn > &conn, bool txt, const std::string &data, int chid)
Internal method to prepare text part of send data Should be called under locked connection mutex.
bool IsNativeOnlyConn() const
returns true if only native (own-created) connections are allowed
bool ProcessWS(THttpCallArg &arg)
Processing of websockets call-backs, invoked from RWebWindowWSHandler Method invoked from http server...
bool HasConnection(unsigned connid=0, bool only_active=true) const
returns true if specified connection id exists
int fProtocolCnt
! counter for protocol recording
std::queue< QueueEntry > fInputQueue
! input queue for all callbacks
bool fProcessMT
! if window event processing performed in dedicated thread
std::string fProtocol
! protocol
void ProvideQueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&arg)
Provide data to user callback User callback must be executed in the window thread.
void CompleteWSSend(unsigned wsid)
Complete websocket send operation Clear "doing send" flag and check if next operation has to be start...
unsigned fId
! unique identifier
float fOperationTmout
! timeout in seconds to perform synchronous operation, default 50s
unsigned FindHeadlessConnection()
Returns connection id of window running in headless mode This can be special connection which may run...
int WaitForTimed(WebWindowWaitFunc_t check)
Waits until provided check function or lambdas returns non-zero value Check function has following si...
WebWindowConnectCallback_t fDisconnCallback
! callback for disconnect event
void SetClientVersion(const std::string &vers)
Set client version, used as prefix in scripts URL When changed, web browser will reload all related J...
void RemoveEmbedWindow(unsigned connid, int channel)
Remove RWebWindow associated with the channelfEmbed.
void SetCallBacks(WebWindowConnectCallback_t conn, WebWindowDataCallback_t data, WebWindowConnectCallback_t disconn=nullptr)
Set call-backs function for connect, data and disconnect events.
std::string GenerateKey() const
Generate new unique key for the window.
std::shared_ptr< void > fClearOnClose
! entry which is cleared when last connection is closed
std::mutex fConnMutex
! mutex used to protect connection list
static bool IsMainThrd()
Returns true when called from main process Main process recognized at the moment when library is load...
static std::shared_ptr< RWebWindowsManager > & Instance()
Returns default window manager Used to display all standard ROOT elements like TCanvas or TFitPanel.
Contains arguments for single HTTP call.
UInt_t GetWSId() const
get web-socket id
const void * GetPostData() const
return pointer on posted with request data
const char * GetQuery() const
returns request query (string after ? in request URL)
Long_t GetPostDataLength() const
return length of posted with request data
Bool_t IsMethod(const char *name) const
returns kTRUE if post method is used
Online http server for arbitrary ROOT application.
Random number generator class based on M.
void SetSeed(ULong_t seed=0) override
Set the random generator sequence if seed is 0 (default value) a TUUID is generated and used to fill ...
virtual UInt_t Integer(UInt_t imax)
Returns a random integer uniformly distributed on the interval [ 0, imax-1 ].
This class represents a WWW compatible URL.
const char * GetValueFromOptions(const char *key) const
Return a value for a given key from the URL options.
void SetOptions(const char *opt)
Bool_t HasOption(const char *key) const
Returns true if the given key appears in the URL options list.
void swap(RDirectoryEntry &e1, RDirectoryEntry &e2) noexcept
RLogChannel & WebGUILog()
Log channel for WebGUI diagnostics.
std::function< void(unsigned)> WebWindowConnectCallback_t
function signature for connect/disconnect call-backs argument is connection id
std::function< void(unsigned, const std::string &)> WebWindowDataCallback_t
function signature for call-backs from the window clients first argument is connection id,...
std::function< int(double)> WebWindowWaitFunc_t
function signature for waiting call-backs Such callback used when calling thread need to waits for so...
static constexpr double s
std::string fData
! text or binary data
std::shared_ptr< THttpCallArg > fHold
! request used to hold headless browser