rest_server.h

 
/***************************************************************************
 *   Copyright (C) 2022 David Register                                     *
 *   Copyright (C) 2022-2023  Alec Leamas                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,  USA.         *
 **************************************************************************/
 
#ifndef RESTSERVER_H_
#define RESTSERVER_H_
 
#include <atomic>
#include <condition_variable>
#include <fstream>
#include <functional>
#include <string>
#include <thread>
#include <unordered_map>
 
#include "observable_evtvar.h"
 
 
// MacOS 1.13:
#if (defined(OCPN_GHC_FILESYSTEM) || (defined(__clang_major__) && (__clang_major__ < 15)))
#include <ghc/filesystem.hpp>
namespace fs = ghc::filesystem;
 
#else
#include <filesystem>
#include <utility>
namespace fs = std::filesystem;
#endif
 
#include <wx/event.h>
#include <wx/string.h>
#include <wx/thread.h>  // for wxSemaphore, std::semaphore is c++20
 
#include "pugixml.hpp"
#include "pincode.h"
#include "route.h"
#include "track.h"
 
enum class RestServerResult {
  NoError = 0,
  GenericError = 1,
  ObjectRejected = 2,
  DuplicateRejected = 3,
  RouteInsertError = 4,
  NewPinRequested = 5,
  ObjectParseError = 6,
  Void = 100
};
 
enum { ID_STG_CANCEL = 10000, ID_STG_OK, ID_STG_CHECK1, ID_STG_CHOICE_COMM };
 
std::string RestResultText(RestServerResult result);
 
struct RestIoEvtData;
 
struct AcceptObjectDlgResult {
  const int status;         
  const bool check1_value;  
 
  AcceptObjectDlgResult() : status(0), check1_value(false) {}
 
  AcceptObjectDlgResult(int s, bool b) : status(s), check1_value(b) {}
};
 
class RestServerDlgCtx {
public:
  std::function<wxDialog*(const std::string& msg, const std::string& text1)>
      run_pincode_dlg;
 
  std::function<void(void)> update_route_mgr;
 
  std::function<AcceptObjectDlgResult(const wxString& msg,
                                      const wxString& check1msg)>
      run_accept_object_dlg;
  std::function<void()> top_level_refresh;
 
  RestServerDlgCtx();
};
 
class RouteCtx {
public:
  std::function<Route*(wxString)> find_route_by_guid;
  std::function<Track*(wxString)> find_track_by_guid;
  std::function<RoutePoint*(wxString)> find_wpt_by_guid;
  std::function<void(Route*)> delete_route;
  std::function<void(Track*)> delete_track;
  std::function<void(RoutePoint*)> delete_waypoint;
 
  RouteCtx();
};
 
class AbstractRestServer {
 
public:
  virtual bool StartServer(const fs::path& certificate_location) = 0;
 
  virtual void StopServer() = 0;
 
  virtual std::string GetEndpoint() = 0;
 
  EventVar activate_route;
 
  EventVar reverse_route;
};
 
class RestServer : public AbstractRestServer, public wxEvtHandler {
  friend class RestServerObjectApp;  
  friend class RestCheckWriteApp;    
  friend class RestServerPingApp;    
  friend class RestPluginMsgApp;     
 
public:
  RestServer(RestServerDlgCtx ctx, RouteCtx route_ctx, bool& portable);
 
  ~RestServer() override;
 
  bool StartServer(const fs::path& certificate_location) override;
 
  void StopServer() override;
 
  std::string GetEndpoint() override { return m_endpoint; }
 
  void UpdateReturnStatus(RestServerResult r);
 
  RestServerResult GetReturnStatus() { return return_status; }
 
  void UpdateRouteMgr() const { m_dlg_ctx.update_route_mgr(); }
 
  std::string m_cert_file;
 
  std::string m_key_file;
 
  std::string m_reply_body;
 
  std::mutex ret_mutex;
 
  std::condition_variable return_status_cv;
 
  wxSemaphore m_exit_sem;
 
  const std::string m_endpoint;
 
private:
  class IoThread {
  public:
    IoThread(RestServer& parent, std::string ip);
    virtual ~IoThread() = default;
    void Run();
 
    bool IsRunning() { return run_flag > 0; }
 
    void Stop();
 
    bool WaitUntilStopped();
 
  private:
    std::atomic_int run_flag;
    RestServer& m_parent;
    std::string m_server_ip;
  };
 
  class Apikeys : public std::unordered_map<std::string, std::string> {
  public:
    static Apikeys Parse(const std::string& s);
    std::string ToString() const;
  };
 
  bool LoadConfig();
  bool SaveConfig();
 
  void HandleServerMessage(ObservedEvt& event);
 
  void HandleWaypoint(pugi::xml_node object, const RestIoEvtData& evt_data);
  void HandleTrack(pugi::xml_node object, const RestIoEvtData& evt_data);
  void HandleRoute(pugi::xml_node object, const RestIoEvtData& evt_data);
 
  bool CheckApiKey(const RestIoEvtData& evt_data);
 
  RestServerDlgCtx m_dlg_ctx;
  RouteCtx m_route_ctx;
 
  RestServerResult return_status;
 
  std::string m_certificate_directory;
  Apikeys m_key_map;
  wxDialog* m_pin_dialog;
 
  bool m_overwrite;
  std::string m_upload_path;
  std::ofstream m_ul_stream;
  std::thread m_std_thread;
  IoThread m_io_thread;
  Pincode m_pincode;
};
 
#endif  // guard