RestHandler Class Reference

The RESTful API handler. More...

#include <RestHandler.h>

Collaboration diagram for RestHandler:

Classes
class	ChannelInfo
	RX Info pertaining to an SCH (MCCH/MCH or PDSCH) More...

Public Types
typedef std::function< void(const std::string &antenna, unsigned fcen, double gain, unsigned sample_rate, unsigned bandwidth)>	set_params_t
	Definition of the callback for setting new reception parameters. More...

Public Member Functions
	RestHandler (const libconfig::Config &cfg, const std::string &url, state_t &state, SdrReader &sdr, Phy &phy, set_params_t set_params)
	Default constructor. More...
virtual	~RestHandler ()
	Default destructor. More...
float	cinr_db ()
	Current CINR value. More...
void	add_cinr_value (float cinr)

Public Attributes
std::vector< uint8_t >	_ce_values = {}
	Time domain subcarrier CE values. More...
ChannelInfo	_pdsch
	RX info for PDSCH. More...
ChannelInfo	_mcch
	RX info for MCCH. More...
std::map< uint32_t, ChannelInfo >	_mch
	RX info for MCHs. More...

Private Member Functions
void	get (web::http::http_request message)
void	put (web::http::http_request message)

Private Attributes
std::vector< float >	_cinr_db
const libconfig::Config &	_cfg
std::unique_ptr< web::http::experimental::listener::http_listener >	_listener
state_t &	_state
SdrReader &	_sdr
Phy &	_phy
set_params_t	_set_params
bool	_require_bearer_token = false
std::string	_api_key

Detailed Description

The RESTful API handler.

Supports GET and PUT verbs for SDR parameters, and GET for reception info

Definition at line 44 of file RestHandler.h.

Member Typedef Documentation

set_params_t

typedef std::function<void(const std::string& antenna, unsigned fcen, double gain, unsigned sample_rate, unsigned bandwidth)> RestHandler::set_params_t

Definition of the callback for setting new reception parameters.

Definition at line 49 of file RestHandler.h.

Constructor & Destructor Documentation

RestHandler()

RestHandler::RestHandler	(	const libconfig::Config &	cfg,
		const std::string &	url,
		state_t &	state,
		SdrReader &	sdr,
		Phy &	phy,
		set_params_t	set_params
	)

Default constructor.

Parameters

cfg	Config singleton reference
url	URL to open the server on
state	Reference to the main loop sate
sdr	Reference to the SDR reader
set_params	Set parameters callback

Definition at line 35 of file RestHandler.cpp.

    : _cfg(cfg),
      _state(state),
      _sdr(sdr),
      _phy(phy),
      _set_params(std::move(set_params)) {
 
  http_listener_config server_config;
  if (url.rfind("https", 0) == 0) {
    server_config.set_ssl_context_callback(
        [&](boost::asio::ssl::context& ctx) {
          std::string cert_file = "/usr/share/5gmag-rt/cert.pem";
          cfg.lookupValue("modem.restful_api.cert", cert_file);
 
          std::string key_file = "/usr/share/5gmag-rt/key.pem";
          cfg.lookupValue("modem.restful_api.key", key_file);
 
          ctx.set_options(boost::asio::ssl::context::default_workarounds);
          ctx.use_certificate_chain_file(cert_file);
          ctx.use_private_key_file(key_file, boost::asio::ssl::context::pem);
        });
  }
 
  cfg.lookupValue("modem.restful_api.api_key.enabled", _require_bearer_token);
  if (_require_bearer_token) {
    _api_key = "106cd60-76c8-4c37-944c-df21aa690c1e";
    cfg.lookupValue("modem.restful_api.api_key.key", _api_key);
  }
 
  _listener = std::make_unique<http_listener>(
      url, server_config);
 
  _listener->support(methods::GET, std::bind(&RestHandler::get, this, std::placeholders::_1));  // NOLINT
  _listener->support(methods::PUT, std::bind(&RestHandler::put, this, std::placeholders::_1));  // NOLINT
 
  _listener->open().wait();
}

~RestHandler()

RestHandler::~RestHandler ( )

virtualdefault

Default destructor.

Member Function Documentation

add_cinr_value()

void RestHandler::add_cinr_value

(

float

cinr

)

Definition at line 234 of file RestHandler.cpp.

                                            {
  if (_cinr_db.size() > CINR_RAVG_CNT) {
    _cinr_db.erase(_cinr_db.begin());
  }
  _cinr_db.push_back(cinr);
}

cinr_db()

float RestHandler::cinr_db ( )

inline

Current CINR value.

Definition at line 113 of file RestHandler.h.

{ return _cinr_db.size() ? (std::accumulate(_cinr_db.begin(), _cinr_db.end(), 0) / (_cinr_db.size() * 1.0)) : 0.0; };

get()

void RestHandler::get ( web::http::http_request  message )

private

Definition at line 77 of file RestHandler.cpp.

                                          {
  spdlog::debug("Received GET request {}", message.to_string() );
  auto paths = uri::split_path(uri::decode(message.relative_uri().path()));
  if (_require_bearer_token &&
    (message.headers()["Authorization"] != "Bearer " + _api_key)) {
    message.reply(status_codes::Unauthorized);
    return;
  }
 
  if (paths.empty()) {
    message.reply(status_codes::NotFound);
  } else {
    if (paths[0] == "status") {
      auto state = value::object();
 
      switch (_state) {
        case searching:
          state["state"] = value::string("searching");
          break;
        case syncing:
          state["state"] = value::string("syncing");
          break;
        case processing:
          state["state"] = value::string("synchronized");
          break;
      }
 
      if (_phy.cell().nof_prb == _phy.cell().mbsfn_prb) {
        state["nof_prb"] = value(_phy.cell().nof_prb);
      } else {
        state["nof_prb"] = value(_phy.cell().mbsfn_prb);
      }
      state["cell_id"] = value(_phy.cell().id);
      state["cfo"] = value(_phy.cfo());
      state["cinr_db"] = value(cinr_db());
      state["subcarrier_spacing"] = value(_phy.mbsfn_subcarrier_spacing_khz());
      message.reply(status_codes::OK, state);
    } else if (paths[0] == "sdr_params") {
      value sdr = value::object();
      sdr["frequency"] = value(_sdr.get_frequency());
      sdr["gain"] = value(_sdr.get_gain());
      sdr["min_gain"] = value(_sdr.min_gain());
      sdr["max_gain"] = value(_sdr.max_gain());
      sdr["filter_bw"] = value(_sdr.get_filter_bw());
      sdr["antenna"] = value(_sdr.get_antenna());
      sdr["sample_rate"] = value(_sdr.get_sample_rate());
      sdr["buffer_level"] = value(_sdr.get_buffer_level());
      message.reply(status_codes::OK, sdr);
    } else if (paths[0] == "ce_values") {
      auto cestream = Concurrency::streams::bytestream::open_istream(_ce_values);
      message.reply(status_codes::OK, cestream);
    } else if (paths[0] == "pdsch_status") {
      value sdr = value::object();
      sdr["bler"] = value(static_cast<float>(_pdsch.errors) /
                                static_cast<float>(_pdsch.total));
      sdr["ber"] = value(_pdsch.ber);
      sdr["mcs"] = value(_pdsch.mcs);
      sdr["present"] = 1;
      message.reply(status_codes::OK, sdr);
    } else if (paths[0] == "pdsch_data") {
      auto cestream = Concurrency::streams::bytestream::open_istream(_pdsch.GetData());
      message.reply(status_codes::OK, cestream);
    } else if (paths[0] == "mcch_status") {
      value sdr = value::object();
      sdr["bler"] = value(static_cast<float>(_mcch.errors) /
                                static_cast<float>(_mcch.total));
      sdr["ber"] = value(_mcch.ber);
      sdr["mcs"] = value(_mcch.mcs);
      sdr["present"] = 1;
      message.reply(status_codes::OK, sdr);
    } else if (paths[0] == "mcch_data") {
      auto cestream = Concurrency::streams::bytestream::open_istream(_mcch.GetData());
      message.reply(status_codes::OK, cestream);
    } else if (paths[0] == "mch_info") {
      std::vector<value> mi;
      auto mch_info = _phy.mch_info();
      std::for_each(std::begin(mch_info), std::end(mch_info), [&mi](Phy::mch_info_t const& mch) {
          value m;
          m["mcs"] = value(mch.mcs);
          std::vector<value> mti;
          std::for_each(std::begin(mch.mtchs), std::end(mch.mtchs), [&mti](Phy::mtch_info_t const& mtch) {
              value mt;
              mt["tmgi"] = value(mtch.tmgi);
              mt["dest"] = value(mtch.dest);
              mt["lcid"] = value(mtch.lcid);
              mti.push_back(mt);
          });
          m["mtchs"] = value::array(mti);
          mi.push_back(m);
      });
      message.reply(status_codes::OK, value::array(mi));
    } else if (paths[0] == "mch_status") {
      int idx = std::stoi(paths[1]);
      value sdr = value::object();
      sdr["bler"] = value(static_cast<float>(_mch[idx].errors) /
                                static_cast<float>(_mch[idx].total));
      sdr["ber"] = value(_mch[idx].ber);
      sdr["mcs"] = value(_mch[idx].mcs);
      sdr["present"] = value(_mch[idx].present);
      message.reply(status_codes::OK, sdr);
    } else if (paths[0] == "mch_data") {
      int idx = std::stoi(paths[1]);
      auto cestream = Concurrency::streams::bytestream::open_istream(_mch[idx].GetData());
      message.reply(status_codes::OK, cestream);
    } else if (paths[0] == "log") {
      std::string logfile = "/var/log/syslog";
 
      Concurrency::streams::file_stream<uint8_t>::open_istream(logfile).then(
          [message](const Concurrency::streams::basic_istream<unsigned char>&
                        file_stream) {
            message.reply(status_codes::OK, file_stream, "text/plain");
          });
    }
  }
}

put()

void RestHandler::put ( web::http::http_request  message )

private

Definition at line 193 of file RestHandler.cpp.

                                          {
  spdlog::debug("Received PUT request {}", message.to_string() );
 
  if (_require_bearer_token &&
    (message.headers()["Authorization"] != "Bearer " + _api_key)) {
    message.reply(status_codes::Unauthorized);
    return;
  }
 
  auto paths = uri::split_path(uri::decode(message.relative_uri().path()));
  if (paths.empty()) {
    message.reply(status_codes::NotFound);
  } else {
    if (paths[0] == "sdr_params") {
      value answer;
 
      auto f = _sdr.get_frequency();
      auto g = _sdr.get_gain();
      auto bw = _sdr.get_filter_bw();
      auto a = _sdr.get_antenna();
      auto sr = _sdr.get_sample_rate();
 
      const auto & jval = message.extract_json().get();
      spdlog::debug("Received JSON: {}", jval.serialize());
 
      if (jval.has_field("antenna")) {
        a = jval.at("antenna").as_string();
      }
      if (jval.has_field("frequency")) {
        f = jval.at("frequency").as_integer();
      }
      if (jval.has_field("gain")) {
        g = jval.at("gain").as_double();
      }
      _set_params( a, f, g, sr, bw);
 
      message.reply(status_codes::OK, answer);
    }
  }
}

Member Data Documentation

_api_key

std::string RestHandler::_api_key

private

Definition at line 132 of file RestHandler.h.

_ce_values

std::vector<uint8_t> RestHandler::_ce_values = {}

Time domain subcarrier CE values.

Definition at line 93 of file RestHandler.h.

_cfg

const libconfig::Config& RestHandler::_cfg

private

Definition at line 121 of file RestHandler.h.

_cinr_db

std::vector<float> RestHandler::_cinr_db

private

Definition at line 117 of file RestHandler.h.

_listener

std::unique_ptr<web::http::experimental::listener::http_listener> RestHandler::_listener

private

Definition at line 123 of file RestHandler.h.

_mcch

ChannelInfo RestHandler::_mcch

RX info for MCCH.

Definition at line 103 of file RestHandler.h.

_mch

std::map<uint32_t, ChannelInfo> RestHandler::_mch

RX info for MCHs.

Definition at line 108 of file RestHandler.h.

_pdsch

ChannelInfo RestHandler::_pdsch

RX info for PDSCH.

Definition at line 98 of file RestHandler.h.

_phy

Phy& RestHandler::_phy

private

Definition at line 127 of file RestHandler.h.

_require_bearer_token

bool RestHandler::_require_bearer_token = false

private

Definition at line 131 of file RestHandler.h.

_sdr

SdrReader& RestHandler::_sdr

private

Definition at line 126 of file RestHandler.h.

_set_params

set_params_t RestHandler::_set_params

private

Definition at line 129 of file RestHandler.h.

_state

state_t& RestHandler::_state

private

Definition at line 125 of file RestHandler.h.

---

The documentation for this class was generated from the following files:

• src/RestHandler.h
• src/RestHandler.cpp