Server.hh

Go to the documentation of this file.

#pragma once

#include <string>
#include <boost/uuid/uuid.hpp>
#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/common/functional.hpp>
#include <future>
#include <boost/python.hpp>

#include "Stopwatch.hh"
#include "ProgressMonitor.hh"


class Server : public ProgressMonitor {
    public:
        Server();
        Server(const Server&)=delete;
        Server(const std::string& socket);
        ~Server();

        void run();



        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;

    private:
        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).

        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;

        // 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;
        void wait_for_job();

        // Data and connection info for a single block of code.
        class Block {
            public:
                Block(websocketpp::connection_hdl, const std::string&, uint64_t id);
                websocketpp::connection_hdl hdl; // FIXME: decouple from websocket?
                std::string                 input;
                std::string                 output;
                std::string                 error;
                uint64_t                    cell_id;
        };
        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);


        void                     on_block_finished(Block);
        void                     on_block_error(Block);
        void                     on_kernel_fault(Block);

        std::string              architecture() const;
        
        bool handles(const std::string& otype) const;
            
        
        uint64_t                 send(const std::string& output, const std::string& msg_type, uint64_t parent_id=0, bool last_in_sequence=false);
        void                     send_json(const std::string&);

        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.
        boost::python::object main_module;
        boost::python::object main_namespace;

        int cells_ran;
};