ComputeThread.hh

Go to the documentation of this file.

 
#pragma once
 
#include <signal.h>
#include <thread>
#include <set>
#include <glibmm/spawn.h>
#include "websocket_client.hh"
 
#include "DataCell.hh"
 
namespace cadabra {
 
    class GUIBase;
    class DocumentThread;
 
 
    class ComputeThread {
        public:
 
            ComputeThread(int server_port=0, std::string token="", std::string ip_address="127.0.0.1");
            ComputeThread(const ComputeThread& )=delete; // You cannot copy this object
            ~ComputeThread();
 
            void set_master(GUIBase *, DocumentThread *);
 
 
            void run();
 
 
            void execute_cell(DTree::iterator, std::string no_assign="",
                                    std::vector<uint64_t> output_cell_ids=std::vector<uint64_t>() );
 
            void execute_interactive(uint64_t id, const std::string& code);
 
 
            void update_variable_on_server(std::string variable, double value);
            
 
            void stop();
 
 
            void restart_kernel();
 
 
            bool complete(DTree::iterator, int pos, int alternative);
 
            // Determine if there are still cells running on the server.
            // FIXME: this does not guarantee thread-safety but at the moment
            // is only used for updating status bars etc.
            // FIXME: can be moved to DocumentThread.
 
            int number_of_cells_executing(void) const;
 
 
            void terminate();
 
            bool kernel_is_connected() const;
            
        private:
            GUIBase        *gui;
            DocumentThread *docthread;
 
            // For debugging purposes, we keep record of the gui thread id,
            // so that we can flag when code runs on the wrong thread.
            // Gets initialised in the ComputeThread constructor.
            std::thread::id  gui_thread_id;
 
            // Keeping track of cells which are running on the server, in
            // a form which allows us to look them up quickly based only
            // on the id (which is all that the server knows about). A
            // cell can be queued multiple times for running; this is the
            // integer in the map.
 
            std::map<DataCell::id_t, int> running_cells;
 
            // WebSocket++ things.
            websocket_client            wsclient;
            bool                        connection_is_open, restarting_kernel;
 
            void init();
            void try_connect();
            void try_spawn_server();
            void on_open();
            void on_fail(const boost::beast::error_code&);
            void on_close();
            void on_message(const std::string& msg);
 
            void cell_finished_running(DataCell::id_t);
 
            void all_cells_nonrunning();
 
            std::set<uint64_t> interactive_cells;
 
            // Self-started server
            Glib::Pid       server_pid;
            int             server_stdout, server_stderr;
            unsigned short  port;
            std::string     authentication_token;
            int             forced_server_port;
            std::string     forced_server_token;
            std::string     forced_server_ip_address;
        };
 
    }