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()) {
151std::shared_ptr<RWebWindowWSHandler>
175 return fMgr->GetUrl(*
this, remote);
183 return fMgr->GetServer();
193 return fMgr->ShowWindow(*
this, args);
210 connid =
fMgr->ShowWindow(*
this, args);
226 if (entry->fHeadlessMode)
227 return entry->fConnId;
230 for (
auto &conn :
fConn) {
231 if (conn->fHeadlessMode)
232 return conn->fConnId;
249 if (!entry->fHeadlessMode)
250 return entry->fConnId;
253 for (
auto &conn :
fConn) {
254 if (!conn->fHeadlessMode)
255 return conn->fConnId;
268 for (
auto &conn :
fConn) {
269 if (conn->fWSId == wsid)
282 std::shared_ptr<WebConn> res;
287 for (
size_t n = 0;
n <
fConn.size(); ++
n)
288 if (
fConn[
n]->fWSId == wsid) {
289 res = std::move(
fConn[
n]);
291 res->fActive =
false;
297 for (
auto &elem: res->fEmbed)
298 elem.second->RemoveMasterConnection(res->fConnId);
327 std::vector<MasterConn> lst;
334 if (!connid || entry.connid == connid)
335 lst.emplace_back(entry);
356 if (iter->connid == connid) {
376 std::string query = arg->GetQuery();
378 if (query.compare(0, 4,
"key=") != 0)
381 std::string key = query.substr(4);
383 std::shared_ptr<THttpCallArg> prev;
385 bool found_key =
false;
391 if (entry->fKey == key) {
394 prev = std::move(entry->fHold);
399 for (
auto &conn :
fConn) {
400 if (conn->fKey == key) {
402 prev = std::move(conn->fHold);
410 prev->SetTextContent(
"console.log('execute holder script'); if (window) window.close();");
411 prev->NotifyCondition();
453 connid = entry.fConnId;
455 arg = std::move(entry.fData);
487 if (entry->fKey == key) {
488 entry->fHeadlessMode = headless_mode;
489 std::swap(entry->fDisplayHandle, handle);
490 return entry->fConnId;
494 auto conn = std::make_shared<WebConn>(++
fConnCnt, headless_mode, key);
496 std::swap(conn->fDisplayHandle, handle);
513bool RWebWindow::_CanTrustIn(std::shared_ptr<WebConn> &conn,
const std::string &hash,
const std::string &ntry,
bool remote,
bool test_first_time)
518 int intry = ntry.empty() ? -1 : std::stoi(ntry);
521 auto expected =
HMAC(conn->fKey,
fMgr->fUseSessionKey && remote ?
fMgr->fSessionKey :
""s, msg.Data(), msg.Length());
524 return (conn->fKey.empty() && hash.empty()) || (hash == conn->fKey) || (hash == expected);
527 if (!remote && ((hash == conn->fKey) || (hash == expected)))
530 if (hash == expected) {
531 if (test_first_time) {
532 if (conn->fKeyUsed >= intry) {
539 conn->fKeyUsed = intry;
541 if (conn->fKeyUsed != intry) {
566 if (entry->fKey == key)
570 for (
auto &conn :
fConn) {
571 if (conn->fKey == key)
573 if (also_newkey && (conn->fNewKey == key))
590 auto pred = [&](std::shared_ptr<WebConn> &
e) {
591 if (
e->fKey == key) {
602 for (
auto &conn : lst)
615 R__ASSERT((!
HasKey(key) && (key !=
fMgr->fSessionKey)) &&
"Fail to generate window connection key");
630 float tmout =
fMgr->GetLaunchTmout();
637 auto pred = [&](std::shared_ptr<WebConn> &
e) {
638 std::chrono::duration<double> diff =
stamp -
e->fSendStamp;
640 if (diff.count() > tmout) {
641 R__LOG_DEBUG(0,
WebGUILog()) <<
"Remove pending connection " <<
e->fKey <<
" after " << diff.count() <<
" sec";
642 selected.emplace_back(
e);
662 double batch_tmout = 20.;
664 std::vector<std::shared_ptr<WebConn>> clr;
669 auto pred = [&](std::shared_ptr<WebConn> &conn) {
670 std::chrono::duration<double> diff =
stamp - conn->fSendStamp;
672 if ((diff.count() > batch_tmout) && conn->fHeadlessMode) {
673 conn->fActive =
false;
674 clr.emplace_back(conn);
683 for (
auto &entry : clr)
775 std::string key, ntry;
781 if (
_CanTrustIn(conn, key, ntry, is_remote,
true ))
794 std::shared_ptr<WebConn> conn;
795 std::string key, ntry;
816 conn->fActive =
true;
822 fConn.emplace_back(conn);
842 std::string key, ntry;
848 if (!
_CanTrustIn(conn, key, ntry, is_remote,
true ))
859 bool do_clear_on_close =
false;
860 if (!conn->fNewKey.empty()) {
864 conn->fKey = conn->fNewKey;
865 conn->fNewKey.clear();
875 if (do_clear_on_close)
899 const char *buf0 = (
const char *) arg.
GetPostData();
902 const char *buf = strchr(buf0,
':');
908 Int_t code_len = buf - buf0;
909 data_len -= code_len + 1;
917 bool is_none = strncmp(buf0,
"none:", 5) == 0, is_match =
false;
920 std::string hmac =
HMAC(conn->fKey,
fMgr->fSessionKey, buf, data_len);
922 is_match = (code_len == (
Int_t) hmac.length()) && (strncmp(buf0, hmac.c_str(), code_len) == 0);
923 }
else if (!
fMgr->fUseSessionKey) {
942 char *str_end =
nullptr;
944 unsigned long oper_seq = std::strtoul(buf, &str_end, 10);
945 if (!str_end || *str_end !=
':') {
950 if (is_remote && (oper_seq <= conn->fRecvSeq)) {
955 conn->fRecvSeq = oper_seq;
957 unsigned long ackn_oper = std::strtoul(str_end + 1, &str_end, 10);
958 if (!str_end || *str_end !=
':') {
963 unsigned long can_send = std::strtoul(str_end + 1, &str_end, 10);
964 if (!str_end || *str_end !=
':') {
969 unsigned long nchannel = std::strtoul(str_end + 1, &str_end, 10);
970 if (!str_end || *str_end !=
':') {
975 Long_t processed_len = (str_end + 1 - buf);
977 if (processed_len > data_len) {
982 std::string cdata(str_end + 1, data_len - processed_len);
987 std::lock_guard<std::mutex> grd(conn->fMutex);
989 conn->fSendCredits += ackn_oper;
991 conn->fClientCredits = (
int)can_send;
992 conn->fRecvStamp =
stamp;
1000 if ((nchannel != 0) || (cdata.find(
"READY=") == 0)) {
1011 if (nchannel == 0) {
1013 if ((cdata.compare(0, 6,
"READY=") == 0) && !conn->fReady) {
1015 std::string key = cdata.substr(6);
1022 if (!key.empty() && !conn->fKey.empty() && (conn->fKey != key)) {
1023 R__LOG_ERROR(
WebGUILog()) <<
"Key mismatch after established connection " << key <<
" != " << conn->fKey;
1036 }
else if (cdata.compare(0, 8,
"CLOSECH=") == 0) {
1037 int channel = std::stoi(cdata.substr(8));
1038 auto iter = conn->fEmbed.find(channel);
1039 if (iter != conn->fEmbed.end()) {
1041 conn->fEmbed.erase(iter);
1043 }
else if (cdata.compare(0, 7,
"RESIZE=") == 0) {
1044 auto p = cdata.find(
",");
1045 if (
p != std::string::npos) {
1046 auto width = std::stoi(cdata.substr(7,
p - 7));
1047 auto height = std::stoi(cdata.substr(
p + 1));
1048 if ((
width > 0) && (
height > 0) && conn->fDisplayHandle)
1051 }
else if (cdata ==
"GENERATE_KEY") {
1056 if(!conn->fNewKey.empty())
1057 SubmitData(conn->fConnId,
true,
"NEW_KEY="s + conn->fNewKey, -1);
1060 }
else if (
fPanelName.length() && (conn->fReady < 10)) {
1061 if (cdata ==
"PANEL_READY") {
1069 }
else if (nchannel == 1) {
1071 }
else if (nchannel > 1) {
1073 auto embed_window = conn->fEmbed[nchannel];
1075 embed_window->ProvideQueueEntry(conn->fConnId,
kind_Data, std::move(cdata));
1095 std::lock_guard<std::mutex> grd(conn->fMutex);
1096 conn->fDoingSend =
false;
1115 if (conn->fSendCredits <= 0) {
1120 if (conn->fDoingSend) {
1126 buf.reserve(
data.length() + 100);
1128 buf.append(std::to_string(conn->fSendSeq++));
1130 buf.append(std::to_string(conn->fRecvCount));
1132 buf.append(std::to_string(conn->fSendCredits));
1134 conn->fRecvCount = 0;
1135 conn->fSendCredits--;
1137 buf.append(std::to_string(chid));
1142 }
else if (
data.length()==0) {
1143 buf.append(
"$$nullbinary$$");
1145 buf.append(
"$$binary$$");
1146 if (!conn->fKey.empty() && !
fMgr->fSessionKey.empty() &&
fMgr->fUseSessionKey)
1147 buf.append(
HMAC(conn->fKey,
fMgr->fSessionKey,
data.data(),
data.length()));
1159 std::string hdr,
data, prefix;
1162 std::lock_guard<std::mutex> grd(conn->fMutex);
1164 if (!conn->fActive || (conn->fSendCredits <= 0) || conn->fDoingSend)
return false;
1166 if (!conn->fQueue.empty()) {
1169 if (!hdr.empty() && !item.
fText)
1172 }
else if ((conn->fClientCredits < 3) && (conn->fRecvCount > 1)) {
1177 if (hdr.empty())
return false;
1179 conn->fDoingSend =
true;
1183 if (!conn->fKey.empty() && !
fMgr->fSessionKey.empty() &&
fMgr->fUseSessionKey) {
1184 prefix =
HMAC(conn->fKey,
fMgr->fSessionKey, hdr.c_str(), hdr.length());
1190 hdr.insert(0, prefix);
1195 res =
fWSHandler->SendCharStarWS(conn->fWSId, hdr.c_str());
1197 res =
fWSHandler->SendHeaderWS(conn->fWSId, hdr.c_str(),
data.data(),
data.length());
1201 if (res >=0)
return true;
1204 std::lock_guard<std::mutex> grd(conn->fMutex);
1205 conn->fDoingSend =
false;
1223 for (
auto &conn : arr)
1229 }
while (!only_once);
1276 std::string res(
"../");
1277 res.append(
win.GetAddr());
1338 auto sz =
fConn.size();
1378 return ((num >= 0) && (num < (
int)
fConn.size()) &&
fConn[num]->fActive) ?
fConn[num]->fConnId : 0;
1388 std::vector<unsigned> res;
1396 if (entry.connid != excludeid)
1397 res.emplace_back(entry.connid);
1399 for (
auto & entry :
fConn)
1400 if (entry->fActive && (entry->fConnId != excludeid))
1401 res.emplace_back(entry->fConnId);
1416 for (
auto &conn :
fConn) {
1417 if (connid && (conn->fConnId != connid))
1419 if (conn->fActive || !only_active)
1425 if (!connid || (conn->fConnId == connid))
1464 for (
auto &conn :
fConn) {
1465 if ((conn->fActive || !only_active) && (!connid || (conn->fConnId == connid)))
1466 arr.push_back(conn);
1471 if (!connid || (conn->fConnId == connid))
1472 arr.push_back(conn);
1489 for (
auto &conn : arr) {
1491 std::lock_guard<std::mutex> grd(conn->fMutex);
1493 if (
direct && (!conn->fQueue.empty() || (conn->fSendCredits == 0) || conn->fDoingSend))
1496 if (conn->fQueue.size() >= maxqlen)
1513 std::lock_guard<std::mutex> grd(conn->fMutex);
1514 int len = conn->fQueue.size();
1515 if (
len > maxq) maxq =
len;
1532 auto cnt = lst.size();
1533 for (
auto & entry : lst)
1535 fMaster->SubmitData(entry.connid, txt, std::string(
data), entry.channel);
1537 fMaster->SubmitData(entry.connid, txt, std::move(
data), entry.channel);
1542 auto cnt = arr.size();
1545 bool clear_queue =
false;
1554 for (
auto &conn : arr) {
1560 fname.append(
"msg");
1563 fname.append(
"_ch");
1564 fname.append(std::to_string(chid));
1566 fname.append(txt ?
".txt" :
".bin");
1568 std::ofstream ofs(fname);
1569 ofs.write(
data.c_str(),
data.length());
1581 conn->fSendStamp =
stamp;
1583 std::lock_guard<std::mutex> grd(conn->fMutex);
1586 while (!conn->fQueue.empty())
1590 if (conn->fQueue.size() < maxqlen) {
1592 conn->fQueue.emplace(chid, txt, std::string(
data));
1594 conn->fQueue.emplace(chid, txt, std::move(
data));
1633 std::copy((
const char *)
data, (
const char *)
data +
len, buf.begin());
1634 SubmitData(connid,
false, std::move(buf), 1);
1653 }
else if (
fMgr->IsUseHttpThread()) {
1655 R__LOG_ERROR(
WebGUILog()) <<
"create web window from main thread when THttpServer created with special thread - not supported";
1688 std::thread thrd([
this] {
1790 return fMgr->WaitFor(*
this, check);
1818 return fMgr->WaitFor(*
this, check,
true, duration);
1851 if (arr.size() == 0)
1855 if (arr[0]->fEmbed.find(channel) != arr[0]->fEmbed.end())
1858 arr[0]->fEmbed[channel] = window;
1860 return arr[0]->fConnId;
1870 for (
auto &conn : arr) {
1871 auto iter = conn->fEmbed.find(channel);
1872 if (iter != conn->fEmbed.end())
1873 conn->fEmbed.erase(iter);
1902 std::swap(arr1,
fConn);
1920 if (args.
fMaster && window->fMaster && window->fMaster != args.
fMaster) {
1929 window->RemoveMasterConnection(connid);
1943 return window->Show(args);
1964 return msg.compare(0, 11,
"FILEDIALOG:") == 0;
1991std::string
RWebWindow::HMAC(
const std::string &key,
const std::string &sessionKey,
const char *msg,
int msglen)
1995 auto get_digest = [](
sha256_t &hash,
bool as_hex =
false) -> std::string {
1999 sha256_final(&hash,
reinterpret_cast<unsigned char *
>(digest.data()));
2001 if (!as_hex)
return digest;
2003 static const char* digits =
"0123456789abcdef";
2005 for (
int n = 0;
n < 32;
n++) {
2006 unsigned char code = (
unsigned char) digest[
n];
2007 hex += digits[code / 16];
2008 hex += digits[code % 16];
2015 sha256_init(&hash1);
2016 sha256_update(&hash1, (
const unsigned char *) sessionKey.data(), sessionKey.length());
2017 sha256_update(&hash1, (
const unsigned char *) key.data(), key.length());
2018 std::string kbis = get_digest(hash1);
2022 std::string ki = kbis, ko = kbis;
2023 const int opad = 0x5c;
2024 const int ipad = 0x36;
2025 for (
size_t i = 0; i < kbis.length(); ++i) {
2026 ko[i] = kbis[i] ^ opad;
2027 ki[i] = kbis[i] ^ ipad;
2032 sha256_init(&hash2);
2033 sha256_update(&hash2, (
const unsigned char *) ki.data(), ki.length());
2034 sha256_update(&hash2, (
const unsigned char *) msg, msglen);
2035 std::string m2digest = get_digest(hash2);
2039 sha256_init(&hash3);
2040 sha256_update(&hash3, (
const unsigned char *) ko.data(), ko.length());
2041 sha256_update(&hash3, (
const unsigned char *) m2digest.data(), m2digest.length());
2043 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
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
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.
bool HasKey(const std::string &key, bool also_newkey=false) const
Returns true if provided key value already exists (in processes map or in existing connections) In sp...
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.
void SetUseCurrentDir(bool on=true)
Configure if window can access local files via currentdir/ path of http server.
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.