server.h

Go to the documentation of this file.

#pragma once
 
#include <ixwebsocket/IXConnectionState.h>
#include <ixwebsocket/IXWebSocket.h>
#include <readerwriterqueue/readerwriterqueue.h>
 
#include <atomic>
#include <chrono>
#include <thread>
#include <zmq.hpp>
 
#include "incoming_machine_message.h"
#include "outgoing_machine_message.h"
 
class Server {
 public:
  Server(moodycamel::ReaderWriterQueue<IncomingMachineMessage>
             &incoming_machine_message_queue,
         moodycamel::ReaderWriterQueue<OutgoingMachineMessage>
             &outgoing_machine_message_queue);
  ~Server();
 
  void start();
 
  void stop();
 
  void wait();
 
  /******************** CUSTOM WS CONNECTION STATE CLASS ********************/
  class MotionMasterConnectionState : public ix::ConnectionState {
   public:
    MotionMasterConnectionState() : ConnectionState() {}
 
    std::string getClientId() { return client_id_; }
 
    bool setClientId(const std::string &client_id) {
      if (client_id_.empty()) {
        client_id_ = client_id;
        return true;
      } else {
        return false;
      }
    }
 
    static std::shared_ptr<ConnectionState>
    createMotionMasterConnectionState() {
      return std::make_shared<MotionMasterConnectionState>();
    }
 
   protected:
    std::string client_id_;
  };
 
 private:
  zmq::context_t context_;
 
  zmq::socket_t frontend_socket_;
  zmq::socket_t forwarder_frontend_socket_;
 
  std::unique_ptr<std::thread> server_thread_;
  std::atomic_bool running_;
 
  moodycamel::ReaderWriterQueue<IncomingMachineMessage>
      &incoming_machine_message_queue_;
  moodycamel::ReaderWriterQueue<OutgoingMachineMessage>
      &outgoing_machine_message_queue_;
 
  // WebSockets
  std::unordered_map<std::string /* client ID */,
                     std::shared_ptr<ix::WebSocket>>
      dealer_ws_client_map_;
  std::unordered_map<std::string /* client ID */,
                     std::shared_ptr<ix::WebSocket>>
      sub_ws_client_map_;
 
  std::unordered_map<std::string /* client ID */,
                     moodycamel::ReaderWriterQueue<IncomingMachineMessage>>
      dealer_ws_incoming_message_map_;
 
  std::unordered_map<std::string /* topic */,
                     std::vector<std::string> /* client IDs */>
      topic_to_client_ids_map_;
 
  std::unordered_map<std::string /* request message ID */,
                     std::string /* topic */>
      request_id_to_topic_map_;
 
  std::mutex mutex_;
 
  void run();
 
  void dealer_ws_close_clean_up(const std::string &client_id);
 
  void sub_ws_close_clean_up(const std::string &client_id);
 
  void ws_clean_up();
 
  void send_outgoing_messages();
};