Logo ROOT  
Reference Guide
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 {
32namespace Experimental {
33
34
35/// function signature for connect/disconnect call-backs
36/// argument is connection id
38
39/// function signature for call-backs from the window clients
40/// first argument is connection id, second is received data
41using WebWindowDataCallback_t = std::function<void(unsigned, const std::string &)>;
42
43/// function signature for waiting call-backs
44/// Such callback used when calling thread need to waits for some special data,
45/// but wants to run application event loop
46/// As argument, spent time in second will be provided
47/// Waiting will be performed until function returns non-zero value
49
52
54
55 friend class RWebWindowsManager;
56 friend class RWebWindowWSHandler;
57 friend class RWebDisplayHandle;
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 std::unique_ptr<RWebDisplayHandle> fDisplayHandle; ///<! handle assigned with started web display (when exists)
74 std::shared_ptr<THttpCallArg> fHold; ///<! request used to hold headless browser
75 timestamp_t fSendStamp; ///<! last server operation, always used from window thread
76 bool fActive{false}; ///<! flag indicates if connection is active
77 unsigned fWSId{0}; ///<! websocket id
78 int fReady{0}; ///<! 0 - not ready, 1..9 - interim, 10 - done
79 mutable std::mutex fMutex; ///<! mutex must be used to protect all following data
80 timestamp_t fRecvStamp; ///<! last receive operation, protected with connection mutex
81 int fRecvCount{0}; ///<! number of received packets, should return back with next sending
82 int fSendCredits{0}; ///<! how many send operation can be performed without confirmation from other side
83 int fClientCredits{0}; ///<! number of credits received from client
84 bool fDoingSend{false}; ///<! true when performing send operation
85 std::queue<QueueItem> fQueue; ///<! output queue
86 std::map<int,std::shared_ptr<RWebWindow>> fEmbed; ///<! map of embed window for that connection, key value is channel id
87 WebConn() = default;
88 WebConn(unsigned connid) : fConnId(connid) {}
89 WebConn(unsigned connid, unsigned wsid) : fConnId(connid), fActive(true), fWSId(wsid) {}
90 WebConn(unsigned connid, bool headless_mode, const std::string &key)
91 : fConnId(connid), fHeadlessMode(headless_mode), fKey(key)
92 {
94 }
95 ~WebConn();
96
97 void ResetStamps() { fSendStamp = fRecvStamp = std::chrono::system_clock::now(); }
98 };
99
101
102 struct QueueEntry {
103 unsigned fConnId{0}; ///<! connection id
104 EQueueEntryKind fKind{kind_None}; ///<! kind of data
105 std::string fData; ///<! data for given connection
106 QueueEntry() = default;
107 QueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&data) : fConnId(connid), fKind(kind), fData(data) {}
108 };
109
110 using ConnectionsList_t = std::vector<std::shared_ptr<WebConn>>;
111
112 std::shared_ptr<RWebWindowsManager> fMgr; ///<! display manager
113 std::shared_ptr<RWebWindow> fMaster; ///<! master window where this window is embeded
114 unsigned fMasterConnId{0}; ///<! master connection id
115 int fMasterChannel{-1}; ///<! channel id in the master window
116 std::string fDefaultPage; ///<! HTML page (or file name) returned when window URL is opened
117 std::string fPanelName; ///<! panel name which should be shown in the window
118 unsigned fId{0}; ///<! unique identifier
119 bool fUseServerThreads{false}; ///<! indicates that server thread is using, no special window thread
120 bool fProcessMT{false}; ///<! if window event processing performed in dedicated thread
121 bool fSendMT{false}; ///<! true is special threads should be used for sending data
122 std::shared_ptr<RWebWindowWSHandler> fWSHandler; ///<! specialize websocket handler for all incoming connections
123 unsigned fConnCnt{0}; ///<! counter of new connections to assign ids
124 ConnectionsList_t fPendingConn; ///<! list of pending connection with pre-assigned keys
125 ConnectionsList_t fConn; ///<! list of all accepted connections
126 mutable std::mutex fConnMutex; ///<! mutex used to protect connection list
127 unsigned fConnLimit{1}; ///<! number of allowed active connections
128 std::string fConnToken; ///<! value of "token" URL parameter which should be provided for connecting window
129 bool fNativeOnlyConn{false}; ///<! only native connection are allowed, created by Show() method
130 unsigned fMaxQueueLength{10}; ///<! maximal number of queue entries
131 WebWindowConnectCallback_t fConnCallback; ///<! callback for connect event
132 WebWindowDataCallback_t fDataCallback; ///<! main callback when data over channel 1 is arrived
133 WebWindowConnectCallback_t fDisconnCallback; ///<! callback for disconnect event
134 std::thread::id fCallbacksThrdId; ///<! thread id where callbacks should be invoked
135 bool fCallbacksThrdIdSet{false}; ///<! flag indicating that thread id is assigned
136 bool fHasWindowThrd{false}; ///<! indicate if special window thread was started
137 std::thread fWindowThrd; ///<! special thread for that window
138 std::queue<QueueEntry> fInputQueue; ///<! input queue for all callbacks
139 std::mutex fInputQueueMutex; ///<! mutex to protect input queue
140 unsigned fWidth{0}; ///<! initial window width when displayed
141 unsigned fHeight{0}; ///<! initial window height when displayed
142 float fOperationTmout{50.}; ///<! timeout in seconds to perform synchronous operation, default 50s
143 std::string fClientVersion; ///<! configured client version, used as prefix in scripts URL
144 std::string fProtocolFileName; ///<! local file where communication protocol will be written
145 int fProtocolCnt{-1}; ///<! counter for protocol recording
146 unsigned fProtocolConnId{0}; ///<! connection id, which is used for writing protocol
147 std::string fProtocolPrefix; ///<! prefix for created files names
148 std::string fProtocol; ///<! protocol
149 std::string fUserArgs; ///<! arbitrary JSON code, which is accessible via conn.getUserArgs() method
150
151 std::shared_ptr<RWebWindowWSHandler> CreateWSHandler(std::shared_ptr<RWebWindowsManager> mgr, unsigned id, double tmout);
152
153 bool ProcessWS(THttpCallArg &arg);
154
155 void CompleteWSSend(unsigned wsid);
156
157 ConnectionsList_t GetConnections(unsigned connid = 0, bool only_active = false) const;
158
159 std::shared_ptr<WebConn> FindOrCreateConnection(unsigned wsid, bool make_new, const char *query);
160
161 /// Find connection with specified websocket id
162 std::shared_ptr<WebConn> FindConnection(unsigned wsid) { return FindOrCreateConnection(wsid, false, nullptr); }
163
164 std::shared_ptr<WebConn> RemoveConnection(unsigned wsid);
165
166 std::string _MakeSendHeader(std::shared_ptr<WebConn> &conn, bool txt, const std::string &data, int chid);
167
168 void ProvideQueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&arg);
169
170 void InvokeCallbacks(bool force = false);
171
172 void SubmitData(unsigned connid, bool txt, std::string &&data, int chid = 1);
173
174 bool CheckDataToSend(std::shared_ptr<WebConn> &conn);
175
176 void CheckDataToSend(bool only_once = false);
177
178 bool HasKey(const std::string &key) const;
179
181
183
184 unsigned AddDisplayHandle(bool headless_mode, const std::string &key, std::unique_ptr<RWebDisplayHandle> &handle);
185
186 unsigned AddEmbedWindow(std::shared_ptr<RWebWindow> window, int channel);
187
188 void RemoveEmbedWindow(unsigned connid, int channel);
189
190 bool ProcessBatchHolder(std::shared_ptr<THttpCallArg> &arg);
191
192 std::string GetConnToken() const;
193
194 unsigned MakeHeadless(bool create_new = false);
195
196 unsigned FindHeadlessConnection();
197
198 void CheckThreadAssign();
199
200public:
201
203
204 ~RWebWindow();
205
206 /// Returns ID for the window - unique inside window manager
207 unsigned GetId() const { return fId; }
208
209 /// Set content of default window HTML page
210 /// This page returns when URL address of the window will be requested
211 /// Either HTML code or file name in the form "file:/home/user/data/file.htm"
212 /// One also can using default locations like "file:rootui5sys/canv/canvas.html"
213 void SetDefaultPage(const std::string &page) { fDefaultPage = page; }
214
215 void SetPanelName(const std::string &name);
216
217 /// Set window geometry. Will be applied if supported by used web display (like CEF or Chromium)
218 void SetGeometry(unsigned width, unsigned height)
219 {
220 fWidth = width;
221 fHeight = height;
222 }
223
224 /////////////////////////////////////////////////////////////////////////
225 /// returns configured window width (0 - default)
226 /// actual window width can be different
227 unsigned GetWidth() const { return fWidth; }
228
229 /////////////////////////////////////////////////////////////////////////
230 /// returns configured window height (0 - default)
231 unsigned GetHeight() const { return fHeight; }
232
233 void SetConnLimit(unsigned lmt = 0);
234
235 unsigned GetConnLimit() const;
236
237 void SetConnToken(const std::string &token = "");
238
239 /////////////////////////////////////////////////////////////////////////
240 /// configures maximal queue length of data which can be held by window
241 void SetMaxQueueLength(unsigned len = 10) { fMaxQueueLength = len; }
242
243 /////////////////////////////////////////////////////////////////////////
244 /// Return maximal queue length of data which can be held by window
245 unsigned GetMaxQueueLength() const { return fMaxQueueLength; }
246
247 /////////////////////////////////////////////////////////////////////////
248 /// configures that only native (own-created) connections are allowed
249 void SetNativeOnlyConn(bool on = true) { fNativeOnlyConn = on; }
250
251 /////////////////////////////////////////////////////////////////////////
252 /// returns true if only native (own-created) connections are allowed
253 bool IsNativeOnlyConn() const { return fNativeOnlyConn; }
254
255 void SetClientVersion(const std::string &vers);
256
257 std::string GetClientVersion() const;
258
259 void SetUserArgs(const std::string &args);
260
261 std::string GetUserArgs() const;
262
263 int NumConnections(bool with_pending = false) const;
264
265 unsigned GetConnectionId(int num = 0) const;
266
267 bool HasConnection(unsigned connid = 0, bool only_active = true) const;
268
269 void CloseConnections();
270
271 void CloseConnection(unsigned connid);
272
273 /// Returns timeout for synchronous WebWindow operations
274 float GetOperationTmout() const { return fOperationTmout; }
275
276 /// Set timeout for synchronous WebWindow operations
277 void SetOperationTmout(float tm = 50.) { fOperationTmout = tm; }
278
279 std::string GetUrl(bool remote = true);
280
282
283 void Sync();
284
285 void Run(double tm = 0.);
286
287 unsigned Show(const RWebDisplayArgs &args = "");
288
289 unsigned GetDisplayConnection() const;
290
291 /// Returns true when window was shown at least once
292 bool IsShown() const { return GetDisplayConnection() != 0; }
293
294 bool CanSend(unsigned connid, bool direct = true) const;
295
296 int GetSendQueueLength(unsigned connid) const;
297
298 void Send(unsigned connid, const std::string &data);
299
300 void SendBinary(unsigned connid, const void *data, std::size_t len);
301
302 void SendBinary(unsigned connid, std::string &&data);
303
304 void RecordData(const std::string &fname = "protocol.json", const std::string &fprefix = "");
305
306 std::string GetAddr() const;
307
308 std::string GetRelativeAddr(const std::shared_ptr<RWebWindow> &win) const;
309
311
313
315
317
318 void AssignThreadId();
319
320 void UseServerThreads();
321
322 int WaitFor(WebWindowWaitFunc_t check);
323
325
326 int WaitForTimed(WebWindowWaitFunc_t check, double duration);
327
328 void StartThread();
329
330 void StopThread();
331
332 void TerminateROOT();
333
334 static std::shared_ptr<RWebWindow> Create();
335
336 static unsigned ShowWindow(std::shared_ptr<RWebWindow> window, const RWebDisplayArgs &args = "");
337
338};
339
340} // namespace Experimental
341} // namespace ROOT
342
343#endif
typedef void(GLAPIENTRYP _GLUfuncptr)(void)
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition: TDocParser.cxx:121
XFontStruct * id
Definition: TGX11.cxx:109
char name[80]
Definition: TGX11.cxx:110
Holds different arguments for starting browser with RWebDisplayHandle::Display() method.
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.
Definition: RWebWindow.hxx:53
bool CheckDataToSend(std::shared_ptr< WebConn > &conn)
Checks if one should send data for specified connection Returns true when send operation was performe...
Definition: RWebWindow.cxx:831
std::vector< std::shared_ptr< WebConn > > ConnectionsList_t
Definition: RWebWindow.hxx:110
int WaitFor(WebWindowWaitFunc_t check)
Waits until provided check function or lambdas returns non-zero value Check function has following si...
std::string fDefaultPage
! HTML page (or file name) returned when window URL is opened
Definition: RWebWindow.hxx:116
unsigned AddEmbedWindow(std::shared_ptr< RWebWindow > window, int channel)
Add embed window.
std::shared_ptr< RWebWindow > fMaster
! master window where this window is embeded
Definition: RWebWindow.hxx:113
void CheckInactiveConnections()
Check if there are connection which are inactive for longer time For instance, batch browser will be ...
Definition: RWebWindow.cxx:495
ConnectionsList_t GetConnections(unsigned connid=0, bool only_active=false) const
returns connection (or all active connections)
std::string fUserArgs
! arbitrary JSON code, which is accessible via conn.getUserArgs() method
Definition: RWebWindow.hxx:149
int fMasterChannel
! channel id in the master window
Definition: RWebWindow.hxx:115
void StartThread()
Start special thread which will be used by the window to handle all callbacks One has to be sure,...
float GetOperationTmout() const
Returns timeout for synchronous WebWindow operations.
Definition: RWebWindow.hxx:274
std::shared_ptr< WebConn > FindConnection(unsigned wsid)
Find connection with specified websocket id.
Definition: RWebWindow.hxx:162
void SetConnToken(const std::string &token="")
Configures connection token (default none) When specified, in URL of webpage such token should be pro...
Definition: RWebWindow.cxx:552
unsigned MakeHeadless(bool create_new=false)
Start headless browser for specified window Normally only single instance is used,...
Definition: RWebWindow.cxx:176
std::string GetUrl(bool remote=true)
Return URL string to access web window If remote flag is specified, real HTTP server will be started ...
Definition: RWebWindow.cxx:147
void CloseConnections()
Closes all connection to clients Normally leads to closing of all correspondent browser windows Some ...
void SetDefaultPage(const std::string &page)
Set content of default window HTML page This page returns when URL address of the window will be requ...
Definition: RWebWindow.hxx:213
std::thread fWindowThrd
! special thread for that window
Definition: RWebWindow.hxx:137
int NumConnections(bool with_pending=false) const
Returns current number of active clients connections.
Definition: RWebWindow.cxx:981
unsigned GetId() const
Returns ID for the window - unique inside window manager.
Definition: RWebWindow.hxx:207
ConnectionsList_t fConn
! list of all accepted connections
Definition: RWebWindow.hxx:125
void InvokeCallbacks(bool force=false)
Invoke callbacks with existing data Must be called from appropriate thread.
Definition: RWebWindow.cxx:377
std::string fProtocolPrefix
! prefix for created files names
Definition: RWebWindow.hxx:147
std::string GetClientVersion() const
Returns current client version.
Definition: RWebWindow.cxx:951
void SetConnectCallBack(WebWindowConnectCallback_t func)
Set call-back function for new connection.
WebWindowConnectCallback_t fConnCallback
! callback for connect event
Definition: RWebWindow.hxx:131
unsigned GetMaxQueueLength() const
Return maximal queue length of data which can be held by window.
Definition: RWebWindow.hxx:245
void Sync()
Special method to process all internal activity when window runs in separate thread.
Definition: RWebWindow.cxx:899
void UseServerThreads()
Let use THttpServer threads to process requests WARNING!!! only for expert use Should be only used wh...
void TerminateROOT()
Terminate ROOT session Tries to correctly close THttpServer, associated with RWebWindowsManager After...
unsigned fConnLimit
! number of allowed active connections
Definition: RWebWindow.hxx:127
void Send(unsigned connid, const std::string &data)
Sends data to specified connection If.
bool fCallbacksThrdIdSet
! flag indicating that thread id is assigned
Definition: RWebWindow.hxx:135
unsigned Show(const RWebDisplayArgs &args="")
Show window in specified location See ROOT::Experimental::RWebWindowsManager::Show() docu for more in...
Definition: RWebWindow.cxx:165
THttpServer * GetServer()
Return THttpServer instance serving requests to the window.
Definition: RWebWindow.cxx:155
unsigned AddDisplayHandle(bool headless_mode, const std::string &key, std::unique_ptr< RWebDisplayHandle > &handle)
Add display handle and associated key Key is random number generated when starting new window When cl...
Definition: RWebWindow.cxx:421
unsigned fMasterConnId
! master connection id
Definition: RWebWindow.hxx:114
void AssignThreadId()
Assign thread id which has to be used for callbacks WARNING!!! only for expert use Automatically done...
bool fSendMT
! true is special threads should be used for sending data
Definition: RWebWindow.hxx:121
void SendBinary(unsigned connid, const void *data, std::size_t len)
Send binary data to specified connection If.
unsigned fWidth
! initial window width when displayed
Definition: RWebWindow.hxx:140
static std::shared_ptr< RWebWindow > Create()
Create new RWebWindow Using default RWebWindowsManager.
std::thread::id fCallbacksThrdId
! thread id where callbacks should be invoked
Definition: RWebWindow.hxx:134
std::chrono::time_point< std::chrono::system_clock > timestamp_t
Definition: RWebWindow.hxx:60
std::string fClientVersion
! configured client version, used as prefix in scripts URL
Definition: RWebWindow.hxx:143
bool ProcessBatchHolder(std::shared_ptr< THttpCallArg > &arg)
Process special http request, used to hold headless browser running Such requests should not be repli...
Definition: RWebWindow.cxx:315
unsigned fConnCnt
! counter of new connections to assign ids
Definition: RWebWindow.hxx:123
unsigned fMaxQueueLength
! maximal number of queue entries
Definition: RWebWindow.hxx:130
void SetDisconnectCallBack(WebWindowConnectCallback_t func)
Set call-back function for disconnecting.
std::string fPanelName
! panel name which should be shown in the window
Definition: RWebWindow.hxx:117
void SetDataCallBack(WebWindowDataCallback_t func)
Set call-back function for data, received from the clients via websocket.
unsigned fProtocolConnId
! connection id, which is used for writing protocol
Definition: RWebWindow.hxx:146
void SetUserArgs(const std::string &args)
Set arbitrary JSON code, which is accessible via conn.GetUserArgs() method This JSON code injected in...
Definition: RWebWindow.cxx:962
static unsigned ShowWindow(std::shared_ptr< RWebWindow > window, const RWebDisplayArgs &args="")
Static method to show web window Has to be used instead of RWebWindow::Show() when window potentially...
void StopThread()
Stop special thread.
WebWindowDataCallback_t fDataCallback
! main callback when data over channel 1 is arrived
Definition: RWebWindow.hxx:132
void SubmitData(unsigned connid, bool txt, std::string &&data, int chid=1)
Internal method to send data Allows to specify channel.
~RWebWindow()
RWebWindow destructor Closes all connections and remove window from manager.
Definition: RWebWindow.cxx:76
void CloseConnection(unsigned connid)
Close specified connection Connection id usually appears in the correspondent call-backs.
unsigned GetConnectionId(int num=0) const
Returns connection for specified connection number Only active connections are returned - where clien...
bool IsShown() const
Returns true when window was shown at least once.
Definition: RWebWindow.hxx:292
std::string GetConnToken() const
Returns configured connection token.
Definition: RWebWindow.cxx:562
void SetMaxQueueLength(unsigned len=10)
configures maximal queue length of data which can be held by window
Definition: RWebWindow.hxx:241
ConnectionsList_t fPendingConn
! list of pending connection with pre-assigned keys
Definition: RWebWindow.hxx:124
void SetConnLimit(unsigned lmt=0)
Configure maximal number of allowed connections - 0 is unlimited Will not affect already existing con...
Definition: RWebWindow.cxx:530
void SetPanelName(const std::string &name)
Configure window to show some of existing JSROOT panels It uses "file:rootui5sys/panel/panel....
Definition: RWebWindow.cxx:113
RWebWindow()
RWebWindow constructor Should be defined here because of std::unique_ptr<RWebWindowWSHandler>
std::shared_ptr< WebConn > FindOrCreateConnection(unsigned wsid, bool make_new, const char *query)
Find connection with given websocket id Connection mutex should be locked before method calling.
Definition: RWebWindow.cxx:239
bool fHasWindowThrd
! indicate if special window thread was started
Definition: RWebWindow.hxx:136
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.
Definition: RWebWindow.cxx:286
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...
Definition: RWebWindow.cxx:131
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.
Definition: RWebWindow.cxx:972
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...
unsigned GetHeight() const
returns configured window height (0 - default)
Definition: RWebWindow.hxx:231
void CheckThreadAssign()
Internal method to verify and thread id has to be assigned from manager again Special case when Proce...
Definition: RWebWindow.cxx:573
bool HasKey(const std::string &key) const
Returns true if provided key value already exists (in processes map or in existing connections)
Definition: RWebWindow.cxx:439
unsigned GetDisplayConnection() const
Returns first connection id where window is displayed It could be that connection(s) not yet fully es...
Definition: RWebWindow.cxx:218
void SetOperationTmout(float tm=50.)
Set timeout for synchronous WebWindow operations.
Definition: RWebWindow.hxx:277
unsigned GetConnLimit() const
returns configured connections limit (0 - default)
Definition: RWebWindow.cxx:540
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 ...
Definition: RWebWindow.cxx:923
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.
Definition: RWebWindow.cxx:913
bool fNativeOnlyConn
! only native connection are allowed, created by Show() method
Definition: RWebWindow.hxx:129
void SetGeometry(unsigned width, unsigned height)
Set window geometry. Will be applied if supported by used web display (like CEF or Chromium)
Definition: RWebWindow.hxx:218
unsigned GetWidth() const
returns configured window width (0 - default) actual window width can be different
Definition: RWebWindow.hxx:227
std::shared_ptr< RWebWindowWSHandler > fWSHandler
! specialize websocket handler for all incoming connections
Definition: RWebWindow.hxx:122
bool fUseServerThreads
! indicates that server thread is using, no special window thread
Definition: RWebWindow.hxx:119
std::string fProtocolFileName
! local file where communication protocol will be written
Definition: RWebWindow.hxx:144
unsigned fHeight
! initial window height when displayed
Definition: RWebWindow.hxx:141
std::shared_ptr< RWebWindowsManager > fMgr
! display manager
Definition: RWebWindow.hxx:112
void CheckPendingConnections()
Check if started process(es) establish connection.
Definition: RWebWindow.cxx:460
std::string fConnToken
! value of "token" URL parameter which should be provided for connecting window
Definition: RWebWindow.hxx:128
std::mutex fInputQueueMutex
! mutex to protect input queue
Definition: RWebWindow.hxx:139
std::string _MakeSendHeader(std::shared_ptr< WebConn > &conn, bool txt, const std::string &data, int chid)
Prepare text part of send data Should be called under locked connection mutex.
Definition: RWebWindow.cxx:784
bool IsNativeOnlyConn() const
returns true if only native (own-created) connections are allowed
Definition: RWebWindow.hxx:253
bool ProcessWS(THttpCallArg &arg)
Processing of websockets call-backs, invoked from RWebWindowWSHandler Method invoked from http server...
Definition: RWebWindow.cxx:583
bool HasConnection(unsigned connid=0, bool only_active=true) const
returns true if specified connection id exists
int fProtocolCnt
! counter for protocol recording
Definition: RWebWindow.hxx:145
std::queue< QueueEntry > fInputQueue
! input queue for all callbacks
Definition: RWebWindow.hxx:138
bool fProcessMT
! if window event processing performed in dedicated thread
Definition: RWebWindow.hxx:120
std::string fProtocol
! protocol
Definition: RWebWindow.hxx:148
void ProvideQueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&arg)
Provide data to user callback User callback must be executed in the window thread.
Definition: RWebWindow.cxx:363
void CompleteWSSend(unsigned wsid)
Complete websocket send operation Clear "doing send" flag and check if next operation has to be start...
Definition: RWebWindow.cxx:765
unsigned fId
! unique identifier
Definition: RWebWindow.hxx:118
float fOperationTmout
! timeout in seconds to perform synchronous operation, default 50s
Definition: RWebWindow.hxx:142
unsigned FindHeadlessConnection()
Returns connection id of window running in headless mode This can be special connection which may run...
Definition: RWebWindow.cxx:195
int WaitForTimed(WebWindowWaitFunc_t check)
Waits until provided check function or lambdas returns non-zero value Check function has following si...
WebWindowConnectCallback_t fDisconnCallback
! callback for disconnect event
Definition: RWebWindow.hxx:133
void SetNativeOnlyConn(bool on=true)
configures that only native (own-created) connections are allowed
Definition: RWebWindow.hxx:249
void SetClientVersion(const std::string &vers)
Set client version, used as prefix in scripts URL When changed, web browser will reload all related J...
Definition: RWebWindow.cxx:942
void RemoveEmbedWindow(unsigned connid, int channel)
Remove RWebWindow associated with the channel.
void SetCallBacks(WebWindowConnectCallback_t conn, WebWindowDataCallback_t data, WebWindowConnectCallback_t disconn=nullptr)
Set call-backs function for connect, data and disconnect events.
std::mutex fConnMutex
! mutex used to protect connection list
Definition: RWebWindow.hxx:126
Central instance to create and show web-based windows like Canvas or FitPanel.
std::function< void(unsigned)> WebWindowConnectCallback_t
function signature for connect/disconnect call-backs argument is connection id
Definition: RWebWindow.hxx:37
std::function< void(unsigned, const std::string &)> WebWindowDataCallback_t
function signature for call-backs from the window clients first argument is connection id,...
Definition: RWebWindow.hxx:41
std::function< int(double)> WebWindowWaitFunc_t
function signature for waiting call-backs Such callback used when calling thread need to waits for so...
Definition: RWebWindow.hxx:48
void function(const Char_t *name_, T fun, const Char_t *docstring=0)
Definition: RExports.h:150
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
QueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&data)
Definition: RWebWindow.hxx:107
EQueueEntryKind fKind
! kind of data
Definition: RWebWindow.hxx:104
std::string fData
! data for given connection
Definition: RWebWindow.hxx:105
std::string fData
! text or binary data
Definition: RWebWindow.hxx:65
QueueItem(int chid, bool txt, std::string &&data)
Definition: RWebWindow.hxx:66
std::queue< QueueItem > fQueue
! output queue
Definition: RWebWindow.hxx:85
WebConn(unsigned connid, unsigned wsid)
Definition: RWebWindow.hxx:89
int fReady
! 0 - not ready, 1..9 - interim, 10 - done
Definition: RWebWindow.hxx:78
int fClientCredits
! number of credits received from client
Definition: RWebWindow.hxx:83
std::mutex fMutex
! mutex must be used to protect all following data
Definition: RWebWindow.hxx:79
timestamp_t fRecvStamp
! last receive operation, protected with connection mutex
Definition: RWebWindow.hxx:80
int fSendCredits
! how many send operation can be performed without confirmation from other side
Definition: RWebWindow.hxx:82
unsigned fConnId
! connection id (unique inside the window)
Definition: RWebWindow.hxx:70
bool fDoingSend
! true when performing send operation
Definition: RWebWindow.hxx:84
~WebConn()
Destructor for WebConn Notify special HTTP request which blocks headless browser from exit.
Definition: RWebWindow.cxx:37
WebConn(unsigned connid, bool headless_mode, const std::string &key)
Definition: RWebWindow.hxx:90
std::string fKey
! key value supplied to the window (when exists)
Definition: RWebWindow.hxx:72
std::shared_ptr< THttpCallArg > fHold
! request used to hold headless browser
Definition: RWebWindow.hxx:74
int fRecvCount
! number of received packets, should return back with next sending
Definition: RWebWindow.hxx:81
timestamp_t fSendStamp
! last server operation, always used from window thread
Definition: RWebWindow.hxx:75
bool fActive
! flag indicates if connection is active
Definition: RWebWindow.hxx:76
std::unique_ptr< RWebDisplayHandle > fDisplayHandle
! handle assigned with started web display (when exists)
Definition: RWebWindow.hxx:73
bool fHeadlessMode
! indicate if connection represent batch job
Definition: RWebWindow.hxx:71
std::map< int, std::shared_ptr< RWebWindow > > fEmbed
! map of embed window for that connection, key value is channel id
Definition: RWebWindow.hxx:86