466f6b4fc4
The HTTP Streamer can be enabled via the _streamer_enabled_ daemon parameter. When the Streamer is active the daemon starts capturing the configured _Sinks_ up to the maximum number of channels configured by the _streamer_channels_ parameters. The captured PCM samples are split into _streamer_files_num_ files of _streamer_file_duration_ duration (in seconds) for each sink, compressed using AAC LC codec and served via HTTP. The HTTP streamer requires the libfaac-dev package to compile. Please note that since the HTTP Streamer uses the RAVENNA ALSA device for capturing it's not possible to use such device for other audio captures.
466 lines
15 KiB
C++
466 lines
15 KiB
C++
//
|
|
// http_server.cpp
|
|
//
|
|
// Copyright (c) 2019 2020 Andrea Bondavalli. All rights reserved.
|
|
//
|
|
// 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 3 of the License, or
|
|
// 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, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
|
|
#include <boost/foreach.hpp>
|
|
#include <boost/property_tree/json_parser.hpp>
|
|
#include <boost/property_tree/ptree.hpp>
|
|
#include <iostream>
|
|
#include <string>
|
|
|
|
#include "main.hpp"
|
|
#include "json.hpp"
|
|
#include "log.hpp"
|
|
#include "http_server.hpp"
|
|
|
|
using namespace httplib;
|
|
|
|
static inline void set_headers(Response& res,
|
|
const std::string& content_type = "") {
|
|
res.set_header("Access-Control-Allow-Methods",
|
|
"GET, POST, PUT, DELETE, OPTIONS");
|
|
res.set_header("Access-Control-Allow-Origin", "*");
|
|
res.set_header("Access-Control-Allow-Headers", "x-user-id");
|
|
if (!content_type.empty()) {
|
|
res.set_header("Content-Type", content_type);
|
|
}
|
|
}
|
|
|
|
static inline int get_http_error_status(const std::error_code& code) {
|
|
if (std::string(code.category().name()) == "daemon") {
|
|
if (code.value() < static_cast<int>(DaemonErrc::send_invalid_size)) {
|
|
return 400;
|
|
}
|
|
}
|
|
if (std::string(code.category().name()) == "driver") {
|
|
if (code.value() == static_cast<int>(DriverErrc::command_failed)) {
|
|
return 400;
|
|
}
|
|
}
|
|
return 500;
|
|
}
|
|
|
|
static inline std::string get_http_error_message(const std::error_code& code) {
|
|
std::stringstream ss;
|
|
ss << "(" << code.category().name() << ") " << code.message();
|
|
return ss.str();
|
|
}
|
|
|
|
static inline void set_error(const std::error_code& code,
|
|
const std::string& message,
|
|
Response& res) {
|
|
res.status = get_http_error_status(code);
|
|
set_headers(res, "text/plain");
|
|
res.body = message + " : " + get_http_error_message(code);
|
|
}
|
|
|
|
static inline void set_error(int status,
|
|
const std::string& message,
|
|
Response& res) {
|
|
res.status = status;
|
|
set_headers(res, "text/plain");
|
|
res.body = message;
|
|
}
|
|
|
|
bool HttpServer::init() {
|
|
/* setup http operations */
|
|
if (!svr_.is_valid()) {
|
|
return false;
|
|
}
|
|
|
|
svr_.set_mount_point(nullptr, config_->get_http_base_dir().c_str());
|
|
|
|
svr_.Get("(/|/Config|/PTP|/Sources|/Sinks|/Browser)",
|
|
[&](const Request& req, Response& res) {
|
|
std::ifstream file(config_->get_http_base_dir() + "/index.html");
|
|
std::stringstream buffer;
|
|
buffer << file.rdbuf();
|
|
res.set_content(buffer.str(), "text/html");
|
|
});
|
|
|
|
/* allows cross-origin */
|
|
svr_.Options("/api/(.*?)", [&](const Request& /*req*/, Response& res) {
|
|
set_headers(res);
|
|
});
|
|
|
|
/* get version */
|
|
svr_.Get("/api/version", [&](const Request& req, Response& res) {
|
|
set_headers(res, "application/json");
|
|
res.body = "{ \"version\": \"" + get_version() + "\" }";
|
|
});
|
|
|
|
/* get config */
|
|
svr_.Get("/api/config", [&](const Request& req, Response& res) {
|
|
set_headers(res, "application/json");
|
|
res.body = config_to_json(*config_);
|
|
});
|
|
|
|
/* set config */
|
|
svr_.Post("/api/config", [this](const Request& req, Response& res) {
|
|
try {
|
|
Config config = json_to_config(req.body, *config_);
|
|
|
|
if (config_->get_syslog_proto() != config.get_syslog_proto() ||
|
|
config_->get_syslog_server() != config.get_syslog_server() ||
|
|
config_->get_log_severity() != config.get_log_severity()) {
|
|
log_init(config);
|
|
}
|
|
std::error_code ret;
|
|
if (config_->get_playout_delay() != config.get_playout_delay()) {
|
|
ret = session_manager_->set_driver_config("playout_delay",
|
|
config.get_playout_delay());
|
|
}
|
|
if (config_->get_sample_rate() != config.get_sample_rate()) {
|
|
ret = session_manager_->set_driver_config("sample_rate",
|
|
config.get_sample_rate());
|
|
}
|
|
if (config_->get_ptp_domain() != config.get_ptp_domain() ||
|
|
config_->get_ptp_dscp() != config.get_ptp_dscp()) {
|
|
PTPConfig ptpConfig{config.get_ptp_domain(), config.get_ptp_dscp()};
|
|
ret = session_manager_->set_ptp_config(ptpConfig);
|
|
}
|
|
if (ret) {
|
|
set_error(ret, "failed to set config", res);
|
|
return;
|
|
}
|
|
if (!config_->save(config)) {
|
|
set_error(500, "failed to save config", res);
|
|
return;
|
|
}
|
|
set_headers(res);
|
|
} catch (const std::runtime_error& e) {
|
|
set_error(400, e.what(), res);
|
|
}
|
|
});
|
|
|
|
/* get ptp status */
|
|
svr_.Get("/api/ptp/status", [this](const Request& req, Response& res) {
|
|
PTPStatus status;
|
|
session_manager_->get_ptp_status(status);
|
|
set_headers(res, "application/json");
|
|
res.body = ptp_status_to_json(status);
|
|
});
|
|
|
|
/* get ptp config */
|
|
svr_.Get("/api/ptp/config", [this](const Request& req, Response& res) {
|
|
PTPConfig ptpConfig;
|
|
session_manager_->get_ptp_config(ptpConfig);
|
|
set_headers(res, "application/json");
|
|
res.body = ptp_config_to_json(ptpConfig);
|
|
});
|
|
|
|
/* set ptp config */
|
|
svr_.Post("/api/ptp/config", [this](const Request& req, Response& res) {
|
|
try {
|
|
PTPConfig ptpConfig = json_to_ptp_config(req.body);
|
|
auto ret = session_manager_->set_ptp_config(ptpConfig);
|
|
if (ret) {
|
|
set_error(ret, "failed to set ptp config", res);
|
|
return;
|
|
}
|
|
Config config(*config_);
|
|
config.set_ptp_domain(ptpConfig.domain);
|
|
config.set_ptp_dscp(ptpConfig.dscp);
|
|
if (!config_->save(config)) {
|
|
set_error(500, "failed to save config", res);
|
|
return;
|
|
}
|
|
set_headers(res);
|
|
} catch (const std::runtime_error& e) {
|
|
set_error(400, e.what(), res);
|
|
}
|
|
});
|
|
|
|
/* get all sources */
|
|
svr_.Get("/api/sources", [this](const Request& req, Response& res) {
|
|
auto const sources = session_manager_->get_sources();
|
|
set_headers(res, "application/json");
|
|
res.body = sources_to_json(sources);
|
|
});
|
|
|
|
/* get all sinks */
|
|
svr_.Get("/api/sinks", [this](const Request& req, Response& res) {
|
|
auto const sinks = session_manager_->get_sinks();
|
|
set_headers(res, "application/json");
|
|
res.body = sinks_to_json(sinks);
|
|
});
|
|
|
|
/* get all sources and sinks */
|
|
svr_.Get("/api/streams", [this](const Request& req, Response& res) {
|
|
auto const sources = session_manager_->get_sources();
|
|
auto const sinks = session_manager_->get_sinks();
|
|
set_headers(res, "application/json");
|
|
res.body = streams_to_json(sources, sinks);
|
|
});
|
|
|
|
/* get a source SDP */
|
|
svr_.Get(
|
|
"/api/source/sdp/([0-9]+)", [this](const Request& req, Response& res) {
|
|
uint32_t id;
|
|
try {
|
|
id = std::stoi(req.matches[1]);
|
|
} catch (...) {
|
|
set_error(400, "failed to convert id", res);
|
|
return;
|
|
}
|
|
|
|
auto ret = session_manager_->get_source_sdp(id, res.body);
|
|
if (ret) {
|
|
set_error(ret, "get source " + std::to_string(id) + " failed", res);
|
|
} else {
|
|
set_headers(res, "application/sdp");
|
|
}
|
|
});
|
|
|
|
/* get stream status */
|
|
svr_.Get(
|
|
"/api/sink/status/([0-9]+)", [this](const Request& req, Response& res) {
|
|
uint32_t id;
|
|
try {
|
|
id = std::stoi(req.matches[1]);
|
|
} catch (...) {
|
|
set_error(400, "failed to convert id", res);
|
|
return;
|
|
}
|
|
SinkStreamStatus status;
|
|
auto ret = session_manager_->get_sink_status(id, status);
|
|
if (ret) {
|
|
set_error(ret, "failed to get sink " + std::to_string(id) + " status",
|
|
res);
|
|
} else {
|
|
set_headers(res, "application/json");
|
|
res.body = sink_status_to_json(status);
|
|
}
|
|
});
|
|
|
|
/* add a source */
|
|
svr_.Put("/api/source/([0-9]+)", [this](const Request& req, Response& res) {
|
|
try {
|
|
StreamSource source = json_to_source(req.matches[1], req.body);
|
|
auto ret = session_manager_->add_source(source);
|
|
if (ret) {
|
|
set_error(ret, "failed to add source " + std::to_string(source.id),
|
|
res);
|
|
} else {
|
|
set_headers(res);
|
|
}
|
|
} catch (const std::runtime_error& e) {
|
|
set_error(400, e.what(), res);
|
|
}
|
|
});
|
|
|
|
/* remove a source */
|
|
svr_.Delete(
|
|
"/api/source/([0-9]+)", [this](const Request& req, Response& res) {
|
|
uint32_t id;
|
|
try {
|
|
id = std::stoi(req.matches[1]);
|
|
} catch (...) {
|
|
set_error(400, "failed to convert id", res);
|
|
return;
|
|
}
|
|
auto ret = session_manager_->remove_source(id);
|
|
if (ret) {
|
|
set_error(ret, "failed to remove source " + std::to_string(id), res);
|
|
} else {
|
|
set_headers(res);
|
|
}
|
|
});
|
|
|
|
/* add a sink */
|
|
svr_.Put("/api/sink/([0-9]+)", [this](const Request& req, Response& res) {
|
|
try {
|
|
StreamSink sink = json_to_sink(req.matches[1], req.body);
|
|
auto ret = session_manager_->add_sink(sink);
|
|
if (ret) {
|
|
set_error(ret, "failed to add sink " + std::to_string(sink.id), res);
|
|
} else {
|
|
set_headers(res);
|
|
}
|
|
} catch (const std::runtime_error& e) {
|
|
set_error(400, e.what(), res);
|
|
}
|
|
});
|
|
|
|
/* remove a sink */
|
|
svr_.Delete("/api/sink/([0-9]+)", [this](const Request& req, Response& res) {
|
|
uint32_t id;
|
|
try {
|
|
id = std::stoi(req.matches[1]);
|
|
} catch (...) {
|
|
set_error(400, "failed to convert id", res);
|
|
return;
|
|
}
|
|
auto ret = session_manager_->remove_sink(id);
|
|
if (ret) {
|
|
set_error(ret, "failed to remove sink " + std::to_string(id), res);
|
|
} else {
|
|
set_headers(res);
|
|
}
|
|
});
|
|
|
|
/* get remote sources */
|
|
svr_.Get("/api/browse/sources/(all|mdns|sap)",
|
|
[this](const Request& req, Response& res) {
|
|
auto const sources = browser_->get_remote_sources(req.matches[1]);
|
|
set_headers(res, "application/json");
|
|
res.body = remote_sources_to_json(sources);
|
|
});
|
|
|
|
/* retrieve streamer info and position */
|
|
svr_.Get("/api/streamer/info/([0-9]+)", [this](const Request& req,
|
|
Response& res) {
|
|
uint32_t id;
|
|
StreamerInfo info;
|
|
enum class streamer_info_status {
|
|
ok,
|
|
ptp_not_locked,
|
|
invalid_channels,
|
|
buffering,
|
|
not_enabled,
|
|
invalid_sink,
|
|
cannot_retrieve
|
|
};
|
|
|
|
info.status = static_cast<uint8_t>(streamer_info_status::ok);
|
|
if (!config_->get_streamer_enabled()) {
|
|
info.status = static_cast<uint8_t>(streamer_info_status::not_enabled);
|
|
} else {
|
|
try {
|
|
id = std::stoi(req.matches[1]);
|
|
} catch (...) {
|
|
info.status = static_cast<uint8_t>(streamer_info_status::invalid_sink);
|
|
}
|
|
}
|
|
|
|
if (info.status == static_cast<uint8_t>(streamer_info_status::ok)) {
|
|
StreamSink sink;
|
|
auto ret = session_manager_->get_sink(id, sink);
|
|
if (ret) {
|
|
info.status =
|
|
static_cast<uint8_t>(streamer_info_status::cannot_retrieve);
|
|
} else {
|
|
ret = streamer_->get_info(sink, info);
|
|
switch (ret.value()) {
|
|
case static_cast<int>(DaemonErrc::streamer_not_running):
|
|
info.status =
|
|
static_cast<uint8_t>(streamer_info_status::ptp_not_locked);
|
|
break;
|
|
case static_cast<int>(DaemonErrc::streamer_invalid_ch):
|
|
info.status =
|
|
static_cast<uint8_t>(streamer_info_status::invalid_channels);
|
|
break;
|
|
case static_cast<int>(DaemonErrc::streamer_retry_later):
|
|
info.status = static_cast<uint8_t>(streamer_info_status::buffering);
|
|
break;
|
|
default:
|
|
info.status = static_cast<uint8_t>(streamer_info_status::ok);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
set_headers(res, "application/json");
|
|
res.body = streamer_info_to_json(info);
|
|
});
|
|
|
|
/* retrieve streamer file */
|
|
svr_.Get("/api/streamer/stream/([0-9]+)/([0-9]+)", [this](const Request& req,
|
|
Response& res) {
|
|
if (!config_->get_streamer_enabled()) {
|
|
set_error(400, "streamer not enabled", res);
|
|
return;
|
|
}
|
|
uint8_t sinkId, fileId;
|
|
try {
|
|
sinkId = std::stoi(req.matches[1]);
|
|
fileId = std::stoi(req.matches[2]);
|
|
} catch (...) {
|
|
set_error(400, "failed to convert id", res);
|
|
return;
|
|
}
|
|
StreamSink sink;
|
|
auto ret = session_manager_->get_sink(sinkId, sink);
|
|
if (ret) {
|
|
set_error(ret, "failed to retrieve sink " + std::to_string(sinkId), res);
|
|
return;
|
|
}
|
|
uint8_t currentFileId, startFileId;
|
|
uint32_t fileCount;
|
|
ret = streamer_->get_stream(sink, fileId, currentFileId, startFileId,
|
|
fileCount, res.body);
|
|
if (ret) {
|
|
set_error(ret, "failed to fetch stream " + std::to_string(sinkId), res);
|
|
return;
|
|
}
|
|
set_headers(res, "audio/aac");
|
|
res.set_header("X-File-Count", std::to_string(fileCount));
|
|
res.set_header("X-File-Current-Id", std::to_string(currentFileId));
|
|
res.set_header("X-File-Start-Id", std::to_string(startFileId));
|
|
});
|
|
|
|
svr_.set_logger([](const Request& req, const Response& res) {
|
|
if (res.status == 200) {
|
|
BOOST_LOG_TRIVIAL(info) << "http_server:: " << req.method << " "
|
|
<< req.path << " response " << res.status;
|
|
} else {
|
|
BOOST_LOG_TRIVIAL(error)
|
|
<< "http_server:: " << req.method << " " << req.path << " response "
|
|
<< res.status << " " << res.body;
|
|
}
|
|
});
|
|
|
|
std::string http_addr = config_->get_http_addr_str();
|
|
if (http_addr.empty())
|
|
http_addr = config_->get_ip_addr_str();
|
|
BOOST_LOG_TRIVIAL(info) << "http_server:: binding to " << http_addr << ":"
|
|
<< config_->get_http_port();
|
|
|
|
/* start http server on a separate thread */
|
|
res_ = std::async(std::launch::async, [&]() {
|
|
try {
|
|
svr_.listen(http_addr.c_str(), config_->get_http_port());
|
|
} catch (...) {
|
|
BOOST_LOG_TRIVIAL(fatal) << "http_server:: "
|
|
<< "failed to listen to " << http_addr << ":"
|
|
<< config_->get_http_port();
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
/* wait for HTTP server to show up */
|
|
httplib::Client cli(config_->get_ip_addr_str().c_str(),
|
|
config_->get_http_port());
|
|
int retry = 3;
|
|
while (retry) {
|
|
auto res = cli.Get("/api/config");
|
|
if (res && res->status == 200) {
|
|
break;
|
|
}
|
|
--retry;
|
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
}
|
|
return retry;
|
|
}
|
|
|
|
bool HttpServer::terminate() {
|
|
BOOST_LOG_TRIVIAL(info) << "http_server: stopping ... ";
|
|
svr_.stop();
|
|
return res_.get();
|
|
}
|