Server.hh

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <set>
#include <deque>
#include <signal.h>
#include <boost/uuid/uuid.hpp>
#include <future>
#include <pybind11/pybind11.h>
#include <pybind11/embed.h>
#include "nlohmann/json.hpp"
#include "websocket_server.hh"
 
#include "Stopwatch.hh"
 
 
class Server {
    public:
        Server();
        Server(const Server&)=delete;
        Server(const std::string& socket);
        virtual ~Server();
 
 
        void run(int port=0, bool exit_on_disconnect=true);
 
 
 
        class CatchOutput {
            public:
                CatchOutput();
                CatchOutput(const CatchOutput&);
 
                void        write(const std::string& txt);
                void        clear();
                std::string str() const;
            private:
                std::string collect;
            };
 
        CatchOutput catchOut, catchErr;
 
        Stopwatch server_stopwatch;
        Stopwatch sympy_stopwatch;
 
 
        virtual uint64_t         send(const std::string& output, const std::string& msg_type,
                                                uint64_t parent_id=0, uint64_t cell_id=0, bool last_in_sequence=false);
 
        void                     send_progress_update(const std::string& msg, int n, int total);
        void                     send_json(const std::string&);
 
        bool                     handles(const std::string& otype) const;
        std::string              architecture() const;
 
        void wait_for_job();
 
        void wait_for_websocket();
 
    protected:
        void init();
 
        // WebSocket++ dependent parts below.
        void on_message(websocket_server::id_type id, const std::string& msg,
                             const websocket_server::request_type& req, const std::string& ip_address);
        void on_open(websocket_server::id_type id);
        void on_close(websocket_server::id_type id);
        websocket_server wserver;
 
        // Connection tracking.  There can be multiple connections to
        // the server, but they all have access to the same Python
        // scope. With multiple connections, one can inspect the Python
        // stack from a different client (e.g. for debugging purposes).
        // All connections share the same authentication token.
 
        class Connection {
            public:
                Connection();
 
                websocket_server::id_type ws_id;
                boost::uuids::uuid        uuid;
            };
        typedef std::map<websocket_server::id_type, Connection> ConnectionMap;
        ConnectionMap connections;
        
        // Authentication token, needs to be sent along with any message.
        // Gets set when the server announces its port.
        std::string  authentication_token;
 
        // Mutex to be able to use the websocket layer from both the
        // main loop and the python-running thread.
        std::mutex ws_mutex;
 
 
        // Basics for the working thread that processes blocks.
        std::thread             runner;
        std::mutex              block_available_mutex;
        std::condition_variable block_available;
        bool                    exit_on_disconnect;
        int                     run_on_port;
        unsigned long           main_thread_id;
 
        // Data and connection info for a single block of code.
        class Block {
            public:
                Block();
                Block(websocket_server::id_type, const std::string&, uint64_t id, const std::string& msg_type);
                
                websocket_server::id_type   ws_id; // FIXME: decouple from websocket?
                std::string                 msg_type;
                std::string                 input;
                std::string                 output;
                std::string                 error;
                uint64_t                    cell_id;
                std::set<std::string>       variables;
                std::set<std::string>       remove_variable_assignments;
 
                // When a cell is re-run on variable change, we re-use the output cells of the
                // previous run. The IDs of these cells are sent to us by the frontend. We
                // store them here, and then pop them off the front for each call to `send`.
 
                std::deque<uint64_t>        reuse_output_cell_ids; 
 
                // Response message, partially filled in when the
                // request comes in.
 
                nlohmann::json              response;
            };
        std::queue<Block>           block_queue;
        Block                       current_block;
        websocket_server::id_type   current_ws_id;
        uint64_t                    current_id;    // id of the block given to us by the client.
 
        // Run a piece of Python code. This is called from a separate
        // thread constructed by on_message().
        std::string              run_string(const std::string&,
                                                        bool handle_output=true,
                                                        bool extract_variables=false,
                                                        std::set<std::string> remove_variable_assignments=std::set<std::string>());
 
        std::set<std::string> run_string_variables;
 
 
        virtual void             on_block_finished(Block);
        virtual void             on_block_error(Block);
        virtual void             on_kernel_fault(Block);
 
 
        void                     stop_block();
        bool                     started;
        std::future<std::string> job;
 
 
        void dispatch_message(websocket_server::id_type, const std::string& json_string);
 
        // Python global info.
        pybind11::scoped_interpreter guard;
        pybind11::module             main_module;
        pybind11::object             main_namespace;
    };