EIC code displayed by LXR master/​include/​root/​ROOT/​RWebWindow.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:10:50

 // Author: Sergey Linev <s.linev@gsi.de>
 // Date: 2017-10-16
 // Warning: This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback is welcome!
 
 /*************************************************************************
  * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
  * All rights reserved.                                                  *
  *                                                                       *
  * For the licensing terms see $ROOTSYS/LICENSE.                         *
  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
  *************************************************************************/
 
 #ifndef ROOT7_RWebWindow
 #define ROOT7_RWebWindow
 
 #include <ROOT/RWebDisplayHandle.hxx>
 
 #include <memory>
 #include <vector>
 #include <string>
 #include <queue>
 #include <map>
 #include <functional>
 #include <mutex>
 #include <thread>
 #include <chrono>
 
 class THttpCallArg;
 class THttpServer;
 
 namespace ROOT {
 
 /// function signature for connect/disconnect call-backs
 /// argument is connection id
 using WebWindowConnectCallback_t = std::function<void(unsigned)>;
 
 /// function signature for call-backs from the window clients
 /// first argument is connection id, second is received data
 using WebWindowDataCallback_t = std::function<void(unsigned, const std::string &)>;
 
 /// function signature for waiting call-backs
 /// Such callback used when calling thread need to waits for some special data,
 /// but wants to run application event loop
 /// As argument, spent time in second will be provided
 /// Waiting will be performed until function returns non-zero value
 using WebWindowWaitFunc_t = std::function<int(double)>;
 
 class RFileDialog;
 class RWebWindowsManager;
 class RWebWindowWSHandler;
 
 class RWebWindow {
 
    friend class RWebWindowsManager;
    friend class RWebWindowWSHandler;
    friend class RWebDisplayHandle;
    friend class RFileDialog;
 
 private:
    using timestamp_t = std::chrono::time_point<std::chrono::system_clock>;
 
    struct QueueItem {
       int fChID{1};      ///<! channel
       bool fText{true};  ///<! is text data
       std::string fData; ///<! text or binary data
       QueueItem(int chid, bool txt, std::string &&data) : fChID(chid), fText(txt), fData(data) {}
    };
 
    struct WebConn {
       unsigned fConnId{0};                 ///<! connection id (unique inside the window)
       bool fHeadlessMode{false};           ///<! indicate if connection represent batch job
       std::string fKey;                    ///<! key value supplied to the window (when exists)
       int fKeyUsed{0};                     ///<! key value used to verify connection
       std::string fNewKey;                 ///<! new key if connection request reload
       std::unique_ptr<RWebDisplayHandle> fDisplayHandle;  ///<! handle assigned with started web display (when exists)
       std::shared_ptr<THttpCallArg> fHold; ///<! request used to hold headless browser
       timestamp_t fSendStamp;              ///<! last server operation, always used from window thread
       bool fActive{false};                 ///<! flag indicates if connection is active
       unsigned fWSId{0};                   ///<! websocket id
       int fReady{0};                       ///<! 0 - not ready, 1..9 - interim, 10 - done
       mutable std::mutex fMutex;           ///<! mutex must be used to protect all following data
       timestamp_t fRecvStamp;              ///<! last receive operation, protected with connection mutex
       int fRecvCount{0};                   ///<! number of received packets, should return back with next sending
       int fSendCredits{0};                 ///<! how many send operation can be performed without confirmation from other side
       int fClientCredits{0};               ///<! number of credits received from client
       bool fDoingSend{false};              ///<! true when performing send operation
       unsigned long fRecvSeq{0};           ///<! sequence id of last received packet
       unsigned long fSendSeq{1};           ///<! sequence id of last send packet
       std::queue<QueueItem> fQueue;        ///<! output queue
       std::map<int,std::shared_ptr<RWebWindow>> fEmbed; ///<! map of embed window for that connection, key value is channel id
       WebConn() = default;
       WebConn(unsigned connid) : fConnId(connid) {}
       WebConn(unsigned connid, unsigned wsid) : fConnId(connid), fActive(true), fWSId(wsid) {}
       WebConn(unsigned connid, bool headless_mode, const std::string &key)
          : fConnId(connid), fHeadlessMode(headless_mode), fKey(key)
       {
          ResetStamps();
       }
       ~WebConn();
 
       void ResetStamps() { fSendStamp = fRecvStamp = std::chrono::system_clock::now(); }
 
       void ResetData()
       {
          fActive = false;
          fWSId = 0;
          fReady = 0;
          fDoingSend = false;
          fSendCredits = 0;
          fClientCredits = 0;
          fRecvSeq = 0;
          fSendSeq = 1;
          while (!fQueue.empty())
             fQueue.pop();
       }
    };
 
    struct MasterConn {
       unsigned connid{0};
       int channel{-1};
       MasterConn(unsigned _connid, int _channel) : connid(_connid), channel(_channel) {}
    };
 
    enum EQueueEntryKind { kind_None, kind_Connect, kind_Data, kind_Disconnect };
 
    struct QueueEntry {
       unsigned fConnId{0};               ///<! connection id
       EQueueEntryKind fKind{kind_None};  ///<! kind of data
       std::string fData;                 ///<! data for given connection
       QueueEntry() = default;
       QueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&data) : fConnId(connid), fKind(kind), fData(data) {}
    };
 
    using ConnectionsList_t = std::vector<std::shared_ptr<WebConn>>;
 
    std::shared_ptr<RWebWindowsManager> fMgr;        ///<! display manager
    std::shared_ptr<RWebWindow> fMaster;             ///<! master window where this window is embedded
    std::vector<MasterConn> fMasterConns;            ///<! master connections
    std::string fDefaultPage;                        ///<! HTML page (or file name) returned when window URL is opened
    std::string fPanelName;                          ///<! panel name which should be shown in the window
    unsigned fId{0};                                 ///<! unique identifier
    bool fUseServerThreads{false};                   ///<! indicates that server thread is using, no special window thread
    bool fUseProcessEvents{false};                   ///<! all window functionality will run through process events
    bool fProcessMT{false};                          ///<! if window event processing performed in dedicated thread
    bool fSendMT{false};                             ///<! true is special threads should be used for sending data
    bool fRequireAuthKey{true};                      ///<! defines if authentication key always required when connect to the widget
    std::shared_ptr<RWebWindowWSHandler> fWSHandler; ///<! specialize websocket handler for all incoming connections
    unsigned fConnCnt{0};                            ///<! counter of new connections to assign ids
    ConnectionsList_t fPendingConn;                  ///<! list of pending connection with pre-assigned keys
    ConnectionsList_t fConn;                         ///<! list of all accepted connections
    mutable std::mutex fConnMutex;                   ///<! mutex used to protect connection list
    unsigned fConnLimit{1};                          ///<! number of allowed active connections
    std::string fConnToken;                          ///<! value of "token" URL parameter which should be provided for connecting window
    bool fNativeOnlyConn{false};                     ///<! only native connection are allowed, created by Show() method
    bool fUseCurrentDir{false};                      ///<! if window can access local files via currentdir/ path of http server
    unsigned fMaxQueueLength{10};                    ///<! maximal number of queue entries
    WebWindowConnectCallback_t fConnCallback;        ///<! callback for connect event
    WebWindowDataCallback_t fDataCallback;           ///<! main callback when data over channel 1 is arrived
    WebWindowConnectCallback_t fDisconnCallback;     ///<! callback for disconnect event
    std::thread::id fCallbacksThrdId;                ///<! thread id where callbacks should be invoked
    bool fCallbacksThrdIdSet{false};                 ///<! flag indicating that thread id is assigned
    bool fHasWindowThrd{false};                      ///<! indicate if special window thread was started
    std::thread fWindowThrd;                         ///<! special thread for that window
    std::queue<QueueEntry> fInputQueue;              ///<! input queue for all callbacks
    std::mutex fInputQueueMutex;                     ///<! mutex to protect input queue
    unsigned fWidth{0}, fHeight{0};                  ///<! initial window width and height when displayed, zeros are ignored
    int fX{-1}, fY{-1};                              ///<! initial window position, -1 ignored
    float fOperationTmout{50.};                      ///<! timeout in seconds to perform synchronous operation, default 50s
    std::string fClientVersion;                      ///<! configured client version, used as prefix in scripts URL
    std::string fProtocolFileName;                   ///<! local file where communication protocol will be written
    int fProtocolCnt{-1};                            ///<! counter for protocol recording
    unsigned fProtocolConnId{0};                     ///<! connection id, which is used for writing protocol
    std::string fProtocolPrefix;                     ///<! prefix for created files names
    std::string fProtocol;                           ///<! protocol
    std::string fUserArgs;                           ///<! arbitrary JSON code, which is accessible via conn.getUserArgs() method
    std::shared_ptr<void> fClearOnClose;             ///<! entry which is cleared when last connection is closed
 
    std::shared_ptr<RWebWindowWSHandler> CreateWSHandler(std::shared_ptr<RWebWindowsManager> mgr, unsigned id, double tmout);
 
    bool ProcessWS(THttpCallArg &arg);
 
    void CompleteWSSend(unsigned wsid);
 
    ConnectionsList_t GetWindowConnections(unsigned connid = 0, bool only_active = false) const;
 
    /// Find connection with specified websocket id
    std::shared_ptr<WebConn> FindConnection(unsigned wsid);
 
    std::shared_ptr<WebConn> RemoveConnection(unsigned wsid);
 
    bool _CanTrustIn(std::shared_ptr<WebConn> &conn, const std::string &key, const std::string &ntry, bool remote, bool test_first_time);
 
    std::string _MakeSendHeader(std::shared_ptr<WebConn> &conn, bool txt, const std::string &data, int chid);
 
    void ProvideQueueEntry(unsigned connid, EQueueEntryKind kind, std::string &&arg);
 
    void InvokeCallbacks(bool force = false);
 
    void SubmitData(unsigned connid, bool txt, std::string &&data, int chid = 1);
 
    bool CheckDataToSend(std::shared_ptr<WebConn> &conn);
 
    void CheckDataToSend(bool only_once = false);
 
    bool HasKey(const std::string &key, bool also_newkey = false) const;
 
    void RemoveKey(const std::string &key);
 
    std::string GenerateKey() const;
 
    void CheckPendingConnections();
 
    void CheckInactiveConnections();
 
    unsigned AddDisplayHandle(bool headless_mode, const std::string &key, std::unique_ptr<RWebDisplayHandle> &handle);
 
    unsigned AddEmbedWindow(std::shared_ptr<RWebWindow> window, unsigned connid, int channel);
 
    void RemoveEmbedWindow(unsigned connid, int channel);
 
    void AddMasterConnection(std::shared_ptr<RWebWindow> window, unsigned connid, int channel);
 
    std::vector<MasterConn> GetMasterConnections(unsigned connid = 0) const;
 
    void RemoveMasterConnection(unsigned connid = 0);
 
    bool ProcessBatchHolder(std::shared_ptr<THttpCallArg> &arg);
 
    std::string GetConnToken() const;
 
    unsigned MakeHeadless(bool create_new = false);
 
    unsigned FindHeadlessConnection();
 
    static std::function<bool(const std::shared_ptr<RWebWindow> &, unsigned, const std::string &)> gStartDialogFunc;
 
    static void SetStartDialogFunc(std::function<bool(const std::shared_ptr<RWebWindow> &, unsigned, const std::string &)>);
 
    static std::string HMAC(const std::string &key, const std::string &sessionKey, const char *msg, int msglen);
 
 public:
 
    RWebWindow();
 
    ~RWebWindow();
 
    /// Returns ID for the window - unique inside window manager
    unsigned GetId() const { return fId; }
 
    /// Returns window manager
    std::shared_ptr<RWebWindowsManager> GetManager() const { return fMgr; }
 
    /// Set content of default window HTML page
    /// This page returns when URL address of the window will be requested
    /// Either HTML code or file name in the form "file:/home/user/data/file.htm"
    /// One also can using default locations like "file:rootui5sys/canv/canvas.html"
    void SetDefaultPage(const std::string &page) { fDefaultPage = page; }
 
    void SetPanelName(const std::string &name);
 
    /// Set window geometry. Will be applied if supported by used web display (like CEF or Chromium)
    void SetGeometry(unsigned width, unsigned height)
    {
       fWidth = width;
       fHeight = height;
    }
 
    /// Set window position. Will be applied if supported by used web display (like CEF or Chromium)
    void SetPosition(unsigned x, unsigned y)
    {
       fX = x;
       fY = y;
    }
 
    /////////////////////////////////////////////////////////////////////////
    /// returns configured window width (0 - default)
    /// actual window width can be different
    unsigned GetWidth() const { return fWidth; }
 
    /////////////////////////////////////////////////////////////////////////
    /// returns configured window height (0 - default)
    unsigned GetHeight() const { return fHeight; }
 
    /////////////////////////////////////////////////////////////////////////
    /// returns configured window X position (-1 - default)
    int GetX() const { return fX; }
 
    /////////////////////////////////////////////////////////////////////////
    /// returns configured window Y position (-1 - default)
    int GetY() const { return fY; }
 
    void SetConnLimit(unsigned lmt = 0);
 
    unsigned GetConnLimit() const;
 
    void SetConnToken(const std::string &token = "");
 
    /////////////////////////////////////////////////////////////////////////
    /// configures maximal queue length of data which can be held by window
    void SetMaxQueueLength(unsigned len = 10) { fMaxQueueLength = len; }
 
    /////////////////////////////////////////////////////////////////////////
    /// Return maximal queue length of data which can be held by window
    unsigned GetMaxQueueLength() const { return fMaxQueueLength; }
 
    /////////////////////////////////////////////////////////////////////////
    /// configures that only native (own-created) connections are allowed
    void SetNativeOnlyConn(bool on = true) { fNativeOnlyConn = on; }
 
    /////////////////////////////////////////////////////////////////////////
    /// returns true if only native (own-created) connections are allowed
    bool IsNativeOnlyConn() const { return fNativeOnlyConn; }
 
    /////////////////////////////////////////////////////////////////////////
    /// Configure if authentication key in connection string is required
    void SetRequireAuthKey(bool on) { fRequireAuthKey = on; }
 
    /////////////////////////////////////////////////////////////////////////
    /// returns true if authentication string is required
    bool IsRequireAuthKey() const { return fRequireAuthKey; }
 
    /////////////////////////////////////////////////////////////////////////
    /// Configure if window can access local files via currentdir/ path of http server
    void SetUseCurrentDir(bool on = true) { fUseCurrentDir = on; }
 
    /////////////////////////////////////////////////////////////////////////
    /// returns true if window can access local files via currentdir/ path of http server
    bool IsUseCurrentDir() const { return fUseCurrentDir; }
 
    void SetClientVersion(const std::string &vers);
 
    std::string GetClientVersion() const;
 
    void SetUserArgs(const std::string &args);
 
    std::string GetUserArgs() const;
 
    int NumConnections(bool with_pending = false) const;
 
    unsigned GetConnectionId(int num = 0) const;
 
    std::vector<unsigned> GetConnections(unsigned excludeid = 0) const;
 
    bool HasConnection(unsigned connid = 0, bool only_active = true) const;
 
    void CloseConnections();
 
    void CloseConnection(unsigned connid);
 
    /// Returns timeout for synchronous WebWindow operations
    float GetOperationTmout() const { return fOperationTmout; }
 
    /// Set timeout for synchronous WebWindow operations
    void SetOperationTmout(float tm = 50.) { fOperationTmout = tm; }
 
    std::string GetUrl(bool remote = true);
 
    THttpServer *GetServer();
 
    void Sync();
 
    void Run(double tm = 0.);
 
    unsigned Show(const RWebDisplayArgs &args = "");
 
    unsigned GetDisplayConnection() const;
 
    /// Returns true when window was shown at least once
    bool IsShown() const { return GetDisplayConnection() != 0; }
 
    bool CanSend(unsigned connid, bool direct = true) const;
 
    int GetSendQueueLength(unsigned connid) const;
 
    void Send(unsigned connid, const std::string &data);
 
    void SendBinary(unsigned connid, const void *data, std::size_t len);
 
    void SendBinary(unsigned connid, std::string &&data);
 
    void RecordData(const std::string &fname = "protocol.json", const std::string &fprefix = "");
 
    std::string GetAddr() const;
 
    std::string GetRelativeAddr(const std::shared_ptr<RWebWindow> &win) const;
 
    std::string GetRelativeAddr(const RWebWindow &win) const;
 
    void SetCallBacks(WebWindowConnectCallback_t conn, WebWindowDataCallback_t data, WebWindowConnectCallback_t disconn = nullptr);
 
    void SetConnectCallBack(WebWindowConnectCallback_t func);
 
    void SetDataCallBack(WebWindowDataCallback_t func);
 
    void SetDisconnectCallBack(WebWindowConnectCallback_t func);
 
    void SetClearOnClose(const std::shared_ptr<void> &handle = nullptr);
 
    void AssignThreadId();
 
    void UseServerThreads();
 
    int WaitFor(WebWindowWaitFunc_t check);
 
    int WaitForTimed(WebWindowWaitFunc_t check);
 
    int WaitForTimed(WebWindowWaitFunc_t check, double duration);
 
    void StartThread();
 
    void StopThread();
 
    void TerminateROOT();
 
    static std::shared_ptr<RWebWindow> Create();
 
    static unsigned ShowWindow(std::shared_ptr<RWebWindow> window, const RWebDisplayArgs &args = "");
 
    static bool IsFileDialogMessage(const std::string &msg);
 
    static bool EmbedFileDialog(const std::shared_ptr<RWebWindow> &window, unsigned connid, const std::string &args);
 };
 
 } // namespace ROOT
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team