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...
void	start ()
	Start function for the listener. More...
float	cinr_db ()
	Current instantaneous CINR value. More...
float	cinr_db_avg ()
	Current average CINR value. More...
void	add_cinr_value (float cinr)
void	set_cas_processor (CasFrameProcessor *cas_processor)
	Save the pointer to the CasFrameProcessor. More...
void	set_mbsfn_processor (MbsfnFrameProcessor *mbsfn_processor)
	Save the pointer to the vector cointaining the MbsfnFrameProcessors. More...

Public Attributes
std::vector< uint8_t >	_ce_values = {}
	Time domain subcarrier CE values. More...
std::vector< uint8_t >	_cir_values = {}
	Time domain channel impulse response of the CAS. More...
std::vector< uint8_t >	_cir_values_mbsfn = {}
	Time domain channel impulse response of the mbsfn subframes. More...
std::vector< uint8_t >	_corr_values = {}
	Correlaton samples from the sync functions. More...
std::vector< uint8_t >	_corr_values_mbsfn = {}
	Correlaton samples from the sync functions. 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
CasFrameProcessor *	_cas_processor
std::vector< MbsfnFrameProcessor * >	_mbsfn_processors
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 47 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 52 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 36 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 371 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 instantaneous CINR value.

Definition at line 144 of file RestHandler.h.

{ return _cinr_db.size() ? _cinr_db.back() : 0.0f; };

cinr_db_avg()

float RestHandler::cinr_db_avg ( )

inline

Current average CINR value.

Definition at line 149 of file RestHandler.h.

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

get()

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

private

Definition at line 78 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["cinr_db_avg"] = value(cinr_db_avg());
      state["subcarrier_spacing"] = value(_phy.mbsfn_subcarrier_spacing_khz());
 
      // CAS Chest params //
      state["filter_order"] = value(_cas_processor->get_filter_order());
      state["filter_coef"] = value(_cas_processor->get_filter_coef());
      state["filter_type"] = value(_cas_processor->get_filter_type());
      state["noise_alg"] = value(_cas_processor->get_noise_alg());
      state["sync_error"] = value(_cas_processor->get_sync_error());
      state["estimator_alg"] = value(_cas_processor->get_estimator_alg());
      state["cfo_estimate"] = value(_cas_processor->get_cfo_estimate());
      state["evm_meas"] = value(_cas_processor->get_evm_meas());
      
      // Phy params // 
      state["cfo_est_pss_find"] = value(_phy.get_ue_sync_find_cfo_pss_enable());
      state["cfo_est_pss_track"] = value(_phy.get_ue_sync_track_cfo_pss_enable());
      state["cfo_correct_find"] = value(_phy.get_ue_sync_find_cfo_correct_enable());
      state["cfo_correct_track"] = value(_phy.get_ue_sync_track_cfo_correct_enable());
      state["cfo_pss_loop_bw"] = value(_phy.get_ue_sync_cfo_loop_bw_pss());
      state["cfo_ema_alpha_find"] = value(_phy.get_ue_sync_find_cfo_ema());
      state["cfo_ema_alpha_track"] = value(_phy.get_ue_sync_track_cfo_ema());
      state["pss_ema_find"] = value(_phy.get_ue_sync_pss_cfo_ema_find());
      state["pss_ema_track"] = value(_phy.get_ue_sync_pss_cfo_ema_track());
      state["threshold_find"] = value(_phy.get_ue_sync_threshold_find());
      state["threshold_track"] = value(_phy.get_ue_sync_threshold_track());
 
 
      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] == "cir_values") {
      auto cestream = Concurrency::streams::bytestream::open_istream(_cir_values);
      message.reply(status_codes::OK, cestream);
    } else if (paths[0] == "cir_values_mbsfn") {
      auto cestream = Concurrency::streams::bytestream::open_istream(_cir_values_mbsfn);
      message.reply(status_codes::OK, cestream);
    } else if (paths[0] == "corr_values") {
      auto cestream = Concurrency::streams::bytestream::open_istream(_corr_values);
      message.reply(status_codes::OK, cestream);
    } else if (paths[0] == "corr_values_mbsfn") {
      auto cestream = Concurrency::streams::bytestream::open_istream(_corr_values_mbsfn);
      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 232 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);
    } else if (paths[0] == "chest_cfg_params") {
      value answer;
 
      const auto & jval = message.extract_json().get();
      spdlog::debug("Recieved JSON: {}", jval.serialize());
 
      if (jval.has_field("noise_alg")) {
        auto alg = jval.at("noise_alg").as_string();
        spdlog::info("New alg est {}", alg);
        _cas_processor->set_noise_alg(static_cast<srsran_chest_dl_noise_alg_t>(stoi(alg)));
      }
      if (jval.has_field("sync_error")) {
        spdlog::info("New sync error value");
        
        bool alg = jval.at("sync_error").as_bool();
 
        spdlog::info("{}", alg); 
        _cas_processor->set_sync_error(alg);
      }
      if (jval.has_field("estimator_alg")) {
        auto alg = jval.at("estimator_alg").as_string();
        spdlog::info("New alg est {}", alg);
        _cas_processor->set_estimator_alg(static_cast<srsran_chest_dl_estimator_alg_t>(stoi(alg)));
      }
      if (jval.has_field("filter_type")) {
        auto type = jval.at("filter_type").as_string();
        spdlog::info("New filter type {}", type);
        _cas_processor->set_filter_type(static_cast<srsran_chest_filter_t>(stoi(type)));
      }
      if (jval.has_field("filter_order")) {
        spdlog::info("New filter order");
        auto order = jval.at("filter_order").as_integer();
        _cas_processor->set_filter_order(order);
      }
      if (jval.has_field("filter_coef")) {
        spdlog::info("New filter coef");
        auto coef = jval.at("filter_coef").as_double();
        _cas_processor->set_filter_coef(coef);
      }
 
      // Phy params
      if (jval.has_field("cfo_est_pss_find")) {
        spdlog::info("New cfo est pss find");
        auto toggle = jval.at("cfo_est_pss_find").as_bool();
        _phy.set_ue_sync_find_cfo_pss_enable(toggle);
      }
      if (jval.has_field("cfo_est_pss_track")) {
        spdlog::info("New cfo est pss track");
        auto toggle = jval.at("cfo_est_pss_track").as_bool();
        _phy.set_ue_sync_track_cfo_pss_enable(toggle);
      }
      if (jval.has_field("cfo_correct_find")) {
        spdlog::info("New cfo correct find");
        auto toggle = jval.at("cfo_correct_find").as_bool();
        _phy.set_ue_sync_find_cfo_correct_enable(toggle);
      }
      if (jval.has_field("cfo_correct_track")) {
        spdlog::info("New cfo correct track");
        auto toggle = jval.at("cfo_correct_track").as_bool();
        _phy.set_ue_sync_track_cfo_correct_enable(toggle);
      }
      if (jval.has_field("cfo_pss_loop_bw")) {
        spdlog::info("New BW pss CFO loop");
        auto bw = jval.at("cfo_pss_loop_bw").as_double();
        _phy.set_ue_sync_cfo_loop_bw_pss(bw);
      }
      if (jval.has_field("cfo_ema_alpha_find")) {
        spdlog::info("New CFO ema alpha for find");
        auto ema = jval.at("cfo_ema_alpha_find").as_double();
        _phy.set_ue_sync_find_cfo_ema(ema);
      }
      if (jval.has_field("cfo_ema_alpha_track")) {
        spdlog::info("New CFO ema alpha for track");
        auto ema = jval.at("cfo_ema_alpha_track").as_double();
        _phy.set_ue_sync_track_cfo_ema(ema); 
      }
      if (jval.has_field("pss_ema_find")) {
        spdlog::info("New PSS corr  ema alpha for find");
        auto ema = jval.at("pss_ema_find").as_double();
        _phy.set_ue_sync_pss_cfo_ema_find(ema); 
      }
      if (jval.has_field("pss_ema_track")) {
        spdlog::info("New PSS corr  ema alpha for track");
        auto ema = jval.at("pss_ema_track").as_double();
        _phy.set_ue_sync_pss_cfo_ema_track(ema); 
      }
      if (jval.has_field("threshold_find")) {
        spdlog::info("New threshold for find");
        auto ema = jval.at("threshold_find").as_double();
        _phy.set_ue_sync_threshold_find(ema); 
      }
      if (jval.has_field("threshold_track")) {
        spdlog::info("New threshold for track");
        auto ema = jval.at("threshold_track").as_double();
        _phy.set_ue_sync_threshold_track(ema); 
      }
      
      message.reply(status_codes::OK, answer);
    }
  }
}

set_cas_processor()

void RestHandler::set_cas_processor ( CasFrameProcessor *  cas_processor )

inline

Save the pointer to the CasFrameProcessor.

Definition at line 156 of file RestHandler.h.

{ _cas_processor = cas_processor; };

set_mbsfn_processor()

void RestHandler::set_mbsfn_processor ( MbsfnFrameProcessor *  mbsfn_processor )

inline

Save the pointer to the vector cointaining the MbsfnFrameProcessors.

Definition at line 161 of file RestHandler.h.

{ _mbsfn_processors.push_back(mbsfn_processor); };

start()

void RestHandler::start ( )

inline

Start function for the listener.

Definition at line 73 of file RestHandler.h.

{ _listener->open().wait(); }

Member Data Documentation

_api_key

std::string RestHandler::_api_key

private

Definition at line 184 of file RestHandler.h.

_cas_processor

CasFrameProcessor* RestHandler::_cas_processor

private

Definition at line 166 of file RestHandler.h.

_ce_values

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

Time domain subcarrier CE values.

Definition at line 102 of file RestHandler.h.

_cfg

const libconfig::Config& RestHandler::_cfg

private

Definition at line 173 of file RestHandler.h.

_cinr_db

std::vector<float> RestHandler::_cinr_db

private

Definition at line 169 of file RestHandler.h.

_cir_values

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

Time domain channel impulse response of the CAS.

Definition at line 107 of file RestHandler.h.

_cir_values_mbsfn

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

Time domain channel impulse response of the mbsfn subframes.

Definition at line 112 of file RestHandler.h.

_corr_values

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

Correlaton samples from the sync functions.

Definition at line 118 of file RestHandler.h.

_corr_values_mbsfn

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

Correlaton samples from the sync functions.

Definition at line 124 of file RestHandler.h.

_listener

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

private

Definition at line 175 of file RestHandler.h.

_mbsfn_processors

std::vector<MbsfnFrameProcessor*> RestHandler::_mbsfn_processors

private

Definition at line 167 of file RestHandler.h.

_mcch

ChannelInfo RestHandler::_mcch

RX info for MCCH.

Definition at line 134 of file RestHandler.h.

_mch

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

RX info for MCHs.

Definition at line 139 of file RestHandler.h.

_pdsch

ChannelInfo RestHandler::_pdsch

RX info for PDSCH.

Definition at line 129 of file RestHandler.h.

_phy

Phy& RestHandler::_phy

private

Definition at line 179 of file RestHandler.h.

_require_bearer_token

bool RestHandler::_require_bearer_token = false

private

Definition at line 183 of file RestHandler.h.

_sdr

SdrReader& RestHandler::_sdr

private

Definition at line 178 of file RestHandler.h.

_set_params

set_params_t RestHandler::_set_params

private

Definition at line 181 of file RestHandler.h.

_state

state_t& RestHandler::_state

private

Definition at line 177 of file RestHandler.h.

---

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

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