ComputeThread.hh

Go to the documentation of this file.

 
#pragma once
 
#include <signal.h>
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>
#include <websocketpp/common/thread.hpp>
#include <websocketpp/common/functional.hpp>
#include <thread>
#include <set>
#include <glibmm/spawn.h>
 
typedef websocketpp::client<websocketpp::config::asio_client> WSClient;
typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
typedef websocketpp::lib::lock_guard<websocketpp::lib::mutex> scoped_lock;
 
#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);
 
            void execute_interactive(uint64_t id, const std::string& code);
 
 
            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).
 
            // FIXME: moving this away into documentthread, so that we only need to refer to id's.
            std::map<DataCell::id_t, DTree::iterator> running_cells;
 
            // WebSocket++ things.
            WSClient wsclient;
            bool     connection_is_open, restarting_kernel;
            WSClient::connection_ptr    connection;
            websocketpp::connection_hdl our_connection_hdl;
            void init();
            void try_connect();
            void try_spawn_server();
            void on_open(websocketpp::connection_hdl hdl);
            void on_fail(websocketpp::connection_hdl hdl);
            void on_close(websocketpp::connection_hdl hdl);
            void on_message(websocketpp::connection_hdl hdl, message_ptr 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;
        };
 
    }