33#include "../../../core/foundation/res/ROOT/RSha256.hxx"
36using namespace std::string_literals;
45 fHold->SetTextContent(
"console.log('execute holder script'); if (window) setTimeout (window.close, 1000); if (window) window.close();");
46 fHold->NotifyCondition();
90 std::vector<MasterConn> lst;
96 for (
auto &entry : lst)
97 fMaster->RemoveEmbedWindow(entry.connid, entry.channel);
116 for (
auto &conn : lst) {
117 conn->fActive =
false;
118 for (
auto &elem: conn->fEmbed)
119 elem.second->RemoveMasterConnection();
120 conn->fEmbed.clear();
123 fMgr->Unregister(*
this);
136 if (!
fConn.empty()) {
149std::shared_ptr<RWebWindowWSHandler>
173 return fMgr->GetUrl(*
this, remote);
181 return fMgr->GetServer();
191 return fMgr->ShowWindow(*
this, args);
208 connid =
fMgr->ShowWindow(*
this, args);
224 if (entry->fHeadlessMode)
225 return entry->fConnId;
228 for (
auto &conn :
fConn) {
229 if (conn->fHeadlessMode)
230 return conn->fConnId;
247 if (!entry->fHeadlessMode)
248 return entry->fConnId;
251 for (
auto &conn :
fConn) {
252 if (!conn->fHeadlessMode)
253 return conn->fConnId;
266 for (
auto &conn :
fConn) {
267 if (conn->fWSId == wsid)
280 std::shared_ptr<WebConn> res;
285 for (
size_t n = 0;
n <
fConn.size(); ++
n)
286 if (
fConn[
n]->fWSId == wsid) {
287 res = std::move(
fConn[
n]);
289 res->fActive =
false;
295 for (
auto &elem: res->fEmbed)
296 elem.second->RemoveMasterConnection(res->fConnId);
325 std::vector<MasterConn> lst;
332 if (!connid || entry.connid == connid)
333 lst.emplace_back(entry);
354 if (iter->connid == connid) {
374 std::string query = arg->GetQuery();
376 if (query.compare(0, 4,
"key=") != 0)
379 std::string key = query.substr(4);
381 std::shared_ptr<THttpCallArg> prev;
383 bool found_key =
false;
389 if (entry->fKey == key) {
392 prev = std::move(entry->fHold);
397 for (
auto &conn :
fConn) {
398 if (conn->fKey == key) {
400 prev = std::move(conn->fHold);
408 prev->SetTextContent(
"console.log('execute holder script'); if (window) window.close();");
409 prev->NotifyCondition();
451 connid = entry.fConnId;
453 arg = std::move(entry.fData);
485 if (entry->fKey == key) {
486 entry->fHeadlessMode = headless_mode;
487 std::swap(entry->fDisplayHandle, handle);
488 return entry->fConnId;
492 auto conn = std::make_shared<WebConn>(++
fConnCnt, headless_mode, key);
494 std::swap(conn->fDisplayHandle, handle);
511 if (entry->fKey == key)
515 for (
auto &conn :
fConn) {
516 if (conn->fKey == key)
532bool RWebWindow::_CanTrustIn(std::shared_ptr<WebConn> &conn,
const std::string &hash,
const std::string &ntry,
bool remote,
bool test_first_time)
537 int intry = ntry.empty() ? -1 : std::stoi(ntry);
540 auto expected =
HMAC(conn->fKey,
fMgr->fUseSessionKey && remote ?
fMgr->fSessionKey :
""s, msg.Data(), msg.Length());
543 return (conn->fKey.empty() && hash.empty()) || (hash == conn->fKey) || (hash == expected);
546 if (!remote && (hash == conn->fKey))
549 if (hash == expected) {
550 if (test_first_time) {
551 if (conn->fKeyUsed >= intry) {
558 conn->fKeyUsed = intry;
560 if (conn->fKeyUsed != intry) {
582 return conn ? true :
false;
595 auto pred = [&](std::shared_ptr<WebConn> &
e) {
596 if (
e->fKey == key) {
607 for (
auto &conn : lst)
620 R__ASSERT((!
HasKey(key) && (key !=
fMgr->fSessionKey)) &&
"Fail to generate window connection key");
635 float tmout =
fMgr->GetLaunchTmout();
642 auto pred = [&](std::shared_ptr<WebConn> &
e) {
643 std::chrono::duration<double> diff =
stamp -
e->fSendStamp;
645 if (diff.count() > tmout) {
646 R__LOG_DEBUG(0,
WebGUILog()) <<
"Remove pending connection " <<
e->fKey <<
" after " << diff.count() <<
" sec";
647 selected.emplace_back(
e);
667 double batch_tmout = 20.;
669 std::vector<std::shared_ptr<WebConn>> clr;
674 auto pred = [&](std::shared_ptr<WebConn> &conn) {
675 std::chrono::duration<double> diff =
stamp - conn->fSendStamp;
677 if ((diff.count() > batch_tmout) && conn->fHeadlessMode) {
678 conn->fActive =
false;
679 clr.emplace_back(conn);
688 for (
auto &entry : clr)
780 std::string key, ntry;
786 if (
_CanTrustIn(conn, key, ntry, is_remote,
true ))
799 std::shared_ptr<WebConn> conn;
800 std::string key, ntry;
821 conn->fActive =
true;
827 fConn.emplace_back(conn);
847 std::string key, ntry;
853 if (!
_CanTrustIn(conn, key, ntry, is_remote,
true ))
864 bool do_clear_on_close =
false;
865 if (!conn->fNewKey.empty()) {
869 conn->fKey = conn->fNewKey;
870 conn->fNewKey.clear();
880 if (do_clear_on_close)
904 const char *buf0 = (
const char *) arg.
GetPostData();
907 const char *buf = strchr(buf0,
':');
913 Int_t code_len = buf - buf0;
914 data_len -= code_len + 1;
922 bool is_none = strncmp(buf0,
"none:", 5) == 0, is_match =
false;
925 std::string hmac =
HMAC(conn->fKey,
fMgr->fSessionKey, buf, data_len);
927 is_match = strncmp(buf0, hmac.c_str(), code_len) == 0;
928 }
else if (!
fMgr->fUseSessionKey) {
947 char *str_end =
nullptr;
949 unsigned long oper_seq = std::strtoul(buf, &str_end, 10);
950 if (!str_end || *str_end !=
':') {
955 if (oper_seq <= conn->fRecvSeq) {
960 conn->fRecvSeq = oper_seq;
962 unsigned long ackn_oper = std::strtoul(str_end + 1, &str_end, 10);
963 if (!str_end || *str_end !=
':') {
968 unsigned long can_send = std::strtoul(str_end + 1, &str_end, 10);
969 if (!str_end || *str_end !=
':') {
974 unsigned long nchannel = std::strtoul(str_end + 1, &str_end, 10);
975 if (!str_end || *str_end !=
':') {
980 Long_t processed_len = (str_end + 1 - buf);
982 if (processed_len > data_len) {
987 std::string cdata(str_end + 1, data_len - processed_len);
992 std::lock_guard<std::mutex> grd(conn->fMutex);
994 conn->fSendCredits += ackn_oper;
996 conn->fClientCredits = (
int)can_send;
997 conn->fRecvStamp =
stamp;
1005 if ((nchannel != 0) || (cdata.find(
"READY=") == 0)) {
1016 if (nchannel == 0) {
1018 if ((cdata.compare(0, 6,
"READY=") == 0) && !conn->fReady) {
1020 std::string key = cdata.substr(6);
1027 if (!key.empty() && !conn->fKey.empty() && (conn->fKey != key)) {
1028 R__LOG_ERROR(
WebGUILog()) <<
"Key mismatch after established connection " << key <<
" != " << conn->fKey;
1041 }
else if (cdata.compare(0, 8,
"CLOSECH=") == 0) {
1042 int channel = std::stoi(cdata.substr(8));
1043 auto iter = conn->fEmbed.find(channel);
1044 if (iter != conn->fEmbed.end()) {
1046 conn->fEmbed.erase(iter);
1048 }
else if (cdata.compare(0, 7,
"RESIZE=") == 0) {
1049 auto p = cdata.find(
",");
1050 if (
p != std::string::npos) {
1051 auto width = std::stoi(cdata.substr(7,
p - 7));
1052 auto height = std::stoi(cdata.substr(
p + 1));
1053 if ((
width > 0) && (
height > 0) && conn->fDisplayHandle)
1056 }
else if (cdata ==
"GENERATE_KEY") {
1061 if(!conn->fNewKey.empty())
1062 SubmitData(conn->fConnId,
true,
"NEW_KEY="s + conn->fNewKey, -1);
1065 }
else if (
fPanelName.length() && (conn->fReady < 10)) {
1066 if (cdata ==
"PANEL_READY") {
1074 }
else if (nchannel == 1) {
1076 }
else if (nchannel > 1) {
1078 auto embed_window = conn->fEmbed[nchannel];
1080 embed_window->ProvideQueueEntry(conn->fConnId,
kind_Data, std::move(cdata));
1100 std::lock_guard<std::mutex> grd(conn->fMutex);
1101 conn->fDoingSend =
false;
1120 if (conn->fSendCredits <= 0) {
1125 if (conn->fDoingSend) {
1131 buf.reserve(
data.length() + 100);
1133 buf.append(std::to_string(conn->fSendSeq++));
1135 buf.append(std::to_string(conn->fRecvCount));
1137 buf.append(std::to_string(conn->fSendCredits));
1139 conn->fRecvCount = 0;
1140 conn->fSendCredits--;
1142 buf.append(std::to_string(chid));
1147 }
else if (
data.length()==0) {
1148 buf.append(
"$$nullbinary$$");
1150 buf.append(
"$$binary$$");
1151 if (!conn->fKey.empty() && !
fMgr->fSessionKey.empty() &&
fMgr->fUseSessionKey)
1152 buf.append(
HMAC(conn->fKey,
fMgr->fSessionKey,
data.data(),
data.length()));
1164 std::string hdr,
data, prefix;
1167 std::lock_guard<std::mutex> grd(conn->fMutex);
1169 if (!conn->fActive || (conn->fSendCredits <= 0) || conn->fDoingSend)
return false;
1171 if (!conn->fQueue.empty()) {
1174 if (!hdr.empty() && !item.
fText)
1177 }
else if ((conn->fClientCredits < 3) && (conn->fRecvCount > 1)) {
1182 if (hdr.empty())
return false;
1184 conn->fDoingSend =
true;
1188 if (!conn->fKey.empty() && !
fMgr->fSessionKey.empty() &&
fMgr->fUseSessionKey) {
1189 prefix =
HMAC(conn->fKey,
fMgr->fSessionKey, hdr.c_str(), hdr.length());
1195 hdr.insert(0, prefix);
1200 res =
fWSHandler->SendCharStarWS(conn->fWSId, hdr.c_str());
1202 res =
fWSHandler->SendHeaderWS(conn->fWSId, hdr.c_str(),
data.data(),
data.length());
1206 if (res >=0)
return true;
1209 std::lock_guard<std::mutex> grd(conn->fMutex);
1210 conn->fDoingSend =
false;
1228 for (
auto &conn : arr)
1234 }
while (!only_once);
1281 std::string res(
"../");
1282 res.append(
win.GetAddr());
1343 auto sz =
fConn.size();
1383 return ((num >= 0) && (num < (
int)
fConn.size()) &&
fConn[num]->fActive) ?
fConn[num]->fConnId : 0;
1393 std::vector<unsigned> res;
1401 if (entry.connid != excludeid)
1402 res.emplace_back(entry.connid);
1404 for (
auto & entry :
fConn)
1405 if (entry->fActive && (entry->fConnId != excludeid))
1406 res.emplace_back(entry->fConnId);
1421 for (
auto &conn :
fConn) {
1422 if (connid && (conn->fConnId != connid))
1424 if (conn->fActive || !only_active)
1430 if (!connid || (conn->fConnId == connid))
1469 for (
auto &conn :
fConn) {
1470 if ((conn->fActive || !only_active) && (!connid || (conn->fConnId == connid)))
1471 arr.push_back(conn);
1476 if (!connid || (conn->fConnId == connid))
1477 arr.push_back(conn);
1494 for (
auto &conn : arr) {
1496 std::lock_guard<std::mutex> grd(conn->fMutex);
1498 if (
direct && (!conn->fQueue.empty() || (conn->fSendCredits == 0) || conn->fDoingSend))
1501 if (conn->fQueue.size() >= maxqlen)
1518 std::lock_guard<std::mutex> grd(conn->fMutex);
1519 int len = conn->fQueue.size();
1520 if (
len > maxq) maxq =
len;
1537 auto cnt = lst.size();
1538 for (
auto & entry : lst)
1540 fMaster->SubmitData(entry.connid, txt, std::string(
data), entry.channel);
1542 fMaster->SubmitData(entry.connid, txt, std::move(
data), entry.channel);
1547 auto cnt = arr.size();
1550 bool clear_queue =
false;
1559 for (
auto &conn : arr) {
1565 fname.append(
"msg");
1568 fname.append(
"_ch");
1569 fname.append(std::to_string(chid));
1571 fname.append(txt ?
".txt" :
".bin");
1573 std::ofstream ofs(fname);
1574 ofs.write(
data.c_str(),
data.length());
1586 conn->fSendStamp =
stamp;
1588 std::lock_guard<std::mutex> grd(conn->fMutex);
1591 while (!conn->fQueue.empty())
1595 if (conn->fQueue.size() < maxqlen) {
1597 conn->fQueue.emplace(chid, txt, std::string(
data));
1599 conn->fQueue.emplace(chid, txt, std::move(
data));
1638 std::copy((
const char *)
data, (
const char *)
data +
len, buf.begin());
1639 SubmitData(connid,
false, std::move(buf), 1);
1658 }
else if (
fMgr->IsUseHttpThread()) {
1660 R__LOG_ERROR(
WebGUILog()) <<
"create web window from main thread when THttpServer created with special thread - not supported";
1693 std::thread thrd([
this] {
1795 return fMgr->WaitFor(*
this, check);
1823 return fMgr->WaitFor(*
this, check,
true, duration);
1856 if (arr.size() == 0)
1860 if (arr[0]->fEmbed.find(channel) != arr[0]->fEmbed.end())
1863 arr[0]->fEmbed[channel] = window;
1865 return arr[0]->fConnId;
1875 for (
auto &conn : arr) {
1876 auto iter = conn->fEmbed.find(channel);
1877 if (iter != conn->fEmbed.end())
1878 conn->fEmbed.erase(iter);
1907 std::swap(arr1,
fConn);
1925 if (args.
fMaster && window->fMaster && window->fMaster != args.
fMaster) {
1934 window->RemoveMasterConnection(connid);
1948 return window->Show(args);
1969 return msg.compare(0, 11,
"FILEDIALOG:") == 0;
1996std::string
RWebWindow::HMAC(
const std::string &key,
const std::string &sessionKey,
const char *msg,
int msglen)
2000 auto get_digest = [](
sha256_t &hash,
bool as_hex =
false) -> std::string {
2004 sha256_final(&hash,
reinterpret_cast<unsigned char *
>(digest.data()));
2006 if (!as_hex)
return digest;
2008 static const char* digits =
"0123456789abcdef";
2010 for (
int n = 0;
n < 32;
n++) {
2011 unsigned char code = (
unsigned char) digest[
n];
2012 hex += digits[code / 16];
2013 hex += digits[code % 16];
2020 sha256_init(&hash1);
2021 sha256_update(&hash1, (
const unsigned char *) sessionKey.data(), sessionKey.length());
2022 sha256_update(&hash1, (
const unsigned char *) key.data(), key.length());
2023 std::string kbis = get_digest(hash1);
2027 std::string ki = kbis, ko = kbis;
2028 const int opad = 0x5c;
2029 const int ipad = 0x36;
2030 for (
size_t i = 0; i < kbis.length(); ++i) {
2031 ko[i] = kbis[i] ^ opad;
2032 ki[i] = kbis[i] ^ ipad;
2037 sha256_init(&hash2);
2038 sha256_update(&hash2, (
const unsigned char *) ki.data(), ki.length());
2039 sha256_update(&hash2, (
const unsigned char *) msg, msglen);
2040 std::string m2digest = get_digest(hash2);
2044 sha256_init(&hash3);
2045 sha256_update(&hash3, (
const unsigned char *) ko.data(), ko.length());
2046 sha256_update(&hash3, (
const unsigned char *) m2digest.data(), m2digest.length());
2048 return get_digest(hash3,
true);
#define R__LOG_WARNING(...)
#define R__LOG_ERROR(...)
#define R__LOG_DEBUG(DEBUGLEVEL,...)
winID h TVirtualViewer3D TVirtualGLPainter p
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 void data
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
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t height
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
R__EXTERN TSystem * gSystem
Holds different arguments for starting browser with RWebDisplayHandle::Display() method.
EBrowserKind GetBrowserKind() const
returns configured browser kind, see EBrowserKind for supported values
unsigned fMasterConnection
! used master connection
int fMasterChannel
! used master channel
std::shared_ptr< RWebWindow > fMaster
! master window
@ kEmbedded
window will be embedded into other, no extra browser need to be started
void SetHeadless(bool on=true)
set headless mode
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...
int WaitFor(WebWindowWaitFunc_t check)
Waits until provided check function or lambdas returns non-zero value Check function has following si...
unsigned GetId() const
Returns ID for the window - unique inside window manager.
std::vector< MasterConn > GetMasterConnections(unsigned connid=0) const
Get list of master connections.
void AddMasterConnection(std::shared_ptr< RWebWindow > window, unsigned connid, int channel)
Add new master connection If there are many connections - only same master is allowed.
std::mutex fConnMutex
! mutex used to protect connection list
WebWindowDataCallback_t fDataCallback
! main callback when data over channel 1 is arrived
void CheckInactiveConnections()
Check if there are connection which are inactive for longer time For instance, batch browser will be ...
unsigned fId
! unique identifier
bool fHasWindowThrd
! indicate if special window thread was started
std::vector< MasterConn > fMasterConns
! master 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...
void StartThread()
Start special thread which will be used by the window to handle all callbacks One has to be sure,...
unsigned fConnCnt
! counter of new connections to assign ids
unsigned fProtocolConnId
! connection id, which is used for writing protocol
ConnectionsList_t GetWindowConnections(unsigned connid=0, bool only_active=false) const
returns connection list (or all active connections)
bool fSendMT
! true is special threads should be used for sending data
std::thread::id fCallbacksThrdId
! thread id where callbacks should be invoked
void RemoveKey(const std::string &key)
Removes all connections with the key.
std::queue< QueueEntry > fInputQueue
! input queue for all callbacks
bool _CanTrustIn(std::shared_ptr< WebConn > &conn, const std::string &key, const std::string &ntry, bool remote, bool test_first_time)
Check if provided hash, ntry parameters from the connection request could be accepted.
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 connect web window URL typically includes extra parameters required for connecti...
void CloseConnections()
Closes all connection to clients Normally leads to closing of all correspondent browser windows Some ...
std::shared_ptr< RWebWindow > fMaster
! master window where this window is embedded
int NumConnections(bool with_pending=false) const
Returns current number of active clients connections.
bool fCallbacksThrdIdSet
! flag indicating that thread id is assigned
std::string fUserArgs
! arbitrary JSON code, which is accessible via conn.getUserArgs() method
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...
unsigned fConnLimit
! number of allowed active connections
void InvokeCallbacks(bool force=false)
Invoke callbacks with existing data Must be called from appropriate thread.
std::shared_ptr< WebConn > FindConnection(unsigned wsid)
Find connection with specified websocket id.
std::string GetClientVersion() const
Returns current client version.
void SetConnectCallBack(WebWindowConnectCallback_t func)
Set call-back function for new connection.
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...
void Send(unsigned connid, const std::string &data)
Sends data to specified connection.
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 large random string generated when starting new window W...
std::vector< std::shared_ptr< WebConn > > ConnectionsList_t
void AssignThreadId()
Assign thread id which has to be used for callbacks WARNING!!! only for expert use Automatically done...
bool IsNativeOnlyConn() const
returns true if only native (own-created) connections are allowed
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::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 AddEmbedWindow(std::shared_ptr< RWebWindow > window, unsigned connid, int channel)
Add embed window.
void SetDisconnectCallBack(WebWindowConnectCallback_t func)
Set call-back function for disconnecting.
std::vector< unsigned > GetConnections(unsigned excludeid=0) const
returns vector with all existing connections ids One also can exclude specified connection from retur...
void SetDataCallBack(WebWindowDataCallback_t func)
Set call-back function for data, received from the clients via websocket.
float fOperationTmout
! timeout in seconds to perform synchronous operation, default 50s
bool fRequireAuthKey
! defines if authentication key always required when connect to the widget
static std::function< bool(const std::shared_ptr< RWebWindow > &, unsigned, const std::string &)> gStartDialogFunc
void SetUserArgs(const std::string &args)
Set arbitrary JSON data, which is accessible via conn.getUserArgs() method in JavaScript This JSON co...
std::string fConnToken
! value of "token" URL parameter which should be provided for connecting window
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...
std::shared_ptr< RWebWindowWSHandler > fWSHandler
! specialize websocket handler for all incoming connections
void StopThread()
Stop special thread.
void SubmitData(unsigned connid, bool txt, std::string &&data, int chid=1)
Internal method to send data.
static std::string HMAC(const std::string &key, const std::string &sessionKey, const char *msg, int msglen)
Calculate HMAC checksum for provided key and message Key combained from connection key and session ke...
~RWebWindow()
RWebWindow destructor Closes all connections and remove window from manager.
static bool EmbedFileDialog(const std::shared_ptr< RWebWindow > &window, unsigned connid, const std::string &args)
Create dialog instance to use as embedded dialog inside provided widget Loads libROOTBrowserv7 and tr...
void CloseConnection(unsigned connid)
Close specified connection.
ConnectionsList_t fPendingConn
! list of pending connection with pre-assigned keys
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.
float GetOperationTmout() const
Returns timeout for synchronous WebWindow operations.
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....
bool IsRequireAuthKey() const
returns true if authentication string is required
RWebWindow()
RWebWindow constructor Should be defined here because of std::unique_ptr<RWebWindowWSHandler>
std::string fProtocolPrefix
! prefix for created files names
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::string fProtocol
! protocol
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...
bool fUseProcessEvents
! all window functionality will run through process events
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 ...
static void SetStartDialogFunc(std::function< bool(const std::shared_ptr< RWebWindow > &, unsigned, const std::string &)>)
Configure func which has to be used for starting dialog.
std::string fPanelName
! panel name which should be shown in the window
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< RWebWindowsManager > fMgr
! display manager
std::string fProtocolFileName
! local file where communication protocol will be written
ConnectionsList_t fConn
! list of all accepted connections
WebWindowConnectCallback_t fConnCallback
! callback for connect event
void CheckPendingConnections()
Check if started process(es) establish connection.
std::shared_ptr< void > fClearOnClose
! entry which is cleared when last connection is closed
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.
std::chrono::time_point< std::chrono::system_clock > timestamp_t
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
std::thread fWindowThrd
! special thread for that window
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...
bool fUseServerThreads
! indicates that server thread is using, no special window thread
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...
bool fProcessMT
! if window event processing performed in dedicated thread
int fProtocolCnt
! counter for protocol recording
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 RemoveMasterConnection(unsigned connid=0)
Remove master connection - if any.
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.
WebWindowConnectCallback_t fDisconnCallback
! callback for disconnect event
unsigned GetMaxQueueLength() const
Return maximal queue length of data which can be held by window.
static bool IsFileDialogMessage(const std::string &msg)
Check if this could be the message send by client to start new file dialog If returns true,...
static std::string GenerateKey(int keylen=32)
Static method to generate cryptographic key Parameter keylen defines length of cryptographic key in b...
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.
static bool IsLoopbackMode()
Returns true if loopback mode used by THttpServer for web widgets.
Contains arguments for single HTTP call.
UInt_t GetWSId() const
get web-socket id
const char * GetTopName() const
returns engine-specific top-name
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
const char * GetFileName() const
returns file name from request URL
Online http server for arbitrary ROOT application.
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
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.
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
std::function< void(unsigned, const std::string &)> WebWindowDataCallback_t
function signature for call-backs from the window clients first argument is connection id,...
ROOT::Experimental::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< int(double)> WebWindowWaitFunc_t
function signature for waiting call-backs Such callback used when calling thread need to waits for so...
std::string fData
! text or binary data
std::shared_ptr< THttpCallArg > fHold
! request used to hold headless browser
~WebConn()
Destructor for WebConn Notify special HTTP request which blocks headless browser from exit.