MBMS_RT::RestHandler Class Reference

The RESTful API handler. More...

#include <RestHandler.h>

Collaboration diagram for MBMS_RT::RestHandler:

Public Member Functions
	RestHandler (const libconfig::Config &cfg, const std::string &url, const CacheManagement &cache, const std::unique_ptr< MBMS_RT::ServiceAnnouncement > *service_announcement, const std::map< std::string, std::shared_ptr< MBMS_RT::Service >> &services)
	Default constructor. More...
virtual	~RestHandler ()
	Default destructor. More...

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

Private Attributes
const CacheManagement &	_cache
const libconfig::Config &	_cfg
const std::map< std::string, std::shared_ptr< Service > > &	_services
const std::unique_ptr< MBMS_RT::ServiceAnnouncement > *	_service_announcement_h = {}
unsigned	_total_cache_size
std::unique_ptr< web::http::experimental::listener::http_listener >	_listener
bool	_require_bearer_token = false
std::string	_api_key
std::string	_api_path

Detailed Description

The RESTful API handler.

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

Definition at line 42 of file RestHandler.h.

Constructor & Destructor Documentation

RestHandler()

MBMS_RT::RestHandler::RestHandler	(	const libconfig::Config &	cfg,
		const std::string &	url,
		const CacheManagement &	cache,
		const std::unique_ptr< MBMS_RT::ServiceAnnouncement > *	service_announcement,
		const std::map< std::string, std::shared_ptr< MBMS_RT::Service >> &	services
	)

Default constructor.

Parameters

cfg	Config singleton reference
url	URL to open the server on

Definition at line 35 of file RestHandler.cpp.

    : _cfg(cfg)
    , _services(services) 
    , _cache(cache)
    , _service_announcement_h(service_announcement)
{
  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("mw.http_server.cert", cert_file);
 
          std::string key_file = "/usr/share/5gmag-rt/key.pem";
          cfg.lookupValue("mw.http_server.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("mw.http_server.api_key.enabled", _require_bearer_token);
  if (_require_bearer_token) {
    _api_key = "106cd60-76c8-4c37-944c-df21aa690c1e";
    cfg.lookupValue("mw.http_server.api_key.key", _api_key);
  }
 
  _api_path = "mw-api";
  cfg.lookupValue("mw.http_server.api_path", _api_path);
 
  _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()

MBMS_RT::RestHandler::~RestHandler ( )

virtualdefault

Default destructor.

Member Function Documentation

get()

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

private

Definition at line 79 of file RestHandler.cpp.

                                                 {
  auto uri = message.relative_uri();
        spdlog::debug("request for  {}", uri.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] == _api_path) {
      if (paths[1] == "service_announcement") {
        if (*_service_announcement_h) {
          std::vector<value> items;
          for (const auto& item : (*_service_announcement_h)->items()) {
            if (item.content_type != "application/mbms-envelope+xml") {
              value i;
              i["location"] = value(item.uri);
              i["type"] = value(item.content_type);
              i["valid_from"] = value(item.valid_from);
              i["valid_until"] = value(item.valid_until);
              i["version"] = value(item.version);
              i["content"] = value(item.content);
              items.push_back(i);
            }
          }
          value sa;
          sa["id"] = value((*_service_announcement_h)->toi());
          sa["content"] = value((*_service_announcement_h)->content());
          sa["items"] = value::array(items);
          message.reply(status_codes::OK, sa);
          return;
        } else {
          message.reply(status_codes::NotFound);
          return;
        }
      } else if (paths[1] == "files") {
        std::vector<value> files;
        for (const auto& item : _cache.item_map()) {
          value f;
          f["source"] = value(item.second->item_source_as_string());
          f["location"] = value(item.second->content_location());
          f["content_length"] = value(item.second->content_length());
          f["received_at"] = value(item.second->received_at());
          if (item.second->received_at() == 0) {
            f["age"] = value(10000);
          } else {
            f["age"] = value(time(nullptr) - item.second->received_at());
          }
          files.push_back(f);
        }
        message.reply(status_codes::OK, value::array(files));
        return;
      } else if (paths[1] == "services") {
        std::vector<value> services;
        for (const auto& service : _services) {
          auto s = service.second;
          value ser;
 
          std::vector<value> names;
          for (const auto& name : s->names()) {
            value n;
            n["lang"] = value(name.first);
            n["name"] = value(name.second);
            names.push_back(n);
          }
          ser["names"] = value::array(names);
          ser["protocol"] = value(s->delivery_protocol_string());
          ser["manifest_path"] = value(s->manifest_path());
 
          std::vector<value> streams;
          for (const auto& stream : s->content_streams()) {
            value s;
            s["base"] = value(stream.second->base());
            s["type"] = value(stream.second->stream_type_string());
            s["flute_info"] = value(stream.second->flute_info());
            s["resolution"] = value(stream.second->resolution());
            s["codecs"] = value(stream.second->codecs());
            s["bandwidth"] = value(stream.second->bandwidth());
            s["frame_rate"] = value(stream.second->frame_rate());
            s["playlist_path"] = value(stream.second->playlist_path());
            if (stream.second->stream_type() == ContentStream::StreamType::SeamlessSwitching) {
              s["cdn_ept"] = value(std::dynamic_pointer_cast<SeamlessContentStream>(stream.second)->cdn_endpoint());
            } else {
              s["cdn_ept"] = value("n/a");
            }
            streams.push_back(s);
          }
          ser["streams"] = value::array(streams);
 
          services.push_back(ser);
        }
        message.reply(status_codes::OK, value::array(services));
        return;
      } else {
        message.reply(status_codes::NotFound);
        return;
      }
    } else {
      auto path = uri.to_string().erase(0,1); // remove leading /
      spdlog::debug("checking for file at path {}", path );
 
      auto it = _cache.item_map().find(path);
      if (it != _cache.item_map().cend()) {
        if (it->second->buffer() != nullptr) {
          web::http::http_response response(status_codes::OK);
          response.headers().add(U("RT-MBMS-MW-File-Origin"), it->second->item_source_as_string());
          auto instream = Concurrency::streams::rawptr_stream<uint8_t>::open_istream((uint8_t*)it->second->buffer(), it->second->content_length());
          response.set_body(instream);
          message.reply(response);
        } else {
          message.reply(status_codes::NotFound);
        }
      } else {
        message.reply(status_codes::NotFound);
      }
    }
  }
}

put()

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

private

Definition at line 202 of file RestHandler.cpp.

                                                 {
  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 {
    // not yet implemented
  }
}

Member Data Documentation

_api_key

std::string MBMS_RT::RestHandler::_api_key

private

Definition at line 71 of file RestHandler.h.

_api_path

std::string MBMS_RT::RestHandler::_api_path

private

Definition at line 72 of file RestHandler.h.

_cache

const CacheManagement& MBMS_RT::RestHandler::_cache

private

Definition at line 60 of file RestHandler.h.

_cfg

const libconfig::Config& MBMS_RT::RestHandler::_cfg

private

Definition at line 63 of file RestHandler.h.

_listener

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

private

Definition at line 69 of file RestHandler.h.

_require_bearer_token

bool MBMS_RT::RestHandler::_require_bearer_token = false

private

Definition at line 70 of file RestHandler.h.

_service_announcement_h

const std::unique_ptr<MBMS_RT::ServiceAnnouncement>* MBMS_RT::RestHandler::_service_announcement_h = {}

private

Definition at line 66 of file RestHandler.h.

_services

const std::map<std::string, std::shared_ptr<Service> >& MBMS_RT::RestHandler::_services

private

Definition at line 65 of file RestHandler.h.

_total_cache_size

unsigned MBMS_RT::RestHandler::_total_cache_size

private

Definition at line 67 of file RestHandler.h.

---

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

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