Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RWebWindow.hxx
Go to the documentation of this file.
1// Author: Sergey Linev <s.linev@gsi.de>
2// Date: 2017-10-16
3// Warning: This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback is welcome!
4
5/*************************************************************************
6 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers. *
7 * All rights reserved. *
8 * *
9 * For the licensing terms see $ROOTSYS/LICENSE. *
10 * For the list of contributors see $ROOTSYS/README/CREDITS. *
11 *************************************************************************/
12
13#ifndef ROOT7_RWebWindow
14#define ROOT7_RWebWindow
15
17
18#include <memory>
19#include <vector>
20#include <string>
21#include <queue>
22#include <map>
23#include <functional>
24#include <mutex>
25#include <thread>
26#include <chrono>
27
28class THttpCallArg;
29class THttpServer;
30
31namespace ROOT {
32
33/// function signature for connect/disconnect call-backs
34/// argument is connection id
35using WebWindowConnectCallback_t = std::function<void(unsigned)>;
36
37/// function signature for call-backs from the window clients
38/// first argument is connection id, second is received data
39using WebWindowDataCallback_t = std::function<void(unsigned, const std::string &)>;
40
41/// function signature for waiting call-backs
42/// Such callback used when calling thread need to waits for some special data,
43/// but wants to run application event loop
44/// As argument, spent time in second will be provided
45/// Waiting will be performed until function returns non-zero value
46using WebWindowWaitFunc_t = std::function<int(double)>;
47
48class RFileDialog;
51
53
54 friend class RWebWindowsManager;
55 friend class RWebWindowWSHandler;
56 friend class RWebDisplayHandle;
57 friend class RFileDialog;
58
59private:
60 using timestamp_t = std::chrono::time_point<std::chrono::system_clock>;
61
62 struct QueueItem {
63 int fChID{1}; ///<! channel
64 bool fText{true}; ///<! is text data
65 std::string fData; ///<! text or binary data
66 QueueItem(int chid, bool txt, std::string &&data) : fChID(chid), fText(txt), fData(data) {}
67 };
68
69 struct WebConn {
70 unsigned fConnId{0}; ///<! connection id (unique inside the window)
71 bool fHeadlessMode{false}; ///<! indicate if connection represent batch job
72 std::string fKey; ///<! key value supplied to the window (when exists)
73 int fKeyUsed{0}; ///<! key value used to verify connection
74 std::string fNewKey; ///<! new key if connection request reload
75 std::unique_ptr<RWebDisplayHandle> fDisplayHandle; ///<! handle assigned with started web display (when exists)
76 std::shared_ptr<THttpCallArg> fHold; ///<! request used to hold headless browser
77 timestamp_t fSendStamp; ///<! last server operation, always used from window thread
78 bool fActive{false}; ///<! flag indicates if connection is active
79 unsigned fWSId{0}; ///<! websocket id
80 int fReady{0}; ///<! 0 - not ready, 1..9 - interim, 10 - done
81 mutable std::mutex fMutex; ///<! mutex must be used to protect all following data
82 timestamp_t fRecvStamp; ///<! last receive operation, protected with connection mutex
83 int fRecvCount{0}; ///<! number of received packets, should return back with next sending
84 int fSendCredits{0}; ///<! how many send operation can be performed without confirmation from other side
85 int fClientCredits{0}; ///<! number of credits received from client
86 bool fDoingSend{false}; ///<! true when performing send operation
87 unsigned long fRecvSeq{0}; ///<! sequence id of last received packet
88 unsigned long fSendSeq{1}; ///<! sequence id of last send packet
89 std::queue<QueueItem> fQueue; ///<! output queue
90 std::map<int,std::shared_ptr<RWebWindow>> fEmbed; ///<! map of embed window for that connection, key value is channel id
91 WebConn() = default;
92 WebConn(unsigned connid) : fConnId(connid) {}
93 WebConn(unsigned connid, unsigned wsid) : fConnId(connid), fActive(true), fWSId(wsid) {}
94 WebConn(unsigned connid, bool headless_mode, const std::string &key)
95 : fConnId(connid), fHeadlessMode(headless_mode), fKey(key)
96 {
98 }
99 ~WebConn();
100
101 void ResetStamps() { fSendStamp = fRecvStamp = std::chrono::system_clock::now(); }
102
104 {
105 fActive = false;
106 fWSId = 0;
107 fReady = 0;
108 fDoingSend = false;
109 fSendCredits = 0;
110 fClientCredits = 0;
111 fRecvSeq = 0;
112 fSendSeq = 1;
113 while (!fQueue.empty())
114 fQueue.pop();
115 }
116 };
117
118 struct MasterConn {
119 unsigned connid{0};
120 int channel{-1};
121 MasterConn(unsigned _connid, int _channel) : connid(_connid), channel(_channel) {}
122 };
123
125
126 struct QueueEntry {
127 unsigned fConnId{0}; ///<! connection id
128 EQueueEntryKind fKind{kind_None}; ///<! kind of data
129 std::string fData; ///<! data for given connection
130 QueueEntry() = default;
131 QueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&data) : fConnId(connid), fKind(kind), fData(data) {}
132 };
133
134 using ConnectionsList_t = std::vector<std::shared_ptr<WebConn>>;
135
136 std::shared_ptr<RWebWindowsManager> fMgr; ///<! display manager
137 std::shared_ptr<RWebWindow> fMaster; ///<! master window where this window is embedded
138 std::vector<MasterConn> fMasterConns; ///<! master connections
139 std::string fDefaultPage; ///<! HTML page (or file name) returned when window URL is opened
140 std::string fPanelName; ///<! panel name which should be shown in the window
141 unsigned fId{0}; ///<! unique identifier
142 bool fUseServerThreads{false}; ///<! indicates that server thread is using, no special window thread
143 bool fUseProcessEvents{false}; ///<! all window functionality will run through process events
144 bool fProcessMT{false}; ///<! if window event processing performed in dedicated thread
145 bool fSendMT{false}; ///<! true is special threads should be used for sending data
146 bool fRequireAuthKey{true}; ///<! defines if authentication key always required when connect to the widget
147 std::shared_ptr<RWebWindowWSHandler> fWSHandler; ///<! specialize websocket handler for all incoming connections
148 unsigned fConnCnt{0}; ///<! counter of new connections to assign ids
149 ConnectionsList_t fPendingConn; ///<! list of pending connection with pre-assigned keys
150 ConnectionsList_t fConn; ///<! list of all accepted connections
151 mutable std::mutex fConnMutex; ///<! mutex used to protect connection list
152 unsigned fConnLimit{1}; ///<! number of allowed active connections
153 std::string fConnToken; ///<! value of "token" URL parameter which should be provided for connecting window
154 bool fNativeOnlyConn{false}; ///<! only native connection are allowed, created by Show() method
155 unsigned fMaxQueueLength{10}; ///<! maximal number of queue entries
156 WebWindowConnectCallback_t fConnCallback; ///<! callback for connect event
157 WebWindowDataCallback_t fDataCallback; ///<! main callback when data over channel 1 is arrived
158 WebWindowConnectCallback_t fDisconnCallback; ///<! callback for disconnect event
159 std::thread::id fCallbacksThrdId; ///<! thread id where callbacks should be invoked
160 bool fCallbacksThrdIdSet{false}; ///<! flag indicating that thread id is assigned
161 bool fHasWindowThrd{false}; ///<! indicate if special window thread was started
162 std::thread fWindowThrd; ///<! special thread for that window
163 std::queue<QueueEntry> fInputQueue; ///<! input queue for all callbacks
164 std::mutex fInputQueueMutex; ///<! mutex to protect input queue
165 unsigned fWidth{0}, fHeight{0}; ///<! initial window width and height when displayed, zeros are ignored
166 int fX{-1}, fY{-1}; ///<! initial window position, -1 ignored
167 float fOperationTmout{50.}; ///<! timeout in seconds to perform synchronous operation, default 50s
168 std::string fClientVersion; ///<! configured client version, used as prefix in scripts URL
169 std::string fProtocolFileName; ///<! local file where communication protocol will be written
170 int fProtocolCnt{-1}; ///<! counter for protocol recording
171 unsigned fProtocolConnId{0}; ///<! connection id, which is used for writing protocol
172 std::string fProtocolPrefix; ///<! prefix for created files names
173 std::string fProtocol; ///<! protocol
174 std::string fUserArgs; ///<! arbitrary JSON code, which is accessible via conn.getUserArgs() method
175 std::shared_ptr<void> fClearOnClose; ///<! entry which is cleared when last connection is closed
176
177 std::shared_ptr<RWebWindowWSHandler> CreateWSHandler(std::shared_ptr<RWebWindowsManager> mgr, unsigned id, double tmout);
178
179 bool ProcessWS(THttpCallArg &arg);
180
181 void CompleteWSSend(unsigned wsid);
182
183 ConnectionsList_t GetWindowConnections(unsigned connid = 0, bool only_active = false) const;
184
185 /// Find connection with specified websocket id
186 std::shared_ptr<WebConn> FindConnection(unsigned wsid);
187
188 std::shared_ptr<WebConn> RemoveConnection(unsigned wsid);
189
190 std::shared_ptr<WebConn> _FindConnWithKey(const std::string &key) const;
191
192 bool _CanTrustIn(std::shared_ptr<WebConn> &conn, const std::string &key, const std::string &ntry, bool remote, bool test_first_time);
193
194 std::string _MakeSendHeader(std::shared_ptr<WebConn> &conn, bool txt, const std::string &data, int chid);
195
196 void ProvideQueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&arg);
197
198 void InvokeCallbacks(bool force = false);
199
200 void SubmitData(unsigned connid, bool txt, std::string &&data, int chid = 1);
201
202 bool CheckDataToSend(std::shared_ptr<WebConn> &conn);
203
204 void CheckDataToSend(bool only_once = false);
205
206 bool HasKey(const std::string &key) const;
207
208 void RemoveKey(const std::string &key);
209
210 std::string GenerateKey() const;
211
213
215
216 unsigned AddDisplayHandle(bool headless_mode, const std::string &key, std::unique_ptr<RWebDisplayHandle> &handle);
217
218 unsigned AddEmbedWindow(std::shared_ptr<RWebWindow> window, unsigned connid, int channel);
219
220 void RemoveEmbedWindow(unsigned connid, int channel);
221
222 void AddMasterConnection(std::shared_ptr<RWebWindow> window, unsigned connid, int channel);
223
224 std::vector<MasterConn> GetMasterConnections(unsigned connid = 0) const;
225
226 void RemoveMasterConnection(unsigned connid = 0);
227
228 bool ProcessBatchHolder(std::shared_ptr<THttpCallArg> &arg);
229
230 std::string GetConnToken() const;
231
232 unsigned MakeHeadless(bool create_new = false);
233
234 unsigned FindHeadlessConnection();
235
236 static std::function<bool(const std::shared_ptr<RWebWindow> &, unsigned, const std::string &)> gStartDialogFunc;
237
238 static void SetStartDialogFunc(std::function<bool(const std::shared_ptr<RWebWindow> &, unsigned, const std::string &)>);
239
240 static std::string HMAC(const std::string &key, const std::string &sessionKey, const char *msg, int msglen);
241
242public:
243
244 RWebWindow();
245
246 ~RWebWindow();
247
248 /// Returns ID for the window - unique inside window manager
249 unsigned GetId() const { return fId; }
250
251 /// Returns window manager
252 std::shared_ptr<RWebWindowsManager> GetManager() const { return fMgr; }
253
254 /// Set content of default window HTML page
255 /// This page returns when URL address of the window will be requested
256 /// Either HTML code or file name in the form "file:/home/user/data/file.htm"
257 /// One also can using default locations like "file:rootui5sys/canv/canvas.html"
258 void SetDefaultPage(const std::string &page) { fDefaultPage = page; }
259
260 void SetPanelName(const std::string &name);
261
262 /// Set window geometry. Will be applied if supported by used web display (like CEF or Chromium)
263 void SetGeometry(unsigned width, unsigned height)
264 {
265 fWidth = width;
266 fHeight = height;
267 }
268
269 /// Set window position. Will be applied if supported by used web display (like CEF or Chromium)
270 void SetPosition(unsigned x, unsigned y)
271 {
272 fX = x;
273 fY = y;
274 }
275
276 /////////////////////////////////////////////////////////////////////////
277 /// returns configured window width (0 - default)
278 /// actual window width can be different
279 unsigned GetWidth() const { return fWidth; }
280
281 /////////////////////////////////////////////////////////////////////////
282 /// returns configured window height (0 - default)
283 unsigned GetHeight() const { return fHeight; }
284
285 /////////////////////////////////////////////////////////////////////////
286 /// returns configured window X position (-1 - default)
287 int GetX() const { return fX; }
288
289 /////////////////////////////////////////////////////////////////////////
290 /// returns configured window Y position (-1 - default)
291 int GetY() const { return fY; }
292
293 void SetConnLimit(unsigned lmt = 0);
294
295 unsigned GetConnLimit() const;
296
297 void SetConnToken(const std::string &token = "");
298
299 /////////////////////////////////////////////////////////////////////////
300 /// configures maximal queue length of data which can be held by window
301 void SetMaxQueueLength(unsigned len = 10) { fMaxQueueLength = len; }
302
303 /////////////////////////////////////////////////////////////////////////
304 /// Return maximal queue length of data which can be held by window
305 unsigned GetMaxQueueLength() const { return fMaxQueueLength; }
306
307 /////////////////////////////////////////////////////////////////////////
308 /// configures that only native (own-created) connections are allowed
309 void SetNativeOnlyConn(bool on = true) { fNativeOnlyConn = on; }
310
311 /////////////////////////////////////////////////////////////////////////
312 /// returns true if only native (own-created) connections are allowed
313 bool IsNativeOnlyConn() const { return fNativeOnlyConn; }
314
315 /////////////////////////////////////////////////////////////////////////
316 /// Configure if authentication key in connection string is required
318
319 /////////////////////////////////////////////////////////////////////////
320 /// returns true if authentication string is required
321 bool IsRequireAuthKey() const { return fRequireAuthKey; }
322
323 void SetClientVersion(const std::string &vers);
324
325 std::string GetClientVersion() const;
326
327 void SetUserArgs(const std::string &args);
328
329 std::string GetUserArgs() const;
330
331 int NumConnections(bool with_pending = false) const;
332
333 unsigned GetConnectionId(int num = 0) const;
334
335 std::vector<unsigned> GetConnections(unsigned excludeid = 0) const;
336
337 bool HasConnection(unsigned connid = 0, bool only_active = true) const;
338
339 void CloseConnections();
340
341 void CloseConnection(unsigned connid);
342
343 /// Returns timeout for synchronous WebWindow operations
344 float GetOperationTmout() const { return fOperationTmout; }
345
346 /// Set timeout for synchronous WebWindow operations
347 void SetOperationTmout(float tm = 50.) { fOperationTmout = tm; }
348
349 std::string GetUrl(bool remote = true);
350
352
353 void Sync();
354
355 void Run(double tm = 0.);
356
357 unsigned Show(const RWebDisplayArgs &args = "");
358
359 unsigned GetDisplayConnection() const;
360
361 /// Returns true when window was shown at least once
362 bool IsShown() const { return GetDisplayConnection() != 0; }
363
364 bool CanSend(unsigned connid, bool direct = true) const;
365
366 int GetSendQueueLength(unsigned connid) const;
367
368 void Send(unsigned connid, const std::string &data);
369
370 void SendBinary(unsigned connid, const void *data, std::size_t len);
371
372 void SendBinary(unsigned connid, std::string &&data);
373
374 void RecordData(const std::string &fname = "protocol.json", const std::string &fprefix = "");
375
376 std::string GetAddr() const;
377
378 std::string GetRelativeAddr(const std::shared_ptr<RWebWindow> &win) const;
379
380 std::string GetRelativeAddr(const RWebWindow &win) const;
381
383
385
387
389
390 void SetClearOnClose(const std::shared_ptr<void> &handle = nullptr);
391
392 void AssignThreadId();
393
394 void UseServerThreads();
395
396 int WaitFor(WebWindowWaitFunc_t check);
397
399
400 int WaitForTimed(WebWindowWaitFunc_t check, double duration);
401
402 void StartThread();
403
404 void StopThread();
405
406 void TerminateROOT();
407
408 static std::shared_ptr<RWebWindow> Create();
409
410 static unsigned ShowWindow(std::shared_ptr<RWebWindow> window, const RWebDisplayArgs &args = "");
411
412 static bool IsFileDialogMessage(const std::string &msg);
413
414 static bool EmbedFileDialog(const std::shared_ptr<RWebWindow> &window, unsigned connid, const std::string &args);
415};
416
417} // namespace ROOT
418
419#endif
winID h direct
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 on
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 width
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t height
char name[80]
Definition TGX11.cxx:110
Web-based FileDialog.
Holds different arguments for starting browser with RWebDisplayHandle::Display() method.
Handle of created web-based display Depending from type of web display, holds handle of started brows...
just wrapper to deliver websockets call-backs to the RWebWindow class
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::string fDefaultPage
! HTML page (or file name) returned when window URL is opened
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.
bool IsShown() const
Returns true when window was shown at least once.
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 SetGeometry(unsigned width, unsigned height)
Set window geometry. Will be applied if supported by used web display (like CEF or Chromium)
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.
int fY
! initial window position, -1 ignored
int GetX() const
returns configured window X position (-1 - default)
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...
void SetOperationTmout(float tm=50.)
Set timeout for synchronous WebWindow operations.
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
unsigned GetHeight() const
returns configured window height (0 - default)
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....
void SetPosition(unsigned x, unsigned y)
Set window position. Will be applied if supported by used web display (like CEF or Chromium)
bool IsRequireAuthKey() const
returns true if authentication string is required
RWebWindow()
RWebWindow constructor Should be defined here because of std::unique_ptr<RWebWindowWSHandler>
void SetNativeOnlyConn(bool on=true)
configures that only native (own-created) connections are allowed
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 fMaxQueueLength
! maximal number of queue entries
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...
unsigned fHeight
! initial window width and height when displayed, zeros are ignored
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
int GetY() const
returns configured window Y position (-1 - default)
bool fNativeOnlyConn
! only native connection are allowed, created by Show() method
std::shared_ptr< RWebWindowsManager > GetManager() const
Returns window manager.
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
void SetMaxQueueLength(unsigned len=10)
configures maximal queue length of data which can be held by window
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
unsigned GetWidth() const
returns configured window width (0 - default) actual window width can be different
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.
void SetRequireAuthKey(bool on)
Configure if authentication key in connection string is required.
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,...
Central instance to create and show web-based windows like Canvas or FitPanel.
Contains arguments for single HTTP call.
Online http server for arbitrary ROOT application.
Definition THttpServer.h:31
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
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,...
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...
MasterConn(unsigned _connid, int _channel)
std::string fData
! data for given connection
EQueueEntryKind fKind
! kind of data
unsigned fConnId
! connection id
QueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&data)
QueueItem(int chid, bool txt, std::string &&data)
std::string fData
! text or binary data
bool fText
! is text data
int fReady
! 0 - not ready, 1..9 - interim, 10 - done
std::shared_ptr< THttpCallArg > fHold
! request used to hold headless browser
WebConn(unsigned connid)
int fClientCredits
! number of credits received from client
unsigned long fRecvSeq
! sequence id of last received packet
bool fActive
! flag indicates if connection is active
bool fHeadlessMode
! indicate if connection represent batch job
unsigned fConnId
! connection id (unique inside the window)
std::map< int, std::shared_ptr< RWebWindow > > fEmbed
! map of embed window for that connection, key value is channel id
std::string fKey
! key value supplied to the window (when exists)
WebConn(unsigned connid, bool headless_mode, const std::string &key)
unsigned long fSendSeq
! sequence id of last send packet
int fKeyUsed
! key value used to verify connection
~WebConn()
Destructor for WebConn Notify special HTTP request which blocks headless browser from exit.
std::mutex fMutex
! mutex must be used to protect all following data
bool fDoingSend
! true when performing send operation
int fSendCredits
! how many send operation can be performed without confirmation from other side
WebConn(unsigned connid, unsigned wsid)
std::string fNewKey
! new key if connection request reload
unsigned fWSId
! websocket id
timestamp_t fSendStamp
! last server operation, always used from window thread
timestamp_t fRecvStamp
! last receive operation, protected with connection mutex
int fRecvCount
! number of received packets, should return back with next sending
std::queue< QueueItem > fQueue
! output queue
std::unique_ptr< RWebDisplayHandle > fDisplayHandle
! handle assigned with started web display (when exists)