Server.hh

Go to the documentation of this file.

 
#pragma once
 
#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/common/functional.hpp>
#include <string>
#include <signal.h>
#include <boost/uuid/uuid.hpp>
#include <future>
#include <pybind11/pybind11.h>
#include <pybind11/embed.h>
#include "nlohmann/json.hpp"
 
#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);
//      virtual void             send_completion(uint64_t id, int pos, int alternative, std::string original, std::string completed);
 
        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.
        typedef websocketpp::server<websocketpp::config::asio> WebsocketServer;
        void on_socket_init(websocketpp::connection_hdl hdl, boost::asio::ip::tcp::socket & s);
        void on_message(websocketpp::connection_hdl hdl, WebsocketServer::message_ptr msg);
        void on_open(websocketpp::connection_hdl hdl);
        void on_close(websocketpp::connection_hdl hdl);
        WebsocketServer wserver;
        std::string     socket_name;
 
        // 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();
 
                websocketpp::connection_hdl hdl;
                boost::uuids::uuid          uuid;
            };
        typedef std::map<websocketpp::connection_hdl, Connection,
                std::owner_less<websocketpp::connection_hdl>> 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(websocketpp::connection_hdl, const std::string&, uint64_t id, const std::string& msg_type);
                websocketpp::connection_hdl hdl; // FIXME: decouple from websocket?
                std::string                 msg_type;
                std::string                 input;
                std::string                 output;
                std::string                 error;
                uint64_t                    cell_id;
 
                // Response message, partially filled in when the
                // request comes in.
                nlohmann::json              response;
            };
        std::queue<Block>           block_queue;
        websocketpp::connection_hdl current_hdl;
        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);
 
 
        virtual void             on_block_finished(Block);
        virtual void             on_block_error(Block);
        virtual void             on_kernel_fault(Block);
 
//      uint64_t                 return_cell_id; // serial number of cells generated by us.
 
        void                     stop_block();
        bool                     started;
        std::future<std::string> job;
 
 
        void dispatch_message(websocketpp::connection_hdl, const std::string& json_string);
 
        // Python global info.
        pybind11::scoped_interpreter guard;
        pybind11::module             main_module;
        pybind11::object             main_namespace;
 
        //      int cells_ran;
    };