mirror of
https://github.com/ossrs/srs.git
synced 2025-03-09 15:49:59 +00:00
APM: Support distributed tracing by Tencent Cloud APM. v5.0.63
This commit is contained in:
winlin
parent
736c661808
commit
3e2f8622f8
49 changed files with 4989 additions and 719 deletions
|
|
@ -1826,6 +1826,13 @@ srs_error_t SrsConfig::parse_options(int argc, char** argv)
|
|||
}
|
||||
}
|
||||
|
||||
// Overwrite the config by env SRS_CONFIG_FILE.
|
||||
if (::getenv("SRS_CONFIG_FILE")) {
|
||||
string ov = config_file;
|
||||
config_file = ::getenv("SRS_CONFIG_FILE");
|
||||
srs_trace("ENV: Overwrite config %s to %s", ov.c_str(), config_file.c_str());
|
||||
}
|
||||
|
||||
// Parse the matched config file.
|
||||
err = parse_file(config_file.c_str());
|
||||
|
||||
|
|
@ -2211,7 +2218,7 @@ srs_error_t SrsConfig::check_normal_config()
|
|||
std::string n = conf->name;
|
||||
if (n != "listen" && n != "pid" && n != "chunk_size" && n != "ff_log_dir"
|
||||
&& n != "srs_log_tank" && n != "srs_log_level" && n != "srs_log_file"
|
||||
&& n != "max_connections" && n != "daemon" && n != "heartbeat"
|
||||
&& n != "max_connections" && n != "daemon" && n != "heartbeat" && n != "tencentcloud_apm"
|
||||
&& n != "http_api" && n != "stats" && n != "vhost" && n != "pithy_print_ms"
|
||||
&& n != "http_server" && n != "stream_caster" && n != "rtc_server" && n != "srt_server"
|
||||
&& n != "utc_time" && n != "work_dir" && n != "asprocess" && n != "server_id"
|
||||
|
|
@ -3442,6 +3449,101 @@ string SrsConfig::get_tencentcloud_cls_topic_id()
|
|||
return conf->arg0();
|
||||
}
|
||||
|
||||
bool SrsConfig::get_tencentcloud_apm_enabled()
|
||||
{
|
||||
SRS_OVERWRITE_BY_ENV_BOOL("SRS_TENCENTCLOUD_APM_ENABLED");
|
||||
|
||||
static bool DEFAULT = false;
|
||||
|
||||
SrsConfDirective* conf = root->get("tencentcloud_apm");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
conf = conf->get("enabled");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
return SRS_CONF_PERFER_FALSE(conf->arg0());
|
||||
}
|
||||
|
||||
string SrsConfig::get_tencentcloud_apm_token()
|
||||
{
|
||||
SRS_OVERWRITE_BY_ENV_STRING("SRS_TENCENTCLOUD_APM_TOKEN");
|
||||
|
||||
static string DEFAULT = "";
|
||||
|
||||
SrsConfDirective* conf = root->get("tencentcloud_apm");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
conf = conf->get("token");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
return conf->arg0();
|
||||
}
|
||||
|
||||
string SrsConfig::get_tencentcloud_apm_endpoint()
|
||||
{
|
||||
SRS_OVERWRITE_BY_ENV_STRING("SRS_TENCENTCLOUD_APM_ENDPOINT");
|
||||
|
||||
static string DEFAULT = "";
|
||||
|
||||
SrsConfDirective* conf = root->get("tencentcloud_apm");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
conf = conf->get("endpoint");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
return conf->arg0();
|
||||
}
|
||||
|
||||
string SrsConfig::get_tencentcloud_apm_service_name()
|
||||
{
|
||||
SRS_OVERWRITE_BY_ENV_STRING("SRS_TENCENTCLOUD_APM_SERVICE_NAME");
|
||||
|
||||
static string DEFAULT = "srs-server";
|
||||
|
||||
SrsConfDirective* conf = root->get("tencentcloud_apm");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
conf = conf->get("service_name");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
return conf->arg0();
|
||||
}
|
||||
|
||||
bool SrsConfig::get_tencentcloud_apm_debug_logging()
|
||||
{
|
||||
SRS_OVERWRITE_BY_ENV_BOOL("SRS_TENCENTCLOUD_APM_DEBUG_LOGGING");
|
||||
|
||||
static bool DEFAULT = false;
|
||||
|
||||
SrsConfDirective* conf = root->get("tencentcloud_apm");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
conf = conf->get("debug_logging");
|
||||
if (!conf) {
|
||||
return DEFAULT;
|
||||
}
|
||||
|
||||
return SRS_CONF_PERFER_FALSE(conf->arg0());
|
||||
}
|
||||
|
||||
vector<SrsConfDirective*> SrsConfig::get_stream_casters()
|
||||
{
|
||||
srs_assert(root);
|
||||
|
|
|
|||
|
|
@ -469,6 +469,11 @@ public:
|
|||
virtual std::string get_tencentcloud_cls_secret_key();
|
||||
virtual std::string get_tencentcloud_cls_endpoint();
|
||||
virtual std::string get_tencentcloud_cls_topic_id();
|
||||
virtual bool get_tencentcloud_apm_enabled();
|
||||
virtual std::string get_tencentcloud_apm_token();
|
||||
virtual std::string get_tencentcloud_apm_endpoint();
|
||||
virtual std::string get_tencentcloud_apm_service_name();
|
||||
virtual bool get_tencentcloud_apm_debug_logging();
|
||||
// stream_caster section
|
||||
public:
|
||||
// Get all stream_caster in config file.
|
||||
|
|
|
|||
|
|
@ -614,7 +614,7 @@ srs_error_t SrsBufferedReadWriter::read(void* buf, size_t size, ssize_t* nread)
|
|||
return io_->read(buf, size, nread);
|
||||
}
|
||||
|
||||
int nn = srs_min(buf_->left(), size);
|
||||
int nn = srs_min(buf_->left(), (int)size);
|
||||
*nread = nn;
|
||||
|
||||
if (nn) {
|
||||
|
|
@ -629,7 +629,7 @@ srs_error_t SrsBufferedReadWriter::read_fully(void* buf, size_t size, ssize_t* n
|
|||
return io_->read_fully(buf, size, nread);
|
||||
}
|
||||
|
||||
int nn = srs_min(buf_->left(), size);
|
||||
int nn = srs_min(buf_->left(), (int)size);
|
||||
if (nn) {
|
||||
buf_->read_bytes((char*)buf, nn);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,6 +34,8 @@ using namespace std;
|
|||
#include <srs_kernel_flv.hpp>
|
||||
#include <srs_kernel_buffer.hpp>
|
||||
#include <srs_protocol_amf0.hpp>
|
||||
#include <srs_app_http_client.hpp>
|
||||
#include <srs_app_tencentcloud.hpp>
|
||||
|
||||
// when edge timeout, retry next.
|
||||
#define SRS_EDGE_INGESTER_TIMEOUT (5 * SRS_UTIME_SECONDS)
|
||||
|
|
@ -107,7 +109,11 @@ srs_error_t SrsEdgeRtmpUpstream::connect(SrsRequest* r, SrsLbRoundRobin* lb)
|
|||
srs_utime_t cto = SRS_EDGE_INGESTER_TIMEOUT;
|
||||
srs_utime_t sto = SRS_CONSTS_RTMP_PULSE;
|
||||
sdk = new SrsSimpleRtmpClient(url, cto, sto);
|
||||
|
||||
|
||||
// Create a client span and store it to an AMF0 propagator.
|
||||
ISrsApmSpan* span_client = _srs_apm->inject(_srs_apm->span("edge-pull")->set_kind(SrsApmKindClient)->as_child(_srs_apm->load()), sdk->extra_args());
|
||||
SrsAutoFree(ISrsApmSpan, span_client);
|
||||
|
||||
if ((err = sdk->connect()) != srs_success) {
|
||||
return srs_error_wrap(err, "edge pull %s failed, cto=%dms, sto=%dms.", url.c_str(), srsu2msi(cto), srsu2msi(sto));
|
||||
}
|
||||
|
|
@ -387,6 +393,7 @@ SrsEdgeIngester::SrsEdgeIngester()
|
|||
source = NULL;
|
||||
edge = NULL;
|
||||
req = NULL;
|
||||
span_main_ = NULL;
|
||||
|
||||
upstream = new SrsEdgeRtmpUpstream("");
|
||||
lb = new SrsLbRoundRobin();
|
||||
|
|
@ -396,7 +403,8 @@ SrsEdgeIngester::SrsEdgeIngester()
|
|||
SrsEdgeIngester::~SrsEdgeIngester()
|
||||
{
|
||||
stop();
|
||||
|
||||
|
||||
srs_freep(span_main_);
|
||||
srs_freep(upstream);
|
||||
srs_freep(lb);
|
||||
srs_freep(trd);
|
||||
|
|
@ -407,7 +415,12 @@ srs_error_t SrsEdgeIngester::initialize(SrsLiveSource* s, SrsPlayEdge* e, SrsReq
|
|||
source = s;
|
||||
edge = e;
|
||||
req = r;
|
||||
|
||||
|
||||
// We create a dedicate span for edge ingester, and all players will link to this one.
|
||||
// Note that we use a producer span and end it immediately.
|
||||
srs_assert(!span_main_);
|
||||
span_main_ = _srs_apm->span("edge")->set_kind(SrsApmKindProducer)->end();
|
||||
|
||||
return srs_success;
|
||||
}
|
||||
|
||||
|
|
@ -445,12 +458,23 @@ string SrsEdgeIngester::get_curr_origin()
|
|||
return lb->selected();
|
||||
}
|
||||
|
||||
ISrsApmSpan* SrsEdgeIngester::span()
|
||||
{
|
||||
srs_assert(span_main_);
|
||||
return span_main_;
|
||||
}
|
||||
|
||||
// when error, edge ingester sleep for a while and retry.
|
||||
#define SRS_EDGE_INGESTER_CIMS (3 * SRS_UTIME_SECONDS)
|
||||
|
||||
srs_error_t SrsEdgeIngester::cycle()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
// Save span from parent coroutine to current coroutine context, so that we can load if in this coroutine, for
|
||||
// example to use it in SrsEdgeRtmpUpstream which use RTMP or FLV client to connect to upstream server.
|
||||
_srs_apm->store(span_main_);
|
||||
srs_assert(span_main_);
|
||||
|
||||
while (true) {
|
||||
// We always check status first.
|
||||
|
|
@ -459,11 +483,19 @@ srs_error_t SrsEdgeIngester::cycle()
|
|||
return srs_error_wrap(err, "edge ingester");
|
||||
}
|
||||
|
||||
srs_assert(span_main_);
|
||||
ISrsApmSpan* start = _srs_apm->span("edge-start")->set_kind(SrsApmKindConsumer)->as_child(span_main_)->end();
|
||||
srs_freep(start);
|
||||
|
||||
if ((err = do_cycle()) != srs_success) {
|
||||
srs_warn("EdgeIngester: Ignore error, %s", srs_error_desc(err).c_str());
|
||||
srs_freep(err);
|
||||
}
|
||||
|
||||
srs_assert(span_main_);
|
||||
ISrsApmSpan* stop = _srs_apm->span("edge-stop")->set_kind(SrsApmKindConsumer)->as_child(span_main_)->end();
|
||||
srs_freep(stop);
|
||||
|
||||
srs_usleep(SRS_EDGE_INGESTER_CIMS);
|
||||
}
|
||||
|
||||
|
|
@ -700,7 +732,7 @@ srs_error_t SrsEdgeForwarder::initialize(SrsLiveSource* s, SrsPublishEdge* e, Sr
|
|||
source = s;
|
||||
edge = e;
|
||||
req = r;
|
||||
|
||||
|
||||
return srs_success;
|
||||
}
|
||||
|
||||
|
|
@ -733,6 +765,11 @@ srs_error_t SrsEdgeForwarder::start()
|
|||
srs_utime_t cto = SRS_EDGE_FORWARDER_TIMEOUT;
|
||||
srs_utime_t sto = SRS_CONSTS_RTMP_TIMEOUT;
|
||||
sdk = new SrsSimpleRtmpClient(url, cto, sto);
|
||||
|
||||
// Create a client span and store it to an AMF0 propagator.
|
||||
// Note that we are able to load the span from coroutine context because in the same coroutine.
|
||||
ISrsApmSpan* span_client = _srs_apm->inject(_srs_apm->span("edge-push")->set_kind(SrsApmKindClient)->as_child(_srs_apm->load()), sdk->extra_args());
|
||||
SrsAutoFree(ISrsApmSpan, span_client);
|
||||
|
||||
if ((err = sdk->connect()) != srs_success) {
|
||||
return srs_error_wrap(err, "sdk connect %s failed, cto=%dms, sto=%dms.", url.c_str(), srsu2msi(cto), srsu2msi(sto));
|
||||
|
|
@ -919,6 +956,14 @@ srs_error_t SrsPlayEdge::on_client_play()
|
|||
} else if (state == SrsEdgeStateIngestStopping) {
|
||||
return srs_error_new(ERROR_RTMP_EDGE_PLAY_STATE, "state is stopping");
|
||||
}
|
||||
|
||||
// APM bind client span to edge span, which fetch stream from upstream server.
|
||||
// We create a new span to link the two span, because these two spans might be ended.
|
||||
if (ingester->span() && _srs_apm->load()) {
|
||||
ISrsApmSpan* from = _srs_apm->span("play-link")->as_child(_srs_apm->load());
|
||||
ISrsApmSpan* to = _srs_apm->span("edge-link")->as_child(ingester->span())->link(from);
|
||||
srs_freep(from); srs_freep(to);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ class SrsHttpClient;
|
|||
class ISrsHttpMessage;
|
||||
class SrsHttpFileReader;
|
||||
class SrsFlvDecoder;
|
||||
class ISrsApmSpan;
|
||||
|
||||
// The state of edge, auto machine
|
||||
enum SrsEdgeState
|
||||
|
|
@ -142,6 +143,7 @@ private:
|
|||
SrsCoroutine* trd;
|
||||
SrsLbRoundRobin* lb;
|
||||
SrsEdgeUpstream* upstream;
|
||||
ISrsApmSpan* span_main_;
|
||||
public:
|
||||
SrsEdgeIngester();
|
||||
virtual ~SrsEdgeIngester();
|
||||
|
|
@ -150,6 +152,8 @@ public:
|
|||
virtual srs_error_t start();
|
||||
virtual void stop();
|
||||
virtual std::string get_curr_origin();
|
||||
// Get the current main span. Note that it might be NULL.
|
||||
ISrsApmSpan* span();
|
||||
// Interface ISrsReusableThread2Handler
|
||||
public:
|
||||
virtual srs_error_t cycle();
|
||||
|
|
|
|||
|
|
@ -185,6 +185,9 @@ srs_error_t SrsHybridServer::initialize()
|
|||
if ((err = _srs_cls->initialize()) != srs_success) {
|
||||
return srs_error_wrap(err, "cls client");
|
||||
}
|
||||
if ((err = _srs_apm->initialize()) != srs_success) {
|
||||
return srs_error_wrap(err, "apm client");
|
||||
}
|
||||
|
||||
// Register some timers.
|
||||
timer20ms_->subscribe(clock_monitor_);
|
||||
|
|
@ -396,6 +399,12 @@ srs_error_t SrsHybridServer::on_timer(srs_utime_t interval)
|
|||
srs_freep(err);
|
||||
}
|
||||
|
||||
// Report logs to APM if enabled.
|
||||
if ((err = _srs_apm->report()) != srs_success) {
|
||||
srs_warn("ignore apm err %s", srs_error_desc(err).c_str());
|
||||
srs_freep(err);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ using namespace std;
|
|||
#include <srs_protocol_utility.hpp>
|
||||
#include <srs_protocol_json.hpp>
|
||||
#include <srs_app_rtc_source.hpp>
|
||||
#include <srs_app_tencentcloud.hpp>
|
||||
|
||||
// the timeout in srs_utime_t to wait encoder to republish
|
||||
// if timeout, close the connection.
|
||||
|
|
@ -100,6 +101,9 @@ SrsRtmpConn::SrsRtmpConn(SrsServer* svr, srs_netfd_t c, string cip, int cport)
|
|||
ip = cip;
|
||||
port = cport;
|
||||
create_time = srsu2ms(srs_get_system_time());
|
||||
span_main_ = _srs_apm->dummy();
|
||||
span_connect_ = _srs_apm->dummy();
|
||||
span_client_ = _srs_apm->dummy();
|
||||
trd = new SrsSTCoroutine("rtmp", this, _srs_context->get_id());
|
||||
|
||||
kbps = new SrsNetworkKbps();
|
||||
|
|
@ -145,6 +149,9 @@ SrsRtmpConn::~SrsRtmpConn()
|
|||
srs_freep(rtmp);
|
||||
srs_freep(refer);
|
||||
srs_freep(security);
|
||||
srs_freep(span_main_);
|
||||
srs_freep(span_connect_);
|
||||
srs_freep(span_client_);
|
||||
}
|
||||
|
||||
std::string SrsRtmpConn::desc()
|
||||
|
|
@ -152,13 +159,27 @@ std::string SrsRtmpConn::desc()
|
|||
return "RtmpConn";
|
||||
}
|
||||
|
||||
std::string srs_ipv4_string(uint32_t rip)
|
||||
{
|
||||
return srs_fmt("%d.%d.%d.%d", uint8_t(rip>>24), uint8_t(rip>>16), uint8_t(rip>>8), uint8_t(rip));
|
||||
}
|
||||
|
||||
// TODO: return detail message when error for client.
|
||||
srs_error_t SrsRtmpConn::do_cycle()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
// We should keep the root span to alive util connection closed.
|
||||
// Note that we use producer and consumer span because RTMP connection is long polling connection.
|
||||
// Note that we also store this span in coroutine context, so that edge could load it.
|
||||
srs_freep(span_main_);
|
||||
span_main_ = _srs_apm->span("rtmp")->set_kind(SrsApmKindServer)->attr("cip", ip)
|
||||
->attr("cid", _srs_context->get_id().c_str());
|
||||
|
||||
srs_trace("RTMP client ip=%s:%d, fd=%d", ip.c_str(), port, srs_netfd_fileno(stfd));
|
||||
|
||||
srs_trace("RTMP client ip=%s:%d, fd=%d, trace=%s, span=%s", ip.c_str(), port, srs_netfd_fileno(stfd),
|
||||
span_main_->format_trace_id(), span_main_->format_span_id()
|
||||
);
|
||||
|
||||
rtmp->set_recv_timeout(SRS_CONSTS_RTMP_TIMEOUT);
|
||||
rtmp->set_send_timeout(SRS_CONSTS_RTMP_TIMEOUT);
|
||||
|
||||
|
|
@ -167,16 +188,23 @@ srs_error_t SrsRtmpConn::do_cycle()
|
|||
}
|
||||
|
||||
uint32_t rip = rtmp->proxy_real_ip();
|
||||
std::string rips = srs_ipv4_string(rip);
|
||||
if (rip > 0) {
|
||||
srs_trace("RTMP proxy real client ip=%d.%d.%d.%d",
|
||||
uint8_t(rip>>24), uint8_t(rip>>16), uint8_t(rip>>8), uint8_t(rip));
|
||||
srs_trace("RTMP proxy real client ip=%s", rips.c_str());
|
||||
}
|
||||
|
||||
|
||||
// Update the real IP of client, also set the HTTP fields.
|
||||
span_main_->attr("rip", rip ? rips : ip)->attr("http.client_ip", rip ? rips : ip);
|
||||
|
||||
// The span for RTMP connecting to application.
|
||||
srs_freep(span_connect_);
|
||||
span_connect_ = _srs_apm->span("connect")->as_child(span_main_);
|
||||
|
||||
SrsRequest* req = info->req;
|
||||
if ((err = rtmp->connect_app(req)) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp connect tcUrl");
|
||||
}
|
||||
|
||||
|
||||
// set client ip to request.
|
||||
req->ip = ip;
|
||||
|
||||
|
|
@ -210,6 +238,10 @@ srs_error_t SrsRtmpConn::do_cycle()
|
|||
srs_trace("edge-srs ip=%s, version=%s, pid=%d, id=%d",
|
||||
srs_server_ip.c_str(), srs_version.c_str(), srs_pid, srs_id);
|
||||
}
|
||||
|
||||
// Load the span from the AMF0 object propagator.
|
||||
// Note that we will update the trace id, so please make sure no spans are ended before this.
|
||||
_srs_apm->extract(span_main_, req->args);
|
||||
}
|
||||
|
||||
if ((err = service_cycle()) != srs_success) {
|
||||
|
|
@ -381,6 +413,9 @@ srs_error_t SrsRtmpConn::service_cycle()
|
|||
if ((err = rtmp->response_connect_app(req, local_ip.c_str())) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp: response connect app");
|
||||
}
|
||||
|
||||
// Must be a connecting application span.
|
||||
span_connect_->end();
|
||||
|
||||
if ((err = rtmp->on_bw_done()) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp: on bw down");
|
||||
|
|
@ -439,9 +474,8 @@ srs_error_t SrsRtmpConn::service_cycle()
|
|||
srs_error_t SrsRtmpConn::stream_service_cycle()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
||||
SrsRequest* req = info->req;
|
||||
|
||||
if ((err = rtmp->identify_client(info->res->stream_id, info->type, req->stream, req->duration)) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp: identify client");
|
||||
}
|
||||
|
|
@ -458,12 +492,21 @@ srs_error_t SrsRtmpConn::stream_service_cycle()
|
|||
req->strip();
|
||||
srs_trace("client identified, type=%s, vhost=%s, app=%s, stream=%s, param=%s, duration=%dms",
|
||||
srs_client_type_string(info->type).c_str(), req->vhost.c_str(), req->app.c_str(), req->stream.c_str(), req->param.c_str(), srsu2msi(req->duration));
|
||||
|
||||
// Start APM only when client is identified, because it might republish.
|
||||
srs_freep(span_client_);
|
||||
span_client_ = _srs_apm->span("client")->as_child(span_connect_)->attr("type", srs_client_type_string(info->type))
|
||||
->attr("url", req->get_stream_url())->attr("http.url", req->get_stream_url());
|
||||
// We store the span to coroutine context, for edge to load it.
|
||||
_srs_apm->store(span_client_);
|
||||
|
||||
// discovery vhost, resolve the vhost from config
|
||||
SrsConfDirective* parsed_vhost = _srs_config->get_vhost(req->vhost);
|
||||
if (parsed_vhost) {
|
||||
req->vhost = parsed_vhost->arg0();
|
||||
}
|
||||
span_client_->attr("vhost", req->vhost)->attr("http.host", req->host)->attr("http.server_name", req->vhost)
|
||||
->attr("http.target", srs_fmt("/%s/%s", req->app.c_str(), req->stream.c_str()));
|
||||
|
||||
if (req->schema.empty() || req->vhost.empty() || req->port == 0 || req->app.empty()) {
|
||||
return srs_error_new(ERROR_RTMP_REQ_TCURL, "discovery tcUrl failed, tcUrl=%s, schema=%s, vhost=%s, port=%d, app=%s",
|
||||
|
|
@ -535,6 +578,11 @@ srs_error_t SrsRtmpConn::stream_service_cycle()
|
|||
if ((err = http_hooks_on_play()) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp: callback on play");
|
||||
}
|
||||
|
||||
// Must be a client span.
|
||||
span_client_->set_name("play")->end();
|
||||
// We end the connection span because it's a producer and only trace the established.
|
||||
span_main_->end();
|
||||
|
||||
err = playing(source);
|
||||
http_hooks_on_stop();
|
||||
|
|
@ -545,6 +593,11 @@ srs_error_t SrsRtmpConn::stream_service_cycle()
|
|||
if ((err = rtmp->start_fmle_publish(info->res->stream_id)) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp: start FMLE publish");
|
||||
}
|
||||
|
||||
// Must be a client span.
|
||||
span_client_->set_name("publish")->end();
|
||||
// We end the connection span because it's a producer and only trace the established.
|
||||
span_main_->end();
|
||||
|
||||
return publishing(source);
|
||||
}
|
||||
|
|
@ -552,6 +605,11 @@ srs_error_t SrsRtmpConn::stream_service_cycle()
|
|||
if ((err = rtmp->start_haivision_publish(info->res->stream_id)) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp: start HAIVISION publish");
|
||||
}
|
||||
|
||||
// Must be a client span.
|
||||
span_client_->set_name("publish")->end();
|
||||
// We end the connection span because it's a producer and only trace the established.
|
||||
span_main_->end();
|
||||
|
||||
return publishing(source);
|
||||
}
|
||||
|
|
@ -559,6 +617,11 @@ srs_error_t SrsRtmpConn::stream_service_cycle()
|
|||
if ((err = rtmp->start_flash_publish(info->res->stream_id)) != srs_success) {
|
||||
return srs_error_wrap(err, "rtmp: start FLASH publish");
|
||||
}
|
||||
|
||||
// Must be a client span.
|
||||
span_client_->set_name("publish")->end();
|
||||
// We end the connection span because it's a producer and only trace the established.
|
||||
span_main_->end();
|
||||
|
||||
return publishing(source);
|
||||
}
|
||||
|
|
@ -719,6 +782,10 @@ srs_error_t SrsRtmpConn::do_playing(SrsLiveSource* source, SrsLiveConsumer* cons
|
|||
|
||||
srs_trace("start play smi=%dms, mw_sleep=%d, mw_msgs=%d, realtime=%d, tcp_nodelay=%d",
|
||||
srsu2msi(send_min_interval), srsu2msi(mw_sleep), mw_msgs, realtime, tcp_nodelay);
|
||||
|
||||
ISrsApmSpan* span = _srs_apm->span("play-cycle")->set_kind(SrsApmKindProducer)->as_child(span_client_)
|
||||
->attr("realtime", srs_fmt("%d", realtime))->end();
|
||||
SrsAutoFree(ISrsApmSpan, span);
|
||||
|
||||
while (true) {
|
||||
// when source is set to expired, disconnect it.
|
||||
|
|
@ -762,6 +829,11 @@ srs_error_t SrsRtmpConn::do_playing(SrsLiveSource* source, SrsLiveConsumer* cons
|
|||
srs_trace("-> " SRS_CONSTS_LOG_PLAY " time=%d, msgs=%d, okbps=%d,%d,%d, ikbps=%d,%d,%d, mw=%d/%d",
|
||||
(int)pprint->age(), count, kbps->get_send_kbps(), kbps->get_send_kbps_30s(), kbps->get_send_kbps_5m(),
|
||||
kbps->get_recv_kbps(), kbps->get_recv_kbps_30s(), kbps->get_recv_kbps_5m(), srsu2msi(mw_sleep), mw_msgs);
|
||||
|
||||
// TODO: Do not use pithy print for frame span.
|
||||
ISrsApmSpan* sample = _srs_apm->span("play-frame")->set_kind(SrsApmKindConsumer)->as_child(span)
|
||||
->attr("msgs", srs_fmt("%d", count))->attr("kbps", srs_fmt("%d", kbps->get_send_kbps_30s()));
|
||||
srs_freep(sample);
|
||||
}
|
||||
|
||||
if (count <= 0) {
|
||||
|
|
@ -887,6 +959,10 @@ srs_error_t SrsRtmpConn::do_publishing(SrsLiveSource* source, SrsPublishRecvThre
|
|||
srs_utime_t mr_sleep = _srs_config->get_mr_sleep(req->vhost);
|
||||
srs_trace("start publish mr=%d/%d, p1stpt=%d, pnt=%d, tcp_nodelay=%d", mr, srsu2msi(mr_sleep), srsu2msi(publish_1stpkt_timeout), srsu2msi(publish_normal_timeout), tcp_nodelay);
|
||||
}
|
||||
|
||||
ISrsApmSpan* span = _srs_apm->span("publish-cycle")->set_kind(SrsApmKindProducer)->as_child(span_client_)
|
||||
->attr("timeout", srs_fmt("%d", srsu2msi(publish_normal_timeout)))->end();
|
||||
SrsAutoFree(ISrsApmSpan, span);
|
||||
|
||||
int64_t nb_msgs = 0;
|
||||
uint64_t nb_frames = 0;
|
||||
|
|
@ -935,6 +1011,12 @@ srs_error_t SrsRtmpConn::do_publishing(SrsLiveSource* source, SrsPublishRecvThre
|
|||
(int)pprint->age(), kbps->get_send_kbps(), kbps->get_send_kbps_30s(), kbps->get_send_kbps_5m(),
|
||||
kbps->get_recv_kbps(), kbps->get_recv_kbps_30s(), kbps->get_recv_kbps_5m(), mr, srsu2msi(mr_sleep),
|
||||
srsu2msi(publish_1stpkt_timeout), srsu2msi(publish_normal_timeout));
|
||||
|
||||
// TODO: Do not use pithy print for frame span.
|
||||
ISrsApmSpan* sample = _srs_apm->span("publish-frame")->set_kind(SrsApmKindConsumer)->as_child(span)
|
||||
->attr("msgs", srs_fmt("%" PRId64, nb_frames))->attr("kbps", srs_fmt("%d", kbps->get_recv_kbps_30s()));
|
||||
srs_freep(sample);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1453,7 +1535,18 @@ srs_error_t SrsRtmpConn::start()
|
|||
|
||||
srs_error_t SrsRtmpConn::cycle()
|
||||
{
|
||||
srs_error_t err = do_cycle();
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
// Serve the client.
|
||||
err = do_cycle();
|
||||
|
||||
// Final APM span, parent is the last span, not the root span. Note that only client or server kind will be filtered
|
||||
// for error or exception report.
|
||||
ISrsApmSpan* span_final = _srs_apm->span("final")->set_kind(SrsApmKindServer)->as_child(span_client_);
|
||||
SrsAutoFree(ISrsApmSpan, span_final);
|
||||
if (srs_error_code(err) != 0) {
|
||||
span_final->record_error(err)->set_status(SrsApmStatusError, srs_fmt("fail code=%d", srs_error_code(err)));
|
||||
}
|
||||
|
||||
// Update statistic when done.
|
||||
SrsStatistic* stat = SrsStatistic::instance();
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ class ISrsWakable;
|
|||
class SrsCommonMessage;
|
||||
class SrsPacket;
|
||||
class SrsNetworkDelta;
|
||||
class ISrsApmSpan;
|
||||
|
||||
// The simple rtmp client for SRS.
|
||||
class SrsSimpleRtmpClient : public SrsBasicRtmpClient
|
||||
|
|
@ -117,6 +118,10 @@ private:
|
|||
// The create time in milliseconds.
|
||||
// for current connection to log self create time and calculate the living time.
|
||||
int64_t create_time;
|
||||
// The span for tracing connection establishment.
|
||||
ISrsApmSpan* span_main_;
|
||||
ISrsApmSpan* span_connect_;
|
||||
ISrsApmSpan* span_client_;
|
||||
public:
|
||||
SrsRtmpConn(SrsServer* svr, srs_netfd_t c, std::string cip, int port);
|
||||
virtual ~SrsRtmpConn();
|
||||
|
|
|
|||
|
|
@ -618,13 +618,13 @@ void SrsStatistic::dumps_hints_kv(std::stringstream & ss)
|
|||
void SrsStatistic::dumps_cls_summaries(SrsClsSugar* sugar)
|
||||
{
|
||||
if (!vhosts.empty()) {
|
||||
sugar->kvf("vhosts", "%d", (int) vhosts.size());
|
||||
sugar->kv("vhosts", srs_fmt("%d", (int)vhosts.size()));
|
||||
}
|
||||
if (!streams.empty()) {
|
||||
sugar->kvf("streams", "%d", (int) streams.size());
|
||||
sugar->kv("streams", srs_fmt("%d", (int)streams.size()));
|
||||
}
|
||||
if (!clients.empty()) {
|
||||
sugar->kvf("clients", "%d", (int) clients.size());
|
||||
sugar->kv("clients", srs_fmt("%d", (int)clients.size()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -639,37 +639,37 @@ void SrsStatistic::dumps_cls_streams(SrsClsSugars* sugars)
|
|||
SrsClsSugar* sugar = sugars->create();
|
||||
sugar->kv("hint", "stream");
|
||||
sugar->kv("version", RTMP_SIG_SRS_VERSION);
|
||||
sugar->kvf("pid", "%d", getpid());
|
||||
sugar->kv("pid", srs_fmt("%d", getpid()));
|
||||
|
||||
sugar->kv("sid", stream->id);
|
||||
sugar->kv("url", stream->url);
|
||||
|
||||
if (stream->frames->r30s()) {
|
||||
sugar->kvf("fps", "%d", stream->frames->r30s());
|
||||
sugar->kv("fps", srs_fmt("%d", stream->frames->r30s()));
|
||||
}
|
||||
if (stream->width) {
|
||||
sugar->kvf("width", "%d", stream->width);
|
||||
sugar->kv("width", srs_fmt("%d", stream->width));
|
||||
}
|
||||
if (stream->height) {
|
||||
sugar->kvf("height", "%d", stream->height);
|
||||
sugar->kv("height", srs_fmt("%d", stream->height));
|
||||
}
|
||||
|
||||
SrsStatisticClient* pub = find_client(stream->publisher_id);
|
||||
if (pub) {
|
||||
if (pub->kbps->get_recv_kbps_30s()) {
|
||||
sugar->kvf("recv", "%d", pub->kbps->get_recv_kbps_30s());
|
||||
sugar->kv("recv", srs_fmt("%d", pub->kbps->get_recv_kbps_30s()));
|
||||
}
|
||||
if (pub->kbps->get_send_kbps_30s()) {
|
||||
sugar->kvf("send", "%d", pub->kbps->get_send_kbps_30s());
|
||||
sugar->kv("send", srs_fmt("%d", pub->kbps->get_send_kbps_30s()));
|
||||
}
|
||||
}
|
||||
|
||||
sugar->kvf("clients", "%d", stream->nb_clients);
|
||||
sugar->kv("clients", srs_fmt("%d", stream->nb_clients));
|
||||
if (stream->kbps->get_recv_kbps_30s()) {
|
||||
sugar->kvf("recv2", "%d", stream->kbps->get_recv_kbps_30s());
|
||||
sugar->kv("recv2", srs_fmt("%d", stream->kbps->get_recv_kbps_30s()));
|
||||
}
|
||||
if (stream->kbps->get_send_kbps_30s()) {
|
||||
sugar->kvf("send2", "%d", stream->kbps->get_send_kbps_30s());
|
||||
sugar->kv("send2", srs_fmt("%d", stream->kbps->get_send_kbps_30s()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -18,6 +18,19 @@ class SrsBuffer;
|
|||
class SrsClsLogGroupList;
|
||||
class SrsClsLogGroup;
|
||||
class SrsClsLog;
|
||||
class SrsOtelSpan;
|
||||
class SrsApmContext;
|
||||
class SrsAmf0Object;
|
||||
class SrsApmSpan;
|
||||
class SrsOtelResourceSpans;
|
||||
class SrsOtelResource;
|
||||
class SrsOtelScopeSpans;
|
||||
class SrsOtelAttribute;
|
||||
class SrsOtelAnyValue;
|
||||
class SrsOtelScope;
|
||||
class SrsOtelStatus;
|
||||
class SrsOtelEvent;
|
||||
class SrsOtelLink;
|
||||
|
||||
class SrsClsSugar : public ISrsEncoder
|
||||
{
|
||||
|
|
@ -34,7 +47,6 @@ public:
|
|||
public:
|
||||
bool empty();
|
||||
SrsClsSugar* kv(std::string k, std::string v);
|
||||
SrsClsSugar* kvf(std::string k, const char* fmt, ...);
|
||||
};
|
||||
|
||||
class SrsClsSugars : public ISrsEncoder
|
||||
|
|
@ -92,5 +104,426 @@ private:
|
|||
|
||||
extern SrsClsClient* _srs_cls;
|
||||
|
||||
enum SrsApmKind
|
||||
{
|
||||
SrsApmKindUnspecified = 0,
|
||||
SrsApmKindInternal = 1,
|
||||
SrsApmKindServer = 2,
|
||||
SrsApmKindClient = 3,
|
||||
SrsApmKindProducer = 4,
|
||||
SrsApmKindConsumer = 5,
|
||||
};
|
||||
|
||||
enum SrsApmStatus
|
||||
{
|
||||
SrsApmStatusUnset = 0,
|
||||
SrsApmStatusOk = 1,
|
||||
SrsApmStatusError = 2,
|
||||
};
|
||||
|
||||
class SrsOtelExportTraceServiceRequest : public ISrsEncoder
|
||||
{
|
||||
private:
|
||||
// repeated opentelemetry.proto.trace.v1.ResourceSpans resource_spans = 1;
|
||||
std::vector<SrsOtelResourceSpans*> spans_;
|
||||
public:
|
||||
SrsOtelExportTraceServiceRequest();
|
||||
virtual ~SrsOtelExportTraceServiceRequest();
|
||||
public:
|
||||
SrsOtelResourceSpans* append();
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelResourceSpans : public ISrsEncoder
|
||||
{
|
||||
private:
|
||||
// opentelemetry.proto.resource.v1.Resource resource = 1;
|
||||
SrsOtelResource* resource_;
|
||||
// repeated ScopeSpans scope_spans = 2;
|
||||
std::vector<SrsOtelScopeSpans*> spans_;
|
||||
public:
|
||||
SrsOtelResourceSpans();
|
||||
virtual ~SrsOtelResourceSpans();
|
||||
public:
|
||||
SrsOtelResource* resource();
|
||||
SrsOtelScopeSpans* append();
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelResource : public ISrsEncoder
|
||||
{
|
||||
private:
|
||||
// repeated opentelemetry.proto.common.v1.KeyValue attributes = 1;
|
||||
std::vector<SrsOtelAttribute*> attributes_;
|
||||
public:
|
||||
SrsOtelResource();
|
||||
virtual ~SrsOtelResource();
|
||||
public:
|
||||
SrsOtelResource* add_addr(SrsOtelAttribute* v);
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelAttribute : public ISrsEncoder
|
||||
{
|
||||
private:
|
||||
// string key = 1;
|
||||
std::string key_;
|
||||
// AnyValue value = 2;
|
||||
SrsOtelAnyValue* value_;
|
||||
private:
|
||||
SrsOtelAttribute();
|
||||
public:
|
||||
virtual ~SrsOtelAttribute();
|
||||
public:
|
||||
const std::string& key();
|
||||
public:
|
||||
static SrsOtelAttribute* kv(std::string k, std::string v);
|
||||
static SrsOtelAttribute* kvi(std::string k, int64_t v);
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelAnyValue : public ISrsEncoder
|
||||
{
|
||||
private:
|
||||
// Default to string(1). Please change it if use other value, such as int(3).
|
||||
uint8_t used_field_id_;
|
||||
private:
|
||||
// string string_value = 1;
|
||||
std::string string_value_;
|
||||
// bool bool_value = 2;
|
||||
// int64 int_value = 3;
|
||||
int64_t int_value_;
|
||||
// double double_value = 4;
|
||||
// ArrayValue array_value = 5;
|
||||
// KeyValueList kvlist_value = 6;
|
||||
// bytes bytes_value = 7;
|
||||
public:
|
||||
SrsOtelAnyValue();
|
||||
virtual ~SrsOtelAnyValue();
|
||||
public:
|
||||
SrsOtelAnyValue* set_string(const std::string& v);
|
||||
SrsOtelAnyValue* set_int(int64_t v);
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelScopeSpans : public ISrsEncoder
|
||||
{
|
||||
private:
|
||||
// opentelemetry.proto.common.v1.InstrumentationScope scope = 1;
|
||||
SrsOtelScope* scope_;
|
||||
// repeated Span spans = 2;
|
||||
std::vector<SrsOtelSpan*> spans_;
|
||||
public:
|
||||
SrsOtelScopeSpans();
|
||||
virtual ~SrsOtelScopeSpans();
|
||||
public:
|
||||
SrsOtelScope* scope();
|
||||
SrsOtelScopeSpans* swap(std::vector<SrsOtelSpan*>& spans);
|
||||
int size();
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelScope : public ISrsEncoder
|
||||
{
|
||||
public:
|
||||
//string name = 1;
|
||||
std::string name_;
|
||||
//string version = 2;
|
||||
//repeated KeyValue attributes = 3;
|
||||
//uint32 dropped_attributes_count = 4;
|
||||
public:
|
||||
SrsOtelScope();
|
||||
virtual ~SrsOtelScope();
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelSpan : public ISrsEncoder
|
||||
{
|
||||
public:
|
||||
//bytes trace_id = 1; // This field is required.
|
||||
std::string trace_id_;
|
||||
//bytes span_id = 2; // This field is required.
|
||||
std::string span_id_;
|
||||
//string trace_state = 3;
|
||||
//bytes parent_span_id = 4;
|
||||
std::string parent_span_id_;
|
||||
//string name = 5; // This field is required.
|
||||
std::string name_;
|
||||
//SpanKind kind = 6;
|
||||
SrsApmKind kind_;
|
||||
//fixed64 start_time_unix_nano = 7;
|
||||
int64_t start_time_unix_nano_;
|
||||
//fixed64 end_time_unix_nano = 8;
|
||||
int64_t end_time_unix_nano_;
|
||||
//repeated opentelemetry.proto.common.v1.KeyValue attributes = 9;
|
||||
std::vector<SrsOtelAttribute*> attributes_;
|
||||
//uint32 dropped_attributes_count = 10;
|
||||
//repeated Event events = 11;
|
||||
std::vector<SrsOtelEvent*> events_;
|
||||
//uint32 dropped_events_count = 12;
|
||||
//repeated Link links = 13;
|
||||
std::vector<SrsOtelLink*> links_;
|
||||
//uint32 dropped_links_count = 14;
|
||||
//Status status = 15;
|
||||
SrsOtelStatus* status_;
|
||||
public:
|
||||
SrsOtelSpan();
|
||||
virtual ~SrsOtelSpan();
|
||||
public:
|
||||
SrsOtelAttribute* attr(const std::string k);
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelEvent : public ISrsEncoder
|
||||
{
|
||||
public:
|
||||
// fixed64 time_unix_nano = 1;
|
||||
int64_t time_;
|
||||
// string name = 2;
|
||||
std::string name_;
|
||||
// repeated opentelemetry.proto.common.v1.KeyValue attributes = 3;
|
||||
std::vector<SrsOtelAttribute*> attributes_;
|
||||
// uint32 dropped_attributes_count = 4;
|
||||
public:
|
||||
SrsOtelEvent();
|
||||
virtual ~SrsOtelEvent();
|
||||
public:
|
||||
static SrsOtelEvent* create(std::string v);
|
||||
SrsOtelEvent* add_attr(SrsOtelAttribute* v);
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelLink : public ISrsEncoder
|
||||
{
|
||||
private:
|
||||
// bytes trace_id = 1;
|
||||
std::string trace_id_;
|
||||
// bytes span_id = 2;
|
||||
std::string span_id_;
|
||||
// string trace_state = 3;
|
||||
// repeated opentelemetry.proto.common.v1.KeyValue attributes = 4;
|
||||
// uint32 dropped_attributes_count = 5;
|
||||
private:
|
||||
SrsOtelLink();
|
||||
public:
|
||||
virtual ~SrsOtelLink();
|
||||
public:
|
||||
static SrsOtelLink* create();
|
||||
SrsOtelLink* set_id(const std::string& trace_id, const std::string& span_id);
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsOtelStatus : public ISrsEncoder
|
||||
{
|
||||
public:
|
||||
//string message = 2;
|
||||
std::string message_;
|
||||
//StatusCode code = 3;
|
||||
SrsApmStatus code_;
|
||||
public:
|
||||
SrsOtelStatus();
|
||||
virtual ~SrsOtelStatus();
|
||||
public:
|
||||
virtual uint64_t nb_bytes();
|
||||
srs_error_t encode(SrsBuffer* b);
|
||||
};
|
||||
|
||||
class SrsApmContext
|
||||
{
|
||||
private:
|
||||
friend class SrsApmSpan;
|
||||
private:
|
||||
SrsApmSpan* span_;
|
||||
SrsApmContext* parent_;
|
||||
std::vector<SrsApmContext*> childs_;
|
||||
// Encode the id in hex string.
|
||||
std::string str_trace_id_;
|
||||
std::string str_span_id_;
|
||||
private:
|
||||
std::string name_;
|
||||
SrsApmKind kind_;
|
||||
std::string trace_id_;
|
||||
std::string span_id_;
|
||||
// Note that parent span id might not be empty, while parent might be NULL, when extract span from propagator.
|
||||
std::string parent_span_id_;
|
||||
srs_utime_t start_time_;
|
||||
SrsApmStatus status_;
|
||||
std::string description_;
|
||||
srs_error_t err_;
|
||||
std::vector<SrsOtelAttribute*> attributes_;
|
||||
std::vector<SrsOtelLink*> links_;
|
||||
private:
|
||||
bool ended_;
|
||||
private:
|
||||
SrsApmContext(const std::string& name);
|
||||
public:
|
||||
virtual ~SrsApmContext();
|
||||
private:
|
||||
// Update the trace id and format it as hex string id.
|
||||
void set_trace_id(std::string v);
|
||||
// Update the span id and format it as hex string id.
|
||||
void set_span_id(std::string v);
|
||||
public:
|
||||
const char* format_trace_id();
|
||||
const char* format_span_id();
|
||||
SrsApmContext* root();
|
||||
void set_parent(SrsApmContext* parent);
|
||||
void set_status(SrsApmStatus status, const std::string& description);
|
||||
bool all_ended();
|
||||
int count_spans();
|
||||
void update_trace_id(std::string v);
|
||||
void link(SrsApmContext* to);
|
||||
void end();
|
||||
};
|
||||
|
||||
class ISrsApmSpan
|
||||
{
|
||||
private:
|
||||
friend class SrsApmClient;
|
||||
public:
|
||||
ISrsApmSpan() {
|
||||
}
|
||||
virtual ~ISrsApmSpan() {
|
||||
}
|
||||
public:
|
||||
// Get the formatted trace ID in hex string.
|
||||
virtual const char* format_trace_id() {
|
||||
return "";
|
||||
}
|
||||
// Get the formatted span ID in hex string.
|
||||
virtual const char* format_span_id() {
|
||||
return "";
|
||||
}
|
||||
public:
|
||||
// Set the name of span.
|
||||
virtual ISrsApmSpan* set_name(const std::string& name) {
|
||||
return this;
|
||||
}
|
||||
// Set the kind of span.
|
||||
virtual ISrsApmSpan* set_kind(SrsApmKind kind) {
|
||||
return this;
|
||||
}
|
||||
// Set span as child span of parent span.
|
||||
virtual ISrsApmSpan* as_child(ISrsApmSpan* parent) {
|
||||
return this;
|
||||
}
|
||||
// Set the status of span, and error description by fmt.
|
||||
// Note that ignore description except for error status.
|
||||
virtual ISrsApmSpan* set_status(SrsApmStatus status, const std::string& description) {
|
||||
return this;
|
||||
}
|
||||
// RecordError will record err as an exception span event for this span. An
|
||||
// additional call to SetStatus is required if the Status of the Span should
|
||||
// be set to Error, as this method does not change the Span status. If this
|
||||
// span is not being recorded or err is nil then this method does nothing.
|
||||
virtual ISrsApmSpan* record_error(srs_error_t err) {
|
||||
return this;
|
||||
}
|
||||
// Add an attribute with all string kv to span.
|
||||
virtual ISrsApmSpan* attr(const std::string& k, const std::string& v) {
|
||||
return this;
|
||||
}
|
||||
// Link with another span.
|
||||
virtual ISrsApmSpan* link(ISrsApmSpan* span) {
|
||||
return this;
|
||||
}
|
||||
// End the span, snapshot and upload(in a while) a otel span to APM server.
|
||||
virtual ISrsApmSpan* end() {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
class SrsApmSpan : public ISrsApmSpan
|
||||
{
|
||||
private:
|
||||
friend class SrsApmContext;
|
||||
friend class SrsApmClient;
|
||||
private:
|
||||
bool child_;
|
||||
SrsApmContext* ctx_;
|
||||
private:
|
||||
SrsApmSpan(const std::string& name);
|
||||
public:
|
||||
virtual ~SrsApmSpan();
|
||||
// Span operations.
|
||||
public:
|
||||
const char* format_trace_id();
|
||||
const char* format_span_id();
|
||||
ISrsApmSpan* set_name(const std::string& name);
|
||||
ISrsApmSpan* set_kind(SrsApmKind kind);
|
||||
ISrsApmSpan* as_child(ISrsApmSpan* parent);
|
||||
ISrsApmSpan* set_status(SrsApmStatus status, const std::string& description);
|
||||
ISrsApmSpan* record_error(srs_error_t err);
|
||||
ISrsApmSpan* attr(const std::string& k, const std::string& v);
|
||||
ISrsApmSpan* link(ISrsApmSpan* span);
|
||||
ISrsApmSpan* end();
|
||||
// Inject or extract for propagator.
|
||||
private:
|
||||
ISrsApmSpan* extract(SrsAmf0Object* h);
|
||||
ISrsApmSpan* inject(SrsAmf0Object* h);
|
||||
std::string text_propagator();
|
||||
// Store or load with coroutine context.
|
||||
private:
|
||||
ISrsApmSpan* store();
|
||||
static ISrsApmSpan* load();
|
||||
};
|
||||
|
||||
class SrsApmClient
|
||||
{
|
||||
private:
|
||||
bool enabled_;
|
||||
std::string token_;
|
||||
std::string endpoint_;
|
||||
std::string service_name_;
|
||||
bool debug_logging_;
|
||||
std::vector<SrsOtelSpan*> spans_;
|
||||
public:
|
||||
SrsApmClient();
|
||||
virtual ~SrsApmClient();
|
||||
public:
|
||||
srs_error_t initialize();
|
||||
srs_error_t report();
|
||||
public:
|
||||
// Create a span with specified name.
|
||||
ISrsApmSpan* span(const std::string& name);
|
||||
// Create dummy span for default.
|
||||
ISrsApmSpan* dummy();
|
||||
public:
|
||||
// Extract and inject for propagator.
|
||||
ISrsApmSpan* extract(ISrsApmSpan* v, SrsAmf0Object* h);
|
||||
ISrsApmSpan* inject(ISrsApmSpan* v, SrsAmf0Object* h);
|
||||
// Store the span to coroutine context.
|
||||
void store(ISrsApmSpan* span);
|
||||
// Get or load span from coroutine context.
|
||||
// Note that a dummy span will be returned if no span in coroutine context.
|
||||
// Note that user should never free the returned span.
|
||||
ISrsApmSpan* load();
|
||||
// Internal APIs.
|
||||
public:
|
||||
void snapshot(SrsOtelSpan* span);
|
||||
};
|
||||
|
||||
extern SrsApmClient* _srs_apm;
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -441,6 +441,7 @@ srs_error_t srs_global_initialize()
|
|||
|
||||
// Initialize global TencentCloud CLS object.
|
||||
_srs_cls = new SrsClsClient();
|
||||
_srs_apm = new SrsApmClient();
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,6 @@
|
|||
|
||||
#define VERSION_MAJOR 5
|
||||
#define VERSION_MINOR 0
|
||||
#define VERSION_REVISION 63
|
||||
#define VERSION_REVISION 64
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -12,6 +12,8 @@
|
|||
#include <sstream>
|
||||
#include <stdarg.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <map>
|
||||
using namespace std;
|
||||
|
||||
bool srs_is_system_control_error(srs_error_t err)
|
||||
|
|
@ -53,6 +55,12 @@ std::string SrsCplxError::description() {
|
|||
stringstream ss;
|
||||
ss << "code=" << code;
|
||||
|
||||
string code_str = srs_error_code_str(this);
|
||||
if (!code_str.empty()) ss << "(" << code_str << ")";
|
||||
|
||||
string code_longstr = srs_error_code_longstr(this);
|
||||
if (!code_longstr.empty()) ss << "(" << code_longstr << ")";
|
||||
|
||||
SrsCplxError* next = this;
|
||||
while (next) {
|
||||
ss << " : " << next->msg;
|
||||
|
|
@ -191,3 +199,65 @@ int SrsCplxError::error_code(SrsCplxError* err)
|
|||
return err? err->code : ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
#define SRS_STRERRNO_GEN(n, v, m, s) {(SrsErrorCode)v, m, s},
|
||||
static struct
|
||||
{
|
||||
SrsErrorCode code;
|
||||
const char* name;
|
||||
const char* descripton;
|
||||
} _srs_strerror_tab[] = {
|
||||
#ifndef _WIN32
|
||||
{ERROR_SUCCESS, "Success", "Success"},
|
||||
#endif
|
||||
SRS_ERRNO_MAP_SYSTEM(SRS_STRERRNO_GEN)
|
||||
SRS_ERRNO_MAP_RTMP(SRS_STRERRNO_GEN)
|
||||
SRS_ERRNO_MAP_APP(SRS_STRERRNO_GEN)
|
||||
SRS_ERRNO_MAP_HTTP(SRS_STRERRNO_GEN)
|
||||
SRS_ERRNO_MAP_RTC(SRS_STRERRNO_GEN)
|
||||
SRS_ERRNO_MAP_SRT(SRS_STRERRNO_GEN)
|
||||
SRS_ERRNO_MAP_USER(SRS_STRERRNO_GEN)
|
||||
};
|
||||
#undef SRS_STRERRNO_GEN
|
||||
|
||||
std::string SrsCplxError::error_code_str(SrsCplxError* err)
|
||||
{
|
||||
static string not_found = "";
|
||||
static std::map<SrsErrorCode, string> error_map;
|
||||
|
||||
// Build map if empty.
|
||||
if (error_map.empty()) {
|
||||
for (int i = 0; i < (int)(sizeof(_srs_strerror_tab) / sizeof(_srs_strerror_tab[0])); i++) {
|
||||
SrsErrorCode code = _srs_strerror_tab[i].code;
|
||||
error_map[code] = _srs_strerror_tab[i].name;
|
||||
}
|
||||
}
|
||||
|
||||
std::map<SrsErrorCode, string>::iterator it = error_map.find((SrsErrorCode)srs_error_code(err));
|
||||
if (it == error_map.end()) {
|
||||
return not_found;
|
||||
}
|
||||
|
||||
return it->second;
|
||||
}
|
||||
|
||||
std::string SrsCplxError::error_code_longstr(SrsCplxError* err)
|
||||
{
|
||||
static string not_found = "";
|
||||
static std::map<SrsErrorCode, string> error_map;
|
||||
|
||||
// Build map if empty.
|
||||
if (error_map.empty()) {
|
||||
for (int i = 0; i < (int)(sizeof(_srs_strerror_tab) / sizeof(_srs_strerror_tab[0])); i++) {
|
||||
SrsErrorCode code = _srs_strerror_tab[i].code;
|
||||
error_map[code] = _srs_strerror_tab[i].descripton;
|
||||
}
|
||||
}
|
||||
|
||||
std::map<SrsErrorCode, string>::iterator it = error_map.find((SrsErrorCode)srs_error_code(err));
|
||||
if (it == error_map.end()) {
|
||||
return not_found;
|
||||
}
|
||||
|
||||
return it->second;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -11,378 +11,378 @@
|
|||
|
||||
#include <string>
|
||||
|
||||
// For srs-librtmp, @see https://github.com/ossrs/srs/issues/213
|
||||
/**************************************************/
|
||||
/* The system error. */
|
||||
#define SRS_ERRNO_MAP_SYSTEM(XX) \
|
||||
XX(ERROR_SOCKET_CREATE , 1000, "SocketCreate", "Create socket fd failed") \
|
||||
XX(ERROR_SOCKET_SETREUSE , 1001, "SocketReuse", "Setup socket reuse option failed") \
|
||||
XX(ERROR_SOCKET_BIND , 1002, "SocketBind", "Bind socket failed") \
|
||||
XX(ERROR_SOCKET_LISTEN , 1003, "SocketListen", "Listen at specified port failed") \
|
||||
XX(ERROR_SOCKET_CLOSED , 1004, "SocketClosed", "Socket is closed") \
|
||||
XX(ERROR_SOCKET_GET_PEER_NAME , 1005, "SocketPeerName", "Socket get peer name failed") \
|
||||
XX(ERROR_SOCKET_GET_PEER_IP , 1006, "SocketPeerIp", "Socket get peer ip failed") \
|
||||
XX(ERROR_SOCKET_READ , 1007, "SocketRead", "Socket read data failed") \
|
||||
XX(ERROR_SOCKET_READ_FULLY , 1008, "SocketReadFully", "Socket fully read data failed") \
|
||||
XX(ERROR_SOCKET_WRITE , 1009, "SocketWrite", "Socket write data failed") \
|
||||
XX(ERROR_SOCKET_WAIT , 1010, "SocketWait", "Socket wait for ready") \
|
||||
XX(ERROR_SOCKET_TIMEOUT , 1011, "SocketTimeout", "Socket io timeout") \
|
||||
XX(ERROR_SOCKET_CONNECT , 1012, "SocketConnect", "Connect to server by socket failed") \
|
||||
XX(ERROR_ST_SET_EPOLL , 1013, "StSetEpoll", "Setup ST with epoll failed") \
|
||||
XX(ERROR_ST_INITIALIZE , 1014, "StInitialize", "Initialize ST failed") \
|
||||
XX(ERROR_ST_OPEN_SOCKET , 1015, "StOpenSocket", "ST open socket failed") \
|
||||
XX(ERROR_ST_CREATE_LISTEN_THREAD , 1016, "StListenThread", "ST create listen thread") \
|
||||
XX(ERROR_ST_CREATE_CYCLE_THREAD , 1017, "StCycleThread", "ST create cycle thread") \
|
||||
XX(ERROR_ST_CONNECT , 1018, "StConnect", "ST connect server failed") \
|
||||
XX(ERROR_SYSTEM_PACKET_INVALID , 1019, "RtmpInvalidPacket", "Got invalid RTMP packet to codec") \
|
||||
XX(ERROR_SYSTEM_CLIENT_INVALID , 1020, "RtmpInvalidClient", "Got invalid RTMP client neither publisher nor player") \
|
||||
XX(ERROR_SYSTEM_ASSERT_FAILED , 1021, "SystemAssert", "System assert failed for fatal error") \
|
||||
XX(ERROR_READER_BUFFER_OVERFLOW , 1022, "FastStreamGrow", "Fast stream buffer grow failed") \
|
||||
XX(ERROR_SYSTEM_CONFIG_INVALID , 1023, "ConfigInvalid", "Configuration is invalid") \
|
||||
XX(ERROR_SYSTEM_STREAM_BUSY , 1028, "StreamBusy", "Stream already exists or busy") \
|
||||
XX(ERROR_SYSTEM_IP_INVALID , 1029, "IpInvalid", "Retrieve IP failed") \
|
||||
XX(ERROR_SYSTEM_FORWARD_LOOP , 1030, "RtmpForwardLoop", "Infinity loop for RTMP forwarding") \
|
||||
XX(ERROR_SYSTEM_WAITPID , 1031, "DaemonWaitPid", "Wait pid failed for daemon process") \
|
||||
XX(ERROR_SYSTEM_BANDWIDTH_KEY , 1032, "BandwidthKey", "Invalid key for RTMP bandwidth check") \
|
||||
XX(ERROR_SYSTEM_BANDWIDTH_DENIED , 1033, "BandwidthDenied", "Denied for RTMP bandwidth check") \
|
||||
XX(ERROR_SYSTEM_PID_ACQUIRE , 1034, "PidFileAcquire", "SRS process exists so that acquire pid file failed") \
|
||||
XX(ERROR_SYSTEM_PID_ALREADY_RUNNING , 1035, "PidFileProcessExists", "Exists SRS process specified by pid file") \
|
||||
XX(ERROR_SYSTEM_PID_LOCK , 1036, "PidFileLock", "SRS process exists so that lock pid file failed") \
|
||||
XX(ERROR_SYSTEM_PID_TRUNCATE_FILE , 1037, "PidFileTruncate", "SRS process exists so that truncate pid file failed") \
|
||||
XX(ERROR_SYSTEM_PID_WRITE_FILE , 1038, "PidFileWrite", "SRS process exists so that write pid file failed") \
|
||||
XX(ERROR_SYSTEM_PID_GET_FILE_INFO , 1039, "PidFileQuery", "SRS process exists so that query pid file failed") \
|
||||
XX(ERROR_SYSTEM_PID_SET_FILE_INFO , 1040, "PidFileUpdate", "SRS process exists so that update pid file failed") \
|
||||
XX(ERROR_SYSTEM_FILE_ALREADY_OPENED , 1041, "FileOpened", "File open failed for already opened") \
|
||||
XX(ERROR_SYSTEM_FILE_OPENE , 1042, "FileOpen", "Failed to open file") \
|
||||
XX(ERROR_SYSTEM_FILE_CLOSE , 1043, "FileClose", "Failed to close file") \
|
||||
XX(ERROR_SYSTEM_FILE_READ , 1044, "FileRead", "Failed to read data from file") \
|
||||
XX(ERROR_SYSTEM_FILE_WRITE , 1045, "FileWrite", "Failed to write data to file") \
|
||||
XX(ERROR_SYSTEM_FILE_EOF , 1046, "FileEof", "File is EOF or end of file") \
|
||||
XX(ERROR_SYSTEM_FILE_RENAME , 1047, "FileRename", "Failed to rename file") \
|
||||
XX(ERROR_SYSTEM_CREATE_PIPE , 1048, "PipeCreate", "Create pipe for signal failed") \
|
||||
XX(ERROR_SYSTEM_FILE_SEEK , 1049, "FileSeek", "Failed to seek in file") \
|
||||
XX(ERROR_SYSTEM_IO_INVALID , 1050, "IOInvalid", "Invalid IO operation") \
|
||||
XX(ERROR_ST_EXCEED_THREADS , 1051, "StThreadsExceed", "ST exceed max threads") \
|
||||
XX(ERROR_SYSTEM_SECURITY , 1052, "SecurityCheck", "Referer security check failed") \
|
||||
XX(ERROR_SYSTEM_SECURITY_DENY , 1053, "SecurityDeny", "Referer security failed for deny rules") \
|
||||
XX(ERROR_SYSTEM_SECURITY_ALLOW , 1054, "SecurityAllow", "Referer security failed for allow rules") \
|
||||
XX(ERROR_SYSTEM_TIME , 1055, "SystemTime", "Invalid system time") \
|
||||
XX(ERROR_SYSTEM_DIR_EXISTS , 1056, "DirExists", "Directory already exists") \
|
||||
XX(ERROR_SYSTEM_CREATE_DIR , 1057, "DirCreate", "Create directory failed") \
|
||||
XX(ERROR_SYSTEM_KILL , 1058, "ProcessKill", "Send signal to process by kill failed") \
|
||||
XX(ERROR_SYSTEM_CONFIG_PERSISTENCE , 1059, "ConfigPersistence", "Failed to persistence configuration") \
|
||||
XX(ERROR_SYSTEM_CONFIG_RAW , 1060, "ConfigRaw", "RAW API serves failed") \
|
||||
XX(ERROR_SYSTEM_CONFIG_RAW_DISABLED , 1061, "ConfigRawDisable", "RAW API is disabled") \
|
||||
XX(ERROR_SYSTEM_CONFIG_RAW_NOT_ALLOWED , 1062, "ConfigRawNotAllowed", "RAW API is not allowed") \
|
||||
XX(ERROR_SYSTEM_CONFIG_RAW_PARAMS , 1063, "ConfigRawParams", "RAW API parameters are invalid") \
|
||||
XX(ERROR_SYSTEM_FILE_NOT_EXISTS , 1064, "FileNotFound", "Request file does not exists") \
|
||||
XX(ERROR_SYSTEM_HOURGLASS_RESOLUTION , 1065, "TimerResolution", "Resolution for timer or hourglass is invalid") \
|
||||
XX(ERROR_SYSTEM_DNS_RESOLVE , 1066, "DnsResolve", "Failed to parse domain name by DNS") \
|
||||
XX(ERROR_SYSTEM_FRAGMENT_UNLINK , 1067, "FileRemove", "Failed to remove or unlink file") \
|
||||
XX(ERROR_SYSTEM_FRAGMENT_RENAME , 1068, "FileRename", "Failed to rename file segment") \
|
||||
XX(ERROR_THREAD_DISPOSED , 1069, "StThreadDispose", "Failed for ST thread is disposed") \
|
||||
XX(ERROR_THREAD_INTERRUPED , 1070, "StThreadInterrupt", "ST thread is interrupted") \
|
||||
XX(ERROR_THREAD_TERMINATED , 1071, "StThreadTerminate", "ST thread is terminated") \
|
||||
XX(ERROR_THREAD_DUMMY , 1072, "StThreadDummy", "Can not operate ST dummy thread") \
|
||||
XX(ERROR_ASPROCESS_PPID , 1073, "SystemAsProcess", "As-process does not support pid change") \
|
||||
XX(ERROR_EXCEED_CONNECTIONS , 1074, "ConnectionsExceed", "Failed for exceed system max connections") \
|
||||
XX(ERROR_SOCKET_SETKEEPALIVE , 1075, "SocketKeepAlive", "Failed to set socket option SO_KEEPALIVE") \
|
||||
XX(ERROR_SOCKET_NO_NODELAY , 1076, "SocketNoDelay", "Failed to set socket option TCP_NODELAY") \
|
||||
XX(ERROR_SOCKET_SNDBUF , 1077, "SocketSendBuffer", "Failed to set socket option SO_SNDBUF") \
|
||||
XX(ERROR_THREAD_STARTED , 1078, "StThreadStarted", "ST thread is already started") \
|
||||
XX(ERROR_SOCKET_SETREUSEADDR , 1079, "SocketReuseAddr", "Failed to set socket option SO_REUSEADDR") \
|
||||
XX(ERROR_SOCKET_SETCLOSEEXEC , 1080, "SocketCloseExec", "Failed to set socket option FD_CLOEXEC") \
|
||||
XX(ERROR_SOCKET_ACCEPT , 1081, "SocketAccept", "Accpet client socket failed") \
|
||||
XX(ERROR_THREAD_CREATE , 1082, "StThreadCreate", "Create ST thread failed") \
|
||||
XX(ERROR_THREAD_FINISHED , 1083, "StThreadFinished", "ST thread finished without error") \
|
||||
XX(ERROR_PB_NO_SPACE , 1084, "ProtobufNoSpace", "Failed to encode protobuf for no buffer space left") \
|
||||
XX(ERROR_CLS_INVALID_CONFIG , 1085, "ClsConfig", "Invalid configuration for TencentCloud CLS") \
|
||||
XX(ERROR_CLS_EXCEED_SIZE , 1086, "ClsExceedSize", "CLS logs exceed max size 5MB") \
|
||||
XX(ERROR_APM_EXCEED_SIZE , 1087, "ApmExceedSize", "APM logs exceed max size 5MB")
|
||||
|
||||
/**************************************************/
|
||||
/* RTMP protocol error. */
|
||||
#define SRS_ERRNO_MAP_RTMP(XX) \
|
||||
XX(ERROR_RTMP_PLAIN_REQUIRED , 2000, "RtmpPlainRequired", "RTMP handshake requires plain text") \
|
||||
XX(ERROR_RTMP_CHUNK_START , 2001, "RtmpChunkStart", "RTMP packet must be fresh chunk") \
|
||||
XX(ERROR_RTMP_MSG_INVALID_SIZE , 2002, "RtmpMsgSize", "Invalid RTMP message size") \
|
||||
XX(ERROR_RTMP_AMF0_DECODE , 2003, "Amf0Decode", "Decode AMF0 message failed") \
|
||||
XX(ERROR_RTMP_AMF0_INVALID , 2004, "Amf0Invalid", "Invalid AMF0 message type") \
|
||||
XX(ERROR_RTMP_REQ_CONNECT , 2005, "RtmpConnect", "Invalid RTMP connect packet without tcUrl") \
|
||||
XX(ERROR_RTMP_REQ_TCURL , 2006, "RtmpTcUrl", "Failed to discover tcUrl from request") \
|
||||
XX(ERROR_RTMP_MESSAGE_DECODE , 2007, "RtmpDecode", "Failed to decode RTMP packet") \
|
||||
XX(ERROR_RTMP_MESSAGE_ENCODE , 2008, "RtmpEncode", "Failed to encode RTMP packet") \
|
||||
XX(ERROR_RTMP_AMF0_ENCODE , 2009, "Amf0Encode", "Encode AMF0 message failed") \
|
||||
XX(ERROR_RTMP_CHUNK_SIZE , 2010, "RtmpChunkSize", "Invalid RTMP chunk size") \
|
||||
XX(ERROR_RTMP_TRY_SIMPLE_HS , 2011, "RtmpTrySimple", "Handshake failed please try simple strategy") \
|
||||
XX(ERROR_RTMP_CH_SCHEMA , 2012, "RtmpSchema", "RTMP handshake failed for schema changed") \
|
||||
XX(ERROR_RTMP_PACKET_SIZE , 2013, "RtmpPacketSize", "RTMP packet size changed in chunks") \
|
||||
XX(ERROR_RTMP_VHOST_NOT_FOUND , 2014, "NoVhost", "Request vhost not found") \
|
||||
XX(ERROR_RTMP_ACCESS_DENIED , 2015, "SecurityDenied", "Referer check failed and access denied") \
|
||||
XX(ERROR_RTMP_HANDSHAKE , 2016, "RtmpHandshake", "RTMP handshake failed") \
|
||||
XX(ERROR_RTMP_NO_REQUEST , 2017, "RtmpNoRequest", "Invalid RTMP response for no request found") \
|
||||
XX(ERROR_RTMP_HS_SSL_REQUIRE , 2018, "RtmpSslRequire", "RTMP handshake failed for SSL required") \
|
||||
XX(ERROR_RTMP_DURATION_EXCEED , 2019, "DurationExceed", "Failed for exceed max service duration") \
|
||||
XX(ERROR_RTMP_EDGE_PLAY_STATE , 2020, "EdgePlayState", "Invalid edge state for play") \
|
||||
XX(ERROR_RTMP_EDGE_PUBLISH_STATE , 2021, "EdgePublishState", "Invalid edge state for publish") \
|
||||
XX(ERROR_RTMP_EDGE_PROXY_PULL , 2022, "EdgeProxyPull", "Failed for edge pull state") \
|
||||
XX(ERROR_RTMP_EDGE_RELOAD , 2023, "EdgeReload", "Vhost with edge does not support reload") \
|
||||
XX(ERROR_RTMP_AGGREGATE , 2024, "RtmpAggregate", "Failed to handle RTMP aggregate message") \
|
||||
XX(ERROR_RTMP_BWTC_DATA , 2025, "BandwidthData", "Invalid data for bandwidth check") \
|
||||
XX(ERROR_OpenSslCreateDH , 2026, "SslCreateDh", "Failed to create DH for SSL") \
|
||||
XX(ERROR_OpenSslCreateP , 2027, "SslCreateP", "Failed to create P by BN for SSL") \
|
||||
XX(ERROR_OpenSslCreateG , 2028, "SslCreateG", "Failed to create G by BN for SSL") \
|
||||
XX(ERROR_OpenSslParseP1024 , 2029, "SslParseP1024", "Failed to parse P1024 for SSL") \
|
||||
XX(ERROR_OpenSslSetG , 2030, "SslSetG", "Failed to set G by BN for SSL") \
|
||||
XX(ERROR_OpenSslGenerateDHKeys , 2031, "SslDhKeys", "Failed to generate DH keys for SSL") \
|
||||
XX(ERROR_OpenSslCopyKey , 2032, "SslCopyKey", "Failed to copy key for SSL") \
|
||||
XX(ERROR_OpenSslSha256Update , 2033, "SslSha256Update", "Failed to update HMAC sha256 for SSL") \
|
||||
XX(ERROR_OpenSslSha256Init , 2034, "SslSha256Init", "Failed to init HMAC sha256 for SSL") \
|
||||
XX(ERROR_OpenSslSha256Final , 2035, "SslSha256Final", "Failed to final HMAC sha256 for SSL") \
|
||||
XX(ERROR_OpenSslSha256EvpDigest , 2036, "SslSha256Digest", "Failed to calculate evp digest of HMAC sha256 for SSL") \
|
||||
XX(ERROR_OpenSslSha256DigestSize , 2037, "SslSha256Size", "Invalid digest size of HMAC sha256 of SSL") \
|
||||
XX(ERROR_OpenSslGetPeerPublicKey , 2038, "SslPublicKey", "Failed to get peer public key of SSL") \
|
||||
XX(ERROR_OpenSslComputeSharedKey , 2039, "SslShareKey", "Failed to get shared key of SSL") \
|
||||
XX(ERROR_RTMP_MIC_CHUNKSIZE_CHANGED , 2040, "RtmpMicChunk", "Invalid RTMP mic for chunk size changed") \
|
||||
XX(ERROR_RTMP_MIC_CACHE_OVERFLOW , 2041, "RtmpMicCache", "Invalid RTMP mic for cache overflow") \
|
||||
XX(ERROR_RTSP_TOKEN_NOT_NORMAL , 2042, "RtspToken", "Invalid RTSP token state not normal") \
|
||||
XX(ERROR_RTSP_REQUEST_HEADER_EOF , 2043, "RtspHeaderEof", "Invalid RTSP request for header EOF") \
|
||||
XX(ERROR_RTP_HEADER_CORRUPT , 2044, "RtspHeaderCorrupt", "Invalid RTSP RTP packet for header corrupt") \
|
||||
XX(ERROR_RTP_TYPE96_CORRUPT , 2045, "RtspP96Corrupt", "Invalid RTSP RTP packet for P96 corrupt") \
|
||||
XX(ERROR_RTP_TYPE97_CORRUPT , 2046, "RtspP97Corrupt", "Invalid RTSP RTP packet for P97 corrupt") \
|
||||
XX(ERROR_RTSP_AUDIO_CONFIG , 2047, "RtspAudioConfig", "RTSP no audio sequence header config") \
|
||||
XX(ERROR_RTMP_STREAM_NOT_FOUND , 2048, "StreamNotFound", "Request stream is not found") \
|
||||
XX(ERROR_RTMP_CLIENT_NOT_FOUND , 2049, "ClientNotFound", "Request client is not found") \
|
||||
XX(ERROR_OpenSslCreateHMAC , 2050, "SslCreateHmac", "Failed to create HMAC for SSL") \
|
||||
XX(ERROR_RTMP_STREAM_NAME_EMPTY , 2051, "StreamNameEmpty", "Invalid stream for name is empty") \
|
||||
XX(ERROR_HTTP_HIJACK , 2052, "HttpHijack", "Failed to hijack HTTP handler") \
|
||||
XX(ERROR_RTMP_MESSAGE_CREATE , 2053, "MessageCreate", "Failed to create shared pointer message") \
|
||||
XX(ERROR_RTMP_PROXY_EXCEED , 2054, "RtmpProxy", "Failed to decode message of RTMP proxy") \
|
||||
XX(ERROR_RTMP_CREATE_STREAM_DEPTH , 2055, "RtmpIdentify", "Failed to identify RTMP client") \
|
||||
XX(ERROR_CONTROL_REDIRECT , 2997, "RtmpRedirect", "RTMP 302 redirection") \
|
||||
XX(ERROR_CONTROL_RTMP_CLOSE , 2998, "RtmpClose", "RTMP connection is closed") \
|
||||
XX(ERROR_CONTROL_REPUBLISH , 2999, "RtmpRepublish", "RTMP stream is republished")
|
||||
|
||||
/**************************************************/
|
||||
/* The application level errors. */
|
||||
#define SRS_ERRNO_MAP_APP(XX) \
|
||||
XX(ERROR_HLS_METADATA , 3000, "HlsMetadata", "HLS metadata is invalid") \
|
||||
XX(ERROR_HLS_DECODE_ERROR , 3001, "HlsDecode", "HLS decode av stream failed") \
|
||||
XX(ERROR_HLS_CREATE_DIR , 3002, "HlsCreateDir", "HLS create directory failed") \
|
||||
XX(ERROR_HLS_OPEN_FAILED , 3003, "HlsOpenFile", "HLS open m3u8 file failed") \
|
||||
XX(ERROR_HLS_WRITE_FAILED , 3004, "HlsWriteFile", "HLS write m3u8 file failed") \
|
||||
XX(ERROR_HLS_AAC_FRAME_LENGTH , 3005, "HlsAacFrame", "HLS decode aac frame size failed") \
|
||||
XX(ERROR_HLS_AVC_SAMPLE_SIZE , 3006, "HlsAvcFrame", "HLS decode avc sample size failed") \
|
||||
XX(ERROR_HTTP_PARSE_URI , 3007, "HttpParseUrl", "HTTP parse url failed") \
|
||||
XX(ERROR_HTTP_DATA_INVALID , 3008, "HttpResponseData", "HTTP response data invalid") \
|
||||
XX(ERROR_HTTP_PARSE_HEADER , 3009, "HttpParseHeader", "HTTP parse header failed") \
|
||||
XX(ERROR_HTTP_HANDLER_MATCH_URL , 3010, "HttpHandlerUrl", "HTTP handler invalid url") \
|
||||
XX(ERROR_HTTP_HANDLER_INVALID , 3011, "HttpHandlerInvalid", "HTTP handler invalid") \
|
||||
XX(ERROR_HTTP_API_LOGS , 3012, "HttpApiLogs", "HTTP API logs invalid") \
|
||||
XX(ERROR_HTTP_REMUX_SEQUENCE_HEADER , 3013, "VodNoSequence", "HTTP VoD sequence header not found") \
|
||||
XX(ERROR_HTTP_REMUX_OFFSET_OVERFLOW , 3014, "VodOffset", "HTTP VoD request offset overflow") \
|
||||
XX(ERROR_ENCODER_VCODEC , 3015, "FFmpegNoCodec", "FFmpeg no audio and video codec") \
|
||||
XX(ERROR_ENCODER_OUTPUT , 3016, "FFmpegNoOutput", "FFmpeg no output url") \
|
||||
XX(ERROR_ENCODER_ACHANNELS , 3017, "FFmpegChannels", "Invalid audio channels for FFmpeg") \
|
||||
XX(ERROR_ENCODER_ASAMPLE_RATE , 3018, "FFmpegSampleRate", "Invalid audio sample rate for FFmpeg") \
|
||||
XX(ERROR_ENCODER_ABITRATE , 3019, "FFmpegAudioBitrate", "Invalid audio bitrate for FFmpeg") \
|
||||
XX(ERROR_ENCODER_ACODEC , 3020, "FFmpegAudioCodec", "Invalid audio codec for FFmpeg") \
|
||||
XX(ERROR_ENCODER_VPRESET , 3021, "FFmpegPreset", "Invalid video preset for FFmpeg") \
|
||||
XX(ERROR_ENCODER_VPROFILE , 3022, "FFmpegProfile", "Invalid video profile for FFmpeg") \
|
||||
XX(ERROR_ENCODER_VTHREADS , 3023, "FFmpegThreads", "Invalid threads config for FFmpeg") \
|
||||
XX(ERROR_ENCODER_VHEIGHT , 3024, "FFmpegHeight", "Invalid video height for FFmpeg") \
|
||||
XX(ERROR_ENCODER_VWIDTH , 3025, "FFmpegWidth", "Invalid video width for FFmpeg") \
|
||||
XX(ERROR_ENCODER_VFPS , 3026, "FFmpegFps", "Invalid video FPS for FFmpeg") \
|
||||
XX(ERROR_ENCODER_VBITRATE , 3027, "FFmpegVideoBitrate", "Invalid video bitrate for FFmpeg") \
|
||||
XX(ERROR_ENCODER_FORK , 3028, "FFmpegFork", "Failed to fork FFmpeg trancoder process") \
|
||||
XX(ERROR_ENCODER_LOOP , 3029, "FFmpegLoop", "FFmpeg transcoder infinite loop detected") \
|
||||
XX(ERROR_FORK_OPEN_LOG , 3030, "FFmpegLog", "Open log file failed for FFmpeg") \
|
||||
XX(ERROR_FORK_DUP2_LOG , 3031, "FFmpegDup2", "Dup2 redirect log failed for FFmpeg") \
|
||||
XX(ERROR_ENCODER_PARSE , 3032, "FFmpegBinary", "FFmpeg binary not found") \
|
||||
XX(ERROR_ENCODER_NO_INPUT , 3033, "FFmpegNoInput", "No input url for FFmpeg") \
|
||||
XX(ERROR_ENCODER_NO_OUTPUT , 3034, "FFmpegNoOutput", "No output url for FFmpeg") \
|
||||
XX(ERROR_ENCODER_INPUT_TYPE , 3035, "FFmpegInputType", "Invalid input type for FFmpeg") \
|
||||
XX(ERROR_KERNEL_FLV_HEADER , 3036, "FlvHeader", "FLV decode header failed") \
|
||||
XX(ERROR_KERNEL_FLV_STREAM_CLOSED , 3037, "VodFlvClosed", "FLV file closed for HTTP VoD") \
|
||||
XX(ERROR_KERNEL_STREAM_INIT , 3038, "StreamInit", "Init kernel stream failed") \
|
||||
XX(ERROR_EDGE_VHOST_REMOVED , 3039, "EdgeVhostRemoved", "Vhost is removed for edge") \
|
||||
XX(ERROR_HLS_AVC_TRY_OTHERS , 3040, "AvcTryOthers", "Should try other strategies for AVC decoder") \
|
||||
XX(ERROR_H264_API_NO_PREFIXED , 3041, "AvcAnnexbPrefix", "No annexb prefix for AVC decoder") \
|
||||
XX(ERROR_FLV_INVALID_VIDEO_TAG , 3042, "FlvInvalidTag", "Invalid video tag for FLV") \
|
||||
XX(ERROR_H264_DROP_BEFORE_SPS_PPS , 3043, "DropBeforeSequence", "Drop frames before get sps and pps") \
|
||||
XX(ERROR_H264_DUPLICATED_SPS , 3044, "SpsDuplicate", "Got duplicated sps for video") \
|
||||
XX(ERROR_H264_DUPLICATED_PPS , 3045, "PpsDuplicate", "Got duplicated pps for video") \
|
||||
XX(ERROR_AAC_REQUIRED_ADTS , 3046, "AacAdtsRequire", "ADTS header is required for AAC") \
|
||||
XX(ERROR_AAC_ADTS_HEADER , 3047, "AacAdtsHeader", "Failed to parse ADTS header for AAC") \
|
||||
XX(ERROR_AAC_DATA_INVALID , 3048, "AacData", "Failed to parse data for AAC") \
|
||||
XX(ERROR_HLS_TRY_MP3 , 3049, "HlsTryMp3", "Should try mp3 when codec detected") \
|
||||
XX(ERROR_HTTP_DVR_DISABLED , 3050, "DvrDisabled", "Failed for DVR disabled") \
|
||||
XX(ERROR_HTTP_DVR_REQUEST , 3051, "DvrRequest", "Failed for DVR request") \
|
||||
XX(ERROR_HTTP_JSON_REQUIRED , 3052, "JsonRequired", "Failed for JSON required") \
|
||||
XX(ERROR_HTTP_DVR_CREATE_REQUEST , 3053, "DvrCreate", "Failed for DVR create request") \
|
||||
XX(ERROR_HTTP_DVR_NO_TAEGET , 3054, "DvrNoTarget", "Failed for DVR no target") \
|
||||
XX(ERROR_ADTS_ID_NOT_AAC , 3055, "AacAdtsId", "Failed for ADTS id not AAC") \
|
||||
XX(ERROR_HDS_OPEN_F4M_FAILED , 3056, "HdsOpenF4m", "Failed to open F4m file for HDS") \
|
||||
XX(ERROR_HDS_WRITE_F4M_FAILED , 3057, "HdsWriteF4m", "Failed to write F4m file for HDS") \
|
||||
XX(ERROR_HDS_OPEN_BOOTSTRAP_FAILED , 3058, "HdsOpenBoot", "Failed to open bootstrap for HDS") \
|
||||
XX(ERROR_HDS_WRITE_BOOTSTRAP_FAILED , 3059, "HdsWriteBoot", "Failed to write bootstrap for HDS") \
|
||||
XX(ERROR_HDS_OPEN_FRAGMENT_FAILED , 3060, "HdsOpenFragment", "Failed to open fragment file for HDS") \
|
||||
XX(ERROR_HDS_WRITE_FRAGMENT_FAILED , 3061, "HdsWriteFragment", "Failed to write fragment file for HDS") \
|
||||
XX(ERROR_HLS_NO_STREAM , 3062, "HlsNoStream", "No stream configured for HLS") \
|
||||
XX(ERROR_JSON_LOADS , 3063, "JsonLoads", "Failed for JSOn loads") \
|
||||
XX(ERROR_RESPONSE_CODE , 3064, "HttpResponseCode", "No code in HTTP response json object") \
|
||||
XX(ERROR_RESPONSE_DATA , 3065, "HttpResponseData", "Invalid HTTP response body data") \
|
||||
XX(ERROR_REQUEST_DATA , 3066, "HttpRequestData", "Invalid HTTP request body data") \
|
||||
XX(ERROR_EDGE_PORT_INVALID , 3067, "EdgePort", "Invalid edge port") \
|
||||
XX(ERROR_EXPECT_FILE_IO , 3068, "VodNotFile", "HTTP VoD not file stream") \
|
||||
XX(ERROR_MP4_BOX_OVERFLOW , 3069, "Mp4BoxOverflow", "Only support 32 bits box for MP4") \
|
||||
XX(ERROR_MP4_BOX_REQUIRE_SPACE , 3070, "Mp4BoxNoSpace", "Failed to decode MP4 box for no buffer space") \
|
||||
XX(ERROR_MP4_BOX_ILLEGAL_TYPE , 3071, "Mp4BoxType", "Invalid box type for MP4") \
|
||||
XX(ERROR_MP4_BOX_ILLEGAL_SCHEMA , 3072, "Mp4BoxNoFtyp", "Missing box FTYP for MP4") \
|
||||
XX(ERROR_MP4_BOX_STRING , 3073, "Mp4BoxString", "MP4 string corrupt") \
|
||||
XX(ERROR_MP4_BOX_ILLEGAL_BRAND , 3074, "Mp4BoxBrand", "Invalid FTYP brand for MP4") \
|
||||
XX(ERROR_MP4_ESDS_SL_Config , 3075, "Mp4BoxEsdsSl", "Invalid SL config for ESDS box for MP4") \
|
||||
XX(ERROR_MP4_ILLEGAL_MOOV , 3076, "Mp4BoxMoov", "Invalid MOOV box for MP4") \
|
||||
XX(ERROR_MP4_ILLEGAL_HANDLER , 3077, "Mp4BoxHandler", "Invalid handler for MP4") \
|
||||
XX(ERROR_MP4_ILLEGAL_TRACK , 3078, "Mp4BoxTrack", "Invalid track box for MP4") \
|
||||
XX(ERROR_MP4_MOOV_OVERFLOW , 3079, "Mp4StszOverflow", "STSZ box size overflow for MP4") \
|
||||
XX(ERROR_MP4_ILLEGAL_SAMPLES , 3080, "Mp4StszSamples", "STSZ box samples invalid") \
|
||||
XX(ERROR_MP4_ILLEGAL_TIMESTAMP , 3081, "Mp4Timestamp", "Invalid timestamp of ctts or stts for MP4") \
|
||||
XX(ERROR_DVR_CANNOT_APPEND , 3082, "DvrAppend", "DVR append data to file failed") \
|
||||
XX(ERROR_DVR_ILLEGAL_PLAN , 3083, "DvrPlan", "Invalid DVR plan") \
|
||||
XX(ERROR_FLV_REQUIRE_SPACE , 3084, "FlvNoSpace", "Failed to decode FLV for no buffer space") \
|
||||
XX(ERROR_MP4_AVCC_CHANGE , 3085, "Mp4AvccChange", "MP4 does not support video AVCC change") \
|
||||
XX(ERROR_MP4_ASC_CHANGE , 3086, "Mp4AscChange", "MP4 does not support audio ASC change") \
|
||||
XX(ERROR_DASH_WRITE_FAILED , 3087, "DashMpdWrite", "DASH write mpd file failed") \
|
||||
XX(ERROR_TS_CONTEXT_NOT_READY , 3088, "TsContexNotReady", "TS context not ready") \
|
||||
XX(ERROR_MP4_ILLEGAL_MOOF , 3089, "Mp4BoxNoMoof", "Missing MP4 box MOOF or no audio video track") \
|
||||
XX(ERROR_MP4_ILLEGAL_MDAT , 3090, "Mp4BoxMdat", "Invalid MDAT header size") \
|
||||
XX(ERROR_OCLUSTER_DISCOVER , 3091, "OriginClusterDiscover", "Failed to discover origin cluster service") \
|
||||
XX(ERROR_OCLUSTER_REDIRECT , 3092, "OriginClusterRedirect", "Failed to redirect origin cluster node") \
|
||||
XX(ERROR_INOTIFY_CREATE , 3093, "InotifyCreate", "Failed to create inotify for config listener") \
|
||||
XX(ERROR_INOTIFY_OPENFD , 3094, "InotifyOpenFd", "Failed to open inotify fd for config listener") \
|
||||
XX(ERROR_INOTIFY_WATCH , 3095, "InotfyWatch", "Failed to watch inotify for config listener") \
|
||||
XX(ERROR_HTTP_URL_UNESCAPE , 3096, "HttpUrlUnescape", "Failed to unescape URL for HTTP") \
|
||||
XX(ERROR_HTTP_WITH_BODY , 3097, "HttpWithBody", "Failed for HTTP body")
|
||||
|
||||
/**************************************************/
|
||||
/* HTTP/StreamCaster protocol error. */
|
||||
#define SRS_ERRNO_MAP_HTTP(XX) \
|
||||
XX(ERROR_HTTP_PATTERN_EMPTY , 4000, "HttpPatternEmpty", "Failed to handle HTTP request for no pattern") \
|
||||
XX(ERROR_HTTP_PATTERN_DUPLICATED , 4001, "HttpPatternDuplicated", "Failed to handle HTTP request for pattern duplicated") \
|
||||
XX(ERROR_HTTP_URL_NOT_CLEAN , 4002, "HttpUrlNotClean", "Failed to handle HTTP request for URL not clean") \
|
||||
XX(ERROR_HTTP_CONTENT_LENGTH , 4003, "HttpContentLength", "Exceed HTTP content length") \
|
||||
XX(ERROR_HTTP_LIVE_STREAM_EXT , 4004, "HttpStreamExt", "Invalid HTTP stream extension") \
|
||||
XX(ERROR_HTTP_STATUS_INVALID , 4005, "HttpStatus", "Invalid HTTP status code") \
|
||||
XX(ERROR_KERNEL_AAC_STREAM_CLOSED , 4006, "AacStreamClosed", "AAC stream is closed") \
|
||||
XX(ERROR_AAC_DECODE_ERROR , 4007, "AacStreamDecode", "Failed to decode AAC stream") \
|
||||
XX(ERROR_KERNEL_MP3_STREAM_CLOSED , 4008, "Mp3StreamClosed", "MP3 stream is closed") \
|
||||
XX(ERROR_MP3_DECODE_ERROR , 4009, "Mp3StreamDecode", "Failed to decode MP3 stream") \
|
||||
XX(ERROR_STREAM_CASTER_ENGINE , 4010, "CasterEngine", "Invalid engine config for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_PORT , 4011, "CasterPort", "Invalid port config for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_HEADER , 4012, "CasterTsHeader", "Invalid ts header for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_SYNC_BYTE , 4013, "CasterTsSync", "Invalid ts sync byte for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_AF , 4014, "CasterTsAdaption", "Invalid ts adaption field for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_CRC32 , 4015, "CasterTsCrc32", "Invalid ts CRC32 checksum for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_PSI , 4016, "CasterTsPsi", "Invalid ts PSI payload for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_PAT , 4017, "CasterTsPat", "Invalid ts PAT program for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_PMT , 4018, "CasterTsPmt", "Invalid ts PMT information for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_PSE , 4019, "CasterTsPse", "Invalid ts PSE payload for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_ES , 4020, "CasterTsEs", "Invalid ts ES stream for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_TS_CODEC , 4021, "CasterTsCodec", "Invalid ts codec for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_AVC_SPS , 4022, "CasterTsAvcSps", "Invalid ts AVC SPS for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_AVC_PPS , 4023, "CasterTsAvcPps", "Invalid ts AVC PPS for stream caster") \
|
||||
XX(ERROR_STREAM_CASTER_FLV_TAG , 4024, "CasterFlvTag", "Invalid flv tag for stream caster") \
|
||||
XX(ERROR_HTTP_RESPONSE_EOF , 4025, "HttpResponseEof", "HTTP response stream is EOF") \
|
||||
XX(ERROR_HTTP_INVALID_CHUNK_HEADER , 4026, "HttpChunkHeader", "Invalid HTTP chunk header") \
|
||||
XX(ERROR_AVC_NALU_UEV , 4027, "AvcNaluUev", "Failed to read UEV for AVC NALU") \
|
||||
XX(ERROR_AAC_BYTES_INVALID , 4028, "AacBytesInvalid", "Invalid bytes for AAC stream") \
|
||||
XX(ERROR_HTTP_REQUEST_EOF , 4029, "HttpRequestEof", "HTTP request stream is EOF") \
|
||||
XX(ERROR_HTTP_302_INVALID , 4038, "HttpRedirectDepth", "Exceed max depth for HTTP redirect") \
|
||||
XX(ERROR_BASE64_DECODE , 4039, "Base64Decode", "Failed to decode the BASE64 content") \
|
||||
XX(ERROR_HTTP_STREAM_EOF , 4040, "HttpStreamEof", "HTTP stream is EOF") \
|
||||
XX(ERROR_HTTPS_NOT_SUPPORTED , 4041, "HttpsNotSupported", "HTTPS is not supported") \
|
||||
XX(ERROR_HTTPS_HANDSHAKE , 4042, "HttpsHandshake", "Failed to do handshake for HTTPS") \
|
||||
XX(ERROR_HTTPS_READ , 4043, "HttpsRead", "Failed to read data from HTTPS stream") \
|
||||
XX(ERROR_HTTPS_WRITE , 4044, "HttpsWrite", "Failed to write data to HTTPS stream") \
|
||||
XX(ERROR_HTTPS_KEY_CRT , 4045, "HttpsSslFile", "Failed to load SSL key or crt file for HTTPS")
|
||||
|
||||
/**************************************************/
|
||||
/* RTC protocol error. */
|
||||
#define SRS_ERRNO_MAP_RTC(XX) \
|
||||
XX(ERROR_RTC_PORT , 5000, "RtcPort", "Invalid RTC config for listen port") \
|
||||
XX(ERROR_RTP_PACKET_CREATE , 5001, "RtcPacketCreate", "Failed to create RTP packet for RTC") \
|
||||
XX(ERROR_OpenSslCreateSSL , 5002, "RtcSslCreate", "RTC create SSL context failed") \
|
||||
XX(ERROR_OpenSslBIOReset , 5003, "RtcSslReset", "RTC reset SSL BIO context failed") \
|
||||
XX(ERROR_OpenSslBIOWrite , 5004, "RtcSslWrite", "RTC write SSL BIO stream failed") \
|
||||
XX(ERROR_OpenSslBIONew , 5005, "RtcSslNew", "RTC create new SSL BIO context failed") \
|
||||
XX(ERROR_RTC_RTP , 5006, "RtcRtpHeader", "Invalid RTP header of packet for RTC") \
|
||||
XX(ERROR_RTC_RTCP , 5007, "RtcRtcpType", "Invalid RTCP packet type for RTC") \
|
||||
XX(ERROR_RTC_STUN , 5008, "RtcStun", "RTC do STUN or ICE failed") \
|
||||
XX(ERROR_RTC_DTLS , 5009, "RtcDtls", "RTC do DTLS handshake failed") \
|
||||
XX(ERROR_RTC_UDP , 5010, "RtcUdpPacket", "Invalid UDP packet for RTC") \
|
||||
XX(ERROR_RTC_RTP_MUXER , 5011, "RtcRtpMuxer", "Failed to mux RTP packet for RTC") \
|
||||
XX(ERROR_RTC_SDP_DECODE , 5012, "RtcSdpDecode", "Failed to decode SDP for RTC") \
|
||||
XX(ERROR_RTC_SRTP_INIT , 5013, "RtcSrtpInit", "Failed to init SRTP context for RTC") \
|
||||
XX(ERROR_RTC_SRTP_PROTECT , 5014, "RtcSrtpProtect", "Failed to crypt data by SRTP for RTC") \
|
||||
XX(ERROR_RTC_SRTP_UNPROTECT , 5015, "RtcSrtpUnprotect", "Failed to decrypt data by SRTP for RTC") \
|
||||
XX(ERROR_RTC_RTCP_CHECK , 5016, "RtcRtcpPacket", "Invalid RTCP packet for RTC") \
|
||||
XX(ERROR_RTC_SOURCE_CHECK , 5017, "RtcSourceCheck", "Invalid source for RTC") \
|
||||
XX(ERROR_RTC_SDP_EXCHANGE , 5018, "RtcSdpNegotiate", "RTC do SDP negotiate failed") \
|
||||
XX(ERROR_RTC_API_BODY , 5019, "RtcApiJson", "Body of RTC API should be JSON format") \
|
||||
XX(ERROR_RTC_SOURCE_BUSY , 5020, "RtcStreamBusy", "RTC stream already exists or busy") \
|
||||
XX(ERROR_RTC_DISABLED , 5021, "RtcDisabled", "RTC is disabled by configuration") \
|
||||
XX(ERROR_RTC_NO_SESSION , 5022, "RtcNoSession", "Invalid packet for no RTC session matched") \
|
||||
XX(ERROR_RTC_INVALID_PARAMS , 5023, "RtcInvalidParams", "Invalid API parameters for RTC") \
|
||||
XX(ERROR_RTC_DUMMY_BRIDGER , 5024, "RtcDummyBridger", "RTC dummy bridger error") \
|
||||
XX(ERROR_RTC_STREM_STARTED , 5025, "RtcStreamStarted", "RTC stream already started") \
|
||||
XX(ERROR_RTC_TRACK_CODEC , 5026, "RtcTrackCodec", "RTC track codec error") \
|
||||
XX(ERROR_RTC_NO_PLAYER , 5027, "RtcNoPlayer", "RTC player not found") \
|
||||
XX(ERROR_RTC_NO_PUBLISHER , 5028, "RtcNoPublisher", "RTC publisher not found") \
|
||||
XX(ERROR_RTC_DUPLICATED_SSRC , 5029, "RtcSsrcDuplicated", "Invalid RTC packet for SSRC is duplicated") \
|
||||
XX(ERROR_RTC_NO_TRACK , 5030, "RtcNoTrack", "Drop RTC packet for track not found") \
|
||||
XX(ERROR_RTC_RTCP_EMPTY_RR , 5031, "RtcEmptyRr", "Invalid RTCP packet for RR is empty") \
|
||||
XX(ERROR_RTC_TCP_SIZE , 5032, "RtcTcpSize", "RTC TCP packet size is invalid") \
|
||||
XX(ERROR_RTC_TCP_PACKET , 5033, "RtcTcpStun", "RTC TCP first packet must be STUN") \
|
||||
XX(ERROR_RTC_TCP_STUN , 5034, "RtcTcpSession", "RTC TCP packet is invalid for session not found") \
|
||||
XX(ERROR_RTC_TCP_UNIQUE , 5035, "RtcUnique", "RTC only support one UDP or TCP network")
|
||||
|
||||
/**************************************************/
|
||||
/* SRT protocol error. */
|
||||
#define SRS_ERRNO_MAP_SRT(XX) \
|
||||
XX(ERROR_SRT_EPOLL , 6000, "SrtEpoll", "SRT epoll operation failed") \
|
||||
XX(ERROR_SRT_IO , 6001, "SrtIo", "SRT read or write failed") \
|
||||
XX(ERROR_SRT_TIMEOUT , 6002, "SrtTimeout", "SRT connection is timeout") \
|
||||
XX(ERROR_SRT_INTERRUPT , 6003, "SrtInterrupt", "SRT connection is interrupted") \
|
||||
XX(ERROR_SRT_LISTEN , 6004, "SrtListen", "SRT listen failed") \
|
||||
XX(ERROR_SRT_SOCKOPT , 6005, "SrtSetSocket", "SRT set socket option failed") \
|
||||
XX(ERROR_SRT_CONN , 6006, "SrtConnection", "SRT connectin level error") \
|
||||
XX(ERROR_SRT_SOURCE_BUSY , 6007, "SrtStreamBusy", "SRT stream already exists or busy") \
|
||||
XX(ERROR_RTMP_TO_SRT , 6008, "SrtFromRtmp", "Covert RTMP to SRT failed") \
|
||||
XX(ERROR_SRT_STATS , 6009, "SrtStats", "SRT get statistic data failed")
|
||||
|
||||
/**************************************************/
|
||||
/* For user-define error. */
|
||||
#define SRS_ERRNO_MAP_USER(XX) \
|
||||
XX(ERROR_USER_START , 9000, "UserStart", "Start error code for user") \
|
||||
XX(ERROR_USER_DISCONNECT , 9001, "UserDisconnect", "User requires to disconnect connection") \
|
||||
XX(ERROR_SOURCE_NOT_FOUND , 9002, "UserNoSource", "Stream source not found") \
|
||||
XX(ERROR_USER_END , 9999, "UserEnd", "The last error code of user")
|
||||
|
||||
// For human readable error generation. Generate integer error code.
|
||||
#define SRS_ERRNO_GEN(n, v, m, s) n = v,
|
||||
enum SrsErrorCode {
|
||||
#ifndef _WIN32
|
||||
#define ERROR_SUCCESS 0
|
||||
ERROR_SUCCESS = 0,
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// The system error.
|
||||
///////////////////////////////////////////////////////
|
||||
#define ERROR_SOCKET_CREATE 1000
|
||||
#define ERROR_SOCKET_SETREUSE 1001
|
||||
#define ERROR_SOCKET_BIND 1002
|
||||
#define ERROR_SOCKET_LISTEN 1003
|
||||
#define ERROR_SOCKET_CLOSED 1004
|
||||
#define ERROR_SOCKET_GET_PEER_NAME 1005
|
||||
#define ERROR_SOCKET_GET_PEER_IP 1006
|
||||
#define ERROR_SOCKET_READ 1007
|
||||
#define ERROR_SOCKET_READ_FULLY 1008
|
||||
#define ERROR_SOCKET_WRITE 1009
|
||||
#define ERROR_SOCKET_WAIT 1010
|
||||
#define ERROR_SOCKET_TIMEOUT 1011
|
||||
#define ERROR_SOCKET_CONNECT 1012
|
||||
#define ERROR_ST_SET_EPOLL 1013
|
||||
#define ERROR_ST_INITIALIZE 1014
|
||||
#define ERROR_ST_OPEN_SOCKET 1015
|
||||
#define ERROR_ST_CREATE_LISTEN_THREAD 1016
|
||||
#define ERROR_ST_CREATE_CYCLE_THREAD 1017
|
||||
#define ERROR_ST_CONNECT 1018
|
||||
#define ERROR_SYSTEM_PACKET_INVALID 1019
|
||||
#define ERROR_SYSTEM_CLIENT_INVALID 1020
|
||||
#define ERROR_SYSTEM_ASSERT_FAILED 1021
|
||||
#define ERROR_READER_BUFFER_OVERFLOW 1022
|
||||
#define ERROR_SYSTEM_CONFIG_INVALID 1023
|
||||
#define ERROR_SYSTEM_STREAM_BUSY 1028
|
||||
#define ERROR_SYSTEM_IP_INVALID 1029
|
||||
#define ERROR_SYSTEM_FORWARD_LOOP 1030
|
||||
#define ERROR_SYSTEM_WAITPID 1031
|
||||
#define ERROR_SYSTEM_BANDWIDTH_KEY 1032
|
||||
#define ERROR_SYSTEM_BANDWIDTH_DENIED 1033
|
||||
#define ERROR_SYSTEM_PID_ACQUIRE 1034
|
||||
#define ERROR_SYSTEM_PID_ALREADY_RUNNING 1035
|
||||
#define ERROR_SYSTEM_PID_LOCK 1036
|
||||
#define ERROR_SYSTEM_PID_TRUNCATE_FILE 1037
|
||||
#define ERROR_SYSTEM_PID_WRITE_FILE 1038
|
||||
#define ERROR_SYSTEM_PID_GET_FILE_INFO 1039
|
||||
#define ERROR_SYSTEM_PID_SET_FILE_INFO 1040
|
||||
#define ERROR_SYSTEM_FILE_ALREADY_OPENED 1041
|
||||
#define ERROR_SYSTEM_FILE_OPENE 1042
|
||||
//#define ERROR_SYSTEM_FILE_CLOSE 1043
|
||||
#define ERROR_SYSTEM_FILE_READ 1044
|
||||
#define ERROR_SYSTEM_FILE_WRITE 1045
|
||||
#define ERROR_SYSTEM_FILE_EOF 1046
|
||||
#define ERROR_SYSTEM_FILE_RENAME 1047
|
||||
#define ERROR_SYSTEM_CREATE_PIPE 1048
|
||||
#define ERROR_SYSTEM_FILE_SEEK 1049
|
||||
#define ERROR_SYSTEM_IO_INVALID 1050
|
||||
#define ERROR_ST_EXCEED_THREADS 1051
|
||||
#define ERROR_SYSTEM_SECURITY 1052
|
||||
#define ERROR_SYSTEM_SECURITY_DENY 1053
|
||||
#define ERROR_SYSTEM_SECURITY_ALLOW 1054
|
||||
#define ERROR_SYSTEM_TIME 1055
|
||||
#define ERROR_SYSTEM_DIR_EXISTS 1056
|
||||
#define ERROR_SYSTEM_CREATE_DIR 1057
|
||||
#define ERROR_SYSTEM_KILL 1058
|
||||
#define ERROR_SYSTEM_CONFIG_PERSISTENCE 1059
|
||||
#define ERROR_SYSTEM_CONFIG_RAW 1060
|
||||
#define ERROR_SYSTEM_CONFIG_RAW_DISABLED 1061
|
||||
#define ERROR_SYSTEM_CONFIG_RAW_NOT_ALLOWED 1062
|
||||
#define ERROR_SYSTEM_CONFIG_RAW_PARAMS 1063
|
||||
#define ERROR_SYSTEM_FILE_NOT_EXISTS 1064
|
||||
#define ERROR_SYSTEM_HOURGLASS_RESOLUTION 1065
|
||||
#define ERROR_SYSTEM_DNS_RESOLVE 1066
|
||||
#define ERROR_SYSTEM_FRAGMENT_UNLINK 1067
|
||||
#define ERROR_SYSTEM_FRAGMENT_RENAME 1068
|
||||
#define ERROR_THREAD_DISPOSED 1069
|
||||
#define ERROR_THREAD_INTERRUPED 1070
|
||||
#define ERROR_THREAD_TERMINATED 1071
|
||||
#define ERROR_THREAD_DUMMY 1072
|
||||
#define ERROR_ASPROCESS_PPID 1073
|
||||
#define ERROR_EXCEED_CONNECTIONS 1074
|
||||
#define ERROR_SOCKET_SETKEEPALIVE 1075
|
||||
#define ERROR_SOCKET_NO_NODELAY 1076
|
||||
#define ERROR_SOCKET_SNDBUF 1077
|
||||
#define ERROR_THREAD_STARTED 1078
|
||||
#define ERROR_SOCKET_SETREUSEADDR 1079
|
||||
#define ERROR_SOCKET_SETCLOSEEXEC 1080
|
||||
#define ERROR_SOCKET_ACCEPT 1081
|
||||
#define ERROR_THREAD_CREATE 1082
|
||||
#define ERROR_THREAD_FINISHED 1083
|
||||
#define ERROR_PB_NO_SPACE 1084
|
||||
#define ERROR_CLS_INVALID_CONFIG 1085
|
||||
#define ERROR_CLS_EXCEED_SIZE 1086
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// RTMP protocol error.
|
||||
///////////////////////////////////////////////////////
|
||||
#define ERROR_RTMP_PLAIN_REQUIRED 2000
|
||||
#define ERROR_RTMP_CHUNK_START 2001
|
||||
#define ERROR_RTMP_MSG_INVALID_SIZE 2002
|
||||
#define ERROR_RTMP_AMF0_DECODE 2003
|
||||
#define ERROR_RTMP_AMF0_INVALID 2004
|
||||
#define ERROR_RTMP_REQ_CONNECT 2005
|
||||
#define ERROR_RTMP_REQ_TCURL 2006
|
||||
#define ERROR_RTMP_MESSAGE_DECODE 2007
|
||||
#define ERROR_RTMP_MESSAGE_ENCODE 2008
|
||||
#define ERROR_RTMP_AMF0_ENCODE 2009
|
||||
#define ERROR_RTMP_CHUNK_SIZE 2010
|
||||
#define ERROR_RTMP_TRY_SIMPLE_HS 2011
|
||||
#define ERROR_RTMP_CH_SCHEMA 2012
|
||||
#define ERROR_RTMP_PACKET_SIZE 2013
|
||||
#define ERROR_RTMP_VHOST_NOT_FOUND 2014
|
||||
#define ERROR_RTMP_ACCESS_DENIED 2015
|
||||
#define ERROR_RTMP_HANDSHAKE 2016
|
||||
#define ERROR_RTMP_NO_REQUEST 2017
|
||||
#define ERROR_RTMP_HS_SSL_REQUIRE 2018
|
||||
#define ERROR_RTMP_DURATION_EXCEED 2019
|
||||
#define ERROR_RTMP_EDGE_PLAY_STATE 2020
|
||||
#define ERROR_RTMP_EDGE_PUBLISH_STATE 2021
|
||||
#define ERROR_RTMP_EDGE_PROXY_PULL 2022
|
||||
#define ERROR_RTMP_EDGE_RELOAD 2023
|
||||
#define ERROR_RTMP_AGGREGATE 2024
|
||||
#define ERROR_RTMP_BWTC_DATA 2025
|
||||
#define ERROR_OpenSslCreateDH 2026
|
||||
#define ERROR_OpenSslCreateP 2027
|
||||
#define ERROR_OpenSslCreateG 2028
|
||||
#define ERROR_OpenSslParseP1024 2029
|
||||
#define ERROR_OpenSslSetG 2030
|
||||
#define ERROR_OpenSslGenerateDHKeys 2031
|
||||
#define ERROR_OpenSslCopyKey 2032
|
||||
#define ERROR_OpenSslSha256Update 2033
|
||||
#define ERROR_OpenSslSha256Init 2034
|
||||
#define ERROR_OpenSslSha256Final 2035
|
||||
#define ERROR_OpenSslSha256EvpDigest 2036
|
||||
#define ERROR_OpenSslSha256DigestSize 2037
|
||||
#define ERROR_OpenSslGetPeerPublicKey 2038
|
||||
#define ERROR_OpenSslComputeSharedKey 2039
|
||||
#define ERROR_RTMP_MIC_CHUNKSIZE_CHANGED 2040
|
||||
#define ERROR_RTMP_MIC_CACHE_OVERFLOW 2041
|
||||
#define ERROR_RTSP_TOKEN_NOT_NORMAL 2042
|
||||
#define ERROR_RTSP_REQUEST_HEADER_EOF 2043
|
||||
#define ERROR_RTP_HEADER_CORRUPT 2044
|
||||
#define ERROR_RTP_TYPE96_CORRUPT 2045
|
||||
#define ERROR_RTP_TYPE97_CORRUPT 2046
|
||||
#define ERROR_RTSP_AUDIO_CONFIG 2047
|
||||
#define ERROR_RTMP_STREAM_NOT_FOUND 2048
|
||||
#define ERROR_RTMP_CLIENT_NOT_FOUND 2049
|
||||
#define ERROR_OpenSslCreateHMAC 2050
|
||||
#define ERROR_RTMP_STREAM_NAME_EMPTY 2051
|
||||
#define ERROR_HTTP_HIJACK 2052
|
||||
#define ERROR_RTMP_MESSAGE_CREATE 2053
|
||||
#define ERROR_RTMP_PROXY_EXCEED 2054
|
||||
#define ERROR_RTMP_CREATE_STREAM_DEPTH 2055
|
||||
//
|
||||
// The system control message,
|
||||
// It's not an error, but special control logic.
|
||||
//
|
||||
// When connection is redirect to another server.
|
||||
#define ERROR_CONTROL_REDIRECT 2997
|
||||
// For sys ctl: rtmp close stream, support replay.
|
||||
#define ERROR_CONTROL_RTMP_CLOSE 2998
|
||||
// When FMLE stop publish and republish.
|
||||
#define ERROR_CONTROL_REPUBLISH 2999
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// The application level errors.
|
||||
///////////////////////////////////////////////////////
|
||||
#define ERROR_HLS_METADATA 3000
|
||||
#define ERROR_HLS_DECODE_ERROR 3001
|
||||
//#define ERROR_HLS_CREATE_DIR 3002
|
||||
#define ERROR_HLS_OPEN_FAILED 3003
|
||||
#define ERROR_HLS_WRITE_FAILED 3004
|
||||
#define ERROR_HLS_AAC_FRAME_LENGTH 3005
|
||||
#define ERROR_HLS_AVC_SAMPLE_SIZE 3006
|
||||
#define ERROR_HTTP_PARSE_URI 3007
|
||||
#define ERROR_HTTP_DATA_INVALID 3008
|
||||
#define ERROR_HTTP_PARSE_HEADER 3009
|
||||
#define ERROR_HTTP_HANDLER_MATCH_URL 3010
|
||||
#define ERROR_HTTP_HANDLER_INVALID 3011
|
||||
#define ERROR_HTTP_API_LOGS 3012
|
||||
#define ERROR_HTTP_REMUX_SEQUENCE_HEADER 3013
|
||||
#define ERROR_HTTP_REMUX_OFFSET_OVERFLOW 3014
|
||||
#define ERROR_ENCODER_VCODEC 3015
|
||||
#define ERROR_ENCODER_OUTPUT 3016
|
||||
#define ERROR_ENCODER_ACHANNELS 3017
|
||||
#define ERROR_ENCODER_ASAMPLE_RATE 3018
|
||||
#define ERROR_ENCODER_ABITRATE 3019
|
||||
#define ERROR_ENCODER_ACODEC 3020
|
||||
#define ERROR_ENCODER_VPRESET 3021
|
||||
#define ERROR_ENCODER_VPROFILE 3022
|
||||
#define ERROR_ENCODER_VTHREADS 3023
|
||||
#define ERROR_ENCODER_VHEIGHT 3024
|
||||
#define ERROR_ENCODER_VWIDTH 3025
|
||||
#define ERROR_ENCODER_VFPS 3026
|
||||
#define ERROR_ENCODER_VBITRATE 3027
|
||||
#define ERROR_ENCODER_FORK 3028
|
||||
#define ERROR_ENCODER_LOOP 3029
|
||||
#define ERROR_FORK_OPEN_LOG 3030
|
||||
#define ERROR_FORK_DUP2_LOG 3031
|
||||
#define ERROR_ENCODER_PARSE 3032
|
||||
#define ERROR_ENCODER_NO_INPUT 3033
|
||||
#define ERROR_ENCODER_NO_OUTPUT 3034
|
||||
#define ERROR_ENCODER_INPUT_TYPE 3035
|
||||
#define ERROR_KERNEL_FLV_HEADER 3036
|
||||
#define ERROR_KERNEL_FLV_STREAM_CLOSED 3037
|
||||
#define ERROR_KERNEL_STREAM_INIT 3038
|
||||
#define ERROR_EDGE_VHOST_REMOVED 3039
|
||||
#define ERROR_HLS_AVC_TRY_OTHERS 3040
|
||||
#define ERROR_H264_API_NO_PREFIXED 3041
|
||||
#define ERROR_FLV_INVALID_VIDEO_TAG 3042
|
||||
#define ERROR_H264_DROP_BEFORE_SPS_PPS 3043
|
||||
#define ERROR_H264_DUPLICATED_SPS 3044
|
||||
#define ERROR_H264_DUPLICATED_PPS 3045
|
||||
#define ERROR_AAC_REQUIRED_ADTS 3046
|
||||
#define ERROR_AAC_ADTS_HEADER 3047
|
||||
#define ERROR_AAC_DATA_INVALID 3048
|
||||
#define ERROR_HLS_TRY_MP3 3049
|
||||
#define ERROR_HTTP_DVR_DISABLED 3050
|
||||
#define ERROR_HTTP_DVR_REQUEST 3051
|
||||
#define ERROR_HTTP_JSON_REQUIRED 3052
|
||||
#define ERROR_HTTP_DVR_CREATE_REQUEST 3053
|
||||
#define ERROR_HTTP_DVR_NO_TAEGET 3054
|
||||
#define ERROR_ADTS_ID_NOT_AAC 3055
|
||||
#define ERROR_HDS_OPEN_F4M_FAILED 3056
|
||||
#define ERROR_HDS_WRITE_F4M_FAILED 3057
|
||||
#define ERROR_HDS_OPEN_BOOTSTRAP_FAILED 3058
|
||||
#define ERROR_HDS_WRITE_BOOTSTRAP_FAILED 3059
|
||||
#define ERROR_HDS_OPEN_FRAGMENT_FAILED 3060
|
||||
#define ERROR_HDS_WRITE_FRAGMENT_FAILED 3061
|
||||
#define ERROR_HLS_NO_STREAM 3062
|
||||
#define ERROR_JSON_LOADS 3063
|
||||
#define ERROR_RESPONSE_CODE 3064
|
||||
#define ERROR_RESPONSE_DATA 3065
|
||||
#define ERROR_REQUEST_DATA 3066
|
||||
#define ERROR_EDGE_PORT_INVALID 3067
|
||||
#define ERROR_EXPECT_FILE_IO 3068
|
||||
#define ERROR_MP4_BOX_OVERFLOW 3069
|
||||
#define ERROR_MP4_BOX_REQUIRE_SPACE 3070
|
||||
#define ERROR_MP4_BOX_ILLEGAL_TYPE 3071
|
||||
#define ERROR_MP4_BOX_ILLEGAL_SCHEMA 3072
|
||||
#define ERROR_MP4_BOX_STRING 3073
|
||||
#define ERROR_MP4_BOX_ILLEGAL_BRAND 3074
|
||||
#define ERROR_MP4_ESDS_SL_Config 3075
|
||||
#define ERROR_MP4_ILLEGAL_MOOV 3076
|
||||
#define ERROR_MP4_ILLEGAL_HANDLER 3077
|
||||
#define ERROR_MP4_ILLEGAL_TRACK 3078
|
||||
#define ERROR_MP4_MOOV_OVERFLOW 3079
|
||||
#define ERROR_MP4_ILLEGAL_SAMPLES 3080
|
||||
#define ERROR_MP4_ILLEGAL_TIMESTAMP 3081
|
||||
#define ERROR_DVR_CANNOT_APPEND 3082
|
||||
#define ERROR_DVR_ILLEGAL_PLAN 3083
|
||||
#define ERROR_FLV_REQUIRE_SPACE 3084
|
||||
#define ERROR_MP4_AVCC_CHANGE 3085
|
||||
#define ERROR_MP4_ASC_CHANGE 3086
|
||||
#define ERROR_DASH_WRITE_FAILED 3087
|
||||
#define ERROR_TS_CONTEXT_NOT_READY 3088
|
||||
#define ERROR_MP4_ILLEGAL_MOOF 3089
|
||||
#define ERROR_MP4_ILLEGAL_MDAT 3090
|
||||
#define ERROR_OCLUSTER_DISCOVER 3091
|
||||
#define ERROR_OCLUSTER_REDIRECT 3092
|
||||
#define ERROR_INOTIFY_CREATE 3093
|
||||
#define ERROR_INOTIFY_OPENFD 3094
|
||||
#define ERROR_INOTIFY_WATCH 3095
|
||||
#define ERROR_HTTP_URL_UNESCAPE 3096
|
||||
#define ERROR_HTTP_WITH_BODY 3097
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// HTTP/StreamCaster protocol error.
|
||||
///////////////////////////////////////////////////////
|
||||
#define ERROR_HTTP_PATTERN_EMPTY 4000
|
||||
#define ERROR_HTTP_PATTERN_DUPLICATED 4001
|
||||
#define ERROR_HTTP_URL_NOT_CLEAN 4002
|
||||
#define ERROR_HTTP_CONTENT_LENGTH 4003
|
||||
#define ERROR_HTTP_LIVE_STREAM_EXT 4004
|
||||
#define ERROR_HTTP_STATUS_INVALID 4005
|
||||
#define ERROR_KERNEL_AAC_STREAM_CLOSED 4006
|
||||
#define ERROR_AAC_DECODE_ERROR 4007
|
||||
#define ERROR_KERNEL_MP3_STREAM_CLOSED 4008
|
||||
#define ERROR_MP3_DECODE_ERROR 4009
|
||||
#define ERROR_STREAM_CASTER_ENGINE 4010
|
||||
#define ERROR_STREAM_CASTER_PORT 4011
|
||||
#define ERROR_STREAM_CASTER_TS_HEADER 4012
|
||||
#define ERROR_STREAM_CASTER_TS_SYNC_BYTE 4013
|
||||
#define ERROR_STREAM_CASTER_TS_AF 4014
|
||||
#define ERROR_STREAM_CASTER_TS_CRC32 4015
|
||||
#define ERROR_STREAM_CASTER_TS_PSI 4016
|
||||
#define ERROR_STREAM_CASTER_TS_PAT 4017
|
||||
#define ERROR_STREAM_CASTER_TS_PMT 4018
|
||||
#define ERROR_STREAM_CASTER_TS_PSE 4019
|
||||
#define ERROR_STREAM_CASTER_TS_ES 4020
|
||||
#define ERROR_STREAM_CASTER_TS_CODEC 4021
|
||||
#define ERROR_STREAM_CASTER_AVC_SPS 4022
|
||||
#define ERROR_STREAM_CASTER_AVC_PPS 4023
|
||||
#define ERROR_STREAM_CASTER_FLV_TAG 4024
|
||||
#define ERROR_HTTP_RESPONSE_EOF 4025
|
||||
#define ERROR_HTTP_INVALID_CHUNK_HEADER 4026
|
||||
#define ERROR_AVC_NALU_UEV 4027
|
||||
#define ERROR_AAC_BYTES_INVALID 4028
|
||||
#define ERROR_HTTP_REQUEST_EOF 4029
|
||||
#define ERROR_HTTP_302_INVALID 4038
|
||||
#define ERROR_BASE64_DECODE 4039
|
||||
#define ERROR_HTTP_STREAM_EOF 4040
|
||||
#define ERROR_HTTPS_NOT_SUPPORTED 4041
|
||||
#define ERROR_HTTPS_HANDSHAKE 4042
|
||||
#define ERROR_HTTPS_READ 4043
|
||||
#define ERROR_HTTPS_WRITE 4044
|
||||
#define ERROR_HTTPS_KEY_CRT 4045
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// RTC protocol error.
|
||||
///////////////////////////////////////////////////////
|
||||
#define ERROR_RTC_PORT 5000
|
||||
#define ERROR_RTP_PACKET_CREATE 5001
|
||||
#define ERROR_OpenSslCreateSSL 5002
|
||||
#define ERROR_OpenSslBIOReset 5003
|
||||
#define ERROR_OpenSslBIOWrite 5004
|
||||
#define ERROR_OpenSslBIONew 5005
|
||||
#define ERROR_RTC_RTP 5006
|
||||
#define ERROR_RTC_RTCP 5007
|
||||
#define ERROR_RTC_STUN 5008
|
||||
#define ERROR_RTC_DTLS 5009
|
||||
#define ERROR_RTC_UDP 5010
|
||||
#define ERROR_RTC_RTP_MUXER 5011
|
||||
#define ERROR_RTC_SDP_DECODE 5012
|
||||
#define ERROR_RTC_SRTP_INIT 5013
|
||||
#define ERROR_RTC_SRTP_PROTECT 5014
|
||||
#define ERROR_RTC_SRTP_UNPROTECT 5015
|
||||
#define ERROR_RTC_RTCP_CHECK 5016
|
||||
#define ERROR_RTC_SOURCE_CHECK 5017
|
||||
#define ERROR_RTC_SDP_EXCHANGE 5018
|
||||
#define ERROR_RTC_API_BODY 5019
|
||||
#define ERROR_RTC_SOURCE_BUSY 5020
|
||||
#define ERROR_RTC_DISABLED 5021
|
||||
#define ERROR_RTC_NO_SESSION 5022
|
||||
#define ERROR_RTC_INVALID_PARAMS 5023
|
||||
#define ERROR_RTC_DUMMY_BRIDGER 5024
|
||||
#define ERROR_RTC_STREM_STARTED 5025
|
||||
#define ERROR_RTC_TRACK_CODEC 5026
|
||||
#define ERROR_RTC_NO_PLAYER 5027
|
||||
#define ERROR_RTC_NO_PUBLISHER 5028
|
||||
#define ERROR_RTC_DUPLICATED_SSRC 5029
|
||||
#define ERROR_RTC_NO_TRACK 5030
|
||||
#define ERROR_RTC_RTCP_EMPTY_RR 5031
|
||||
#define ERROR_RTC_TCP_SIZE 5032
|
||||
#define ERROR_RTC_TCP_PACKET 5033
|
||||
#define ERROR_RTC_TCP_STUN 5034
|
||||
#define ERROR_RTC_TCP_UNIQUE 5035
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// SRT protocol error.
|
||||
///////////////////////////////////////////////////////
|
||||
#define ERROR_SRT_EPOLL 6000
|
||||
#define ERROR_SRT_IO 6001
|
||||
#define ERROR_SRT_TIMEOUT 6002
|
||||
#define ERROR_SRT_INTERRUPT 6003
|
||||
#define ERROR_SRT_LISTEN 6004
|
||||
#define ERROR_SRT_SOCKOPT 6005
|
||||
#define ERROR_SRT_CONN 6006
|
||||
#define ERROR_SRT_SOURCE_BUSY 6007
|
||||
#define ERROR_RTMP_TO_SRT 6008
|
||||
#define ERROR_SRT_STATS 6009
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// HTTP API error.
|
||||
///////////////////////////////////////////////////////
|
||||
//#define ERROR_API_METHOD_NOT_ALLOWD
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// For user-define error.
|
||||
///////////////////////////////////////////////////////
|
||||
#define ERROR_USER_START 9000
|
||||
//#define ERROR_USER_DISCONNECT 9001
|
||||
#define ERROR_SOURCE_NOT_FOUND 9002
|
||||
#define ERROR_USER_END 9999
|
||||
SRS_ERRNO_MAP_SYSTEM(SRS_ERRNO_GEN)
|
||||
SRS_ERRNO_MAP_RTMP(SRS_ERRNO_GEN)
|
||||
SRS_ERRNO_MAP_APP(SRS_ERRNO_GEN)
|
||||
SRS_ERRNO_MAP_HTTP(SRS_ERRNO_GEN)
|
||||
SRS_ERRNO_MAP_RTC(SRS_ERRNO_GEN)
|
||||
SRS_ERRNO_MAP_SRT(SRS_ERRNO_GEN)
|
||||
SRS_ERRNO_MAP_USER(SRS_ERRNO_GEN)
|
||||
};
|
||||
#undef SRS_ERRNO_GEN
|
||||
|
||||
// Whether the error code is an system control error.
|
||||
// TODO: FIXME: Remove it from underlayer for confused with error and logger.
|
||||
|
|
@ -426,6 +426,8 @@ public:
|
|||
static std::string description(SrsCplxError* err);
|
||||
static std::string summary(SrsCplxError* err);
|
||||
static int error_code(SrsCplxError* err);
|
||||
static std::string error_code_str(SrsCplxError* err);
|
||||
static std::string error_code_longstr(SrsCplxError* err);
|
||||
};
|
||||
|
||||
// Error helpers, should use these functions to new or wrap an error.
|
||||
|
|
@ -436,6 +438,8 @@ public:
|
|||
#define srs_error_desc(err) SrsCplxError::description(err)
|
||||
#define srs_error_summary(err) SrsCplxError::summary(err)
|
||||
#define srs_error_code(err) SrsCplxError::error_code(err)
|
||||
#define srs_error_code_str(err) SrsCplxError::error_code_str(err)
|
||||
#define srs_error_code_longstr(err) SrsCplxError::error_code_longstr(err)
|
||||
#define srs_error_reset(err) srs_freep(err); err = srs_success
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@
|
|||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
|
|
@ -275,10 +276,7 @@ bool srs_check_ip_addr_valid(string ip)
|
|||
|
||||
string srs_int2str(int64_t value)
|
||||
{
|
||||
// len(max int64_t) is 20, plus one "+-."
|
||||
char tmp[21 + 1];
|
||||
snprintf(tmp, sizeof(tmp), "%" PRId64, value);
|
||||
return tmp;
|
||||
return srs_fmt("%" PRId64, value);
|
||||
}
|
||||
|
||||
string srs_float2str(double value)
|
||||
|
|
@ -554,6 +552,23 @@ vector<string> srs_string_split(string str, vector<string> seperators)
|
|||
return arr;
|
||||
}
|
||||
|
||||
std::string srs_fmt(const char* fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
|
||||
static char buf[8192];
|
||||
int r0 = vsnprintf(buf, sizeof(buf), fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
string v;
|
||||
if (r0 > 0 && r0 < (int)sizeof(buf)) {
|
||||
v.append(buf, r0);
|
||||
}
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
int srs_do_create_dir_recursively(string dir)
|
||||
{
|
||||
int ret = ERROR_SUCCESS;
|
||||
|
|
|
|||
|
|
@ -91,6 +91,8 @@ extern std::string srs_string_min_match(std::string str, std::vector<std::string
|
|||
// Split the string by seperator to array.
|
||||
extern std::vector<std::string> srs_string_split(std::string s, std::string seperator);
|
||||
extern std::vector<std::string> srs_string_split(std::string s, std::vector<std::string> seperators);
|
||||
// Format to a string.
|
||||
extern std::string srs_fmt(const char* fmt, ...);
|
||||
|
||||
// Compare the memory in bytes.
|
||||
// @return true if completely equal; otherwise, false.
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ using namespace std;
|
|||
#include <srs_kernel_file.hpp>
|
||||
#include <srs_app_hybrid.hpp>
|
||||
#include <srs_app_threads.hpp>
|
||||
|
||||
#ifdef SRS_RTC
|
||||
#include <srs_app_rtc_conn.hpp>
|
||||
#include <srs_app_rtc_server.hpp>
|
||||
|
|
@ -473,6 +474,7 @@ srs_error_t run_in_thread_pool()
|
|||
return _srs_thread_pool->run();
|
||||
}
|
||||
|
||||
#include <srs_app_tencentcloud.hpp>
|
||||
srs_error_t run_hybrid_server(void* /*arg*/)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
|
@ -498,6 +500,10 @@ srs_error_t run_hybrid_server(void* /*arg*/)
|
|||
return srs_error_wrap(err, "init circuit breaker");
|
||||
}
|
||||
|
||||
// When startup, create a span for server information.
|
||||
ISrsApmSpan* span = _srs_apm->span("main")->set_kind(SrsApmKindServer);
|
||||
srs_freep(span);
|
||||
|
||||
// Should run util hybrid servers all done.
|
||||
if ((err = _srs_hybrid->run()) != srs_success) {
|
||||
return srs_error_wrap(err, "hybrid run");
|
||||
|
|
|
|||
|
|
@ -136,6 +136,26 @@ srs_error_t SrsProtobufVarints::encode(SrsBuffer* b, uint64_t v)
|
|||
return err;
|
||||
}
|
||||
|
||||
int SrsProtobufFixed64::sizeof_int(uint64_t v)
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
|
||||
srs_error_t SrsProtobufFixed64::encode(SrsBuffer* b, uint64_t v)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (!b->require(8)) {
|
||||
return srs_error_new(ERROR_PB_NO_SPACE, "require 8 only %d byte", b->left());
|
||||
}
|
||||
|
||||
// Encode values in little-endian byte order,
|
||||
// see https://developers.google.com/protocol-buffers/docs/encoding#non-varint_numbers
|
||||
b->write_le8bytes((int64_t)v);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
// See Go protowire.SizeBytes of package google.golang.org/protobuf/encoding/protowire
|
||||
int SrsProtobufString::sizeof_string(const std::string& v)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -24,6 +24,14 @@ public:
|
|||
static srs_error_t encode(SrsBuffer* b, uint64_t v);
|
||||
};
|
||||
|
||||
// See https://developers.google.com/protocol-buffers/docs/encoding#structure
|
||||
class SrsProtobufFixed64
|
||||
{
|
||||
public:
|
||||
static int sizeof_int(uint64_t v);
|
||||
static srs_error_t encode(SrsBuffer* b, uint64_t v);
|
||||
};
|
||||
|
||||
// See https://developers.google.com/protocol-buffers/docs/encoding#strings
|
||||
class SrsProtobufString
|
||||
{
|
||||
|
|
@ -44,6 +52,7 @@ public:
|
|||
enum SrsProtobufField
|
||||
{
|
||||
// For int32, int64, uint32, uint64, sint32, sint64, bool, enum
|
||||
SrsProtobufFieldEnum = 0,
|
||||
SrsProtobufFieldVarint = 0,
|
||||
// For fixed64, sfixed64, double
|
||||
SrsProtobufField64bit = 1,
|
||||
|
|
|
|||
|
|
@ -41,6 +41,14 @@ SrsBasicRtmpClient::~SrsBasicRtmpClient()
|
|||
srs_freep(req);
|
||||
}
|
||||
|
||||
SrsAmf0Object* SrsBasicRtmpClient::extra_args()
|
||||
{
|
||||
if (req->args == NULL) {
|
||||
req->args = SrsAmf0Any::object();
|
||||
}
|
||||
return req->args;
|
||||
}
|
||||
|
||||
srs_error_t SrsBasicRtmpClient::connect()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
|
@ -89,13 +97,8 @@ srs_error_t SrsBasicRtmpClient::do_connect_app(string local_ip, bool debug)
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
// args of request takes the srs info.
|
||||
if (req->args == NULL) {
|
||||
req->args = SrsAmf0Any::object();
|
||||
}
|
||||
|
||||
// notify server the edge identity,
|
||||
SrsAmf0Object* data = req->args;
|
||||
SrsAmf0Object* data = extra_args();
|
||||
data->set("srs_sig", SrsAmf0Any::str(RTMP_SIG_SRS_KEY));
|
||||
data->set("srs_server", SrsAmf0Any::str(RTMP_SIG_SRS_SERVER));
|
||||
data->set("srs_license", SrsAmf0Any::str(RTMP_SIG_SRS_LICENSE));
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ class SrsSharedPtrMessage;
|
|||
class SrsPacket;
|
||||
class SrsNetworkKbps;
|
||||
class SrsWallClock;
|
||||
class SrsAmf0Object;
|
||||
|
||||
// The simple RTMP client, provides friendly APIs.
|
||||
// @remark Should never use client when closed.
|
||||
|
|
@ -47,6 +48,9 @@ public:
|
|||
// @param stm The timeout in srs_utime_t to delivery A/V stream.
|
||||
SrsBasicRtmpClient(std::string r, srs_utime_t ctm, srs_utime_t stm);
|
||||
virtual ~SrsBasicRtmpClient();
|
||||
public:
|
||||
// Get extra args to carry more information.
|
||||
SrsAmf0Object* extra_args();
|
||||
public:
|
||||
// Connect, handshake and connect app to RTMP server.
|
||||
// @remark We always close the transport.
|
||||
|
|
|
|||
|
|
@ -1897,7 +1897,7 @@ srs_error_t SrsRtmpClient::connect_app(string app, string tcUrl, SrsRequest* r,
|
|||
|
||||
// @see https://github.com/ossrs/srs/issues/160
|
||||
// the debug_srs_upnode is config in vhost and default to true.
|
||||
if (dsu && r && r->args) {
|
||||
if (dsu && r && r->args && r->args->count() > 0) {
|
||||
srs_freep(pkt->args);
|
||||
pkt->args = r->args->copy()->to_object();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -674,10 +674,12 @@ VOID TEST(KernelCodecTest, IsAudioSequenceHeader)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvEncoderStreamClosed)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileWriter fs;
|
||||
SrsFlvTransmuxer enc;
|
||||
// The decoder never check the reader status.
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(enc.initialize(&fs));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -686,10 +688,12 @@ VOID TEST(KernelFlvTest, FlvEncoderStreamClosed)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvEncoderWriteHeader)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileWriter fs;
|
||||
SrsFlvTransmuxer enc;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(enc.initialize(&fs));
|
||||
|
||||
// write header, 9bytes
|
||||
char flv_header[] = {
|
||||
|
|
@ -700,7 +704,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteHeader)
|
|||
};
|
||||
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)0x00 };
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == enc.write_header());
|
||||
HELPER_EXPECT_SUCCESS(enc.write_header());
|
||||
ASSERT_TRUE(9 + 4 == fs.tellg());
|
||||
|
||||
EXPECT_TRUE(srs_bytes_equals(flv_header, fs.data(), 9));
|
||||
|
|
@ -713,7 +717,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteHeader)
|
|||
|
||||
fs.mock_reset_offset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == enc.write_header(flv_header));
|
||||
HELPER_EXPECT_SUCCESS(enc.write_header(flv_header));
|
||||
ASSERT_TRUE(9 + 4 == fs.tellg());
|
||||
|
||||
EXPECT_TRUE(srs_bytes_equals(flv_header, fs.data(), 9));
|
||||
|
|
@ -726,10 +730,12 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteHeader)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvEncoderWriteMetadata)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileWriter fs;
|
||||
EXPECT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
HELPER_EXPECT_SUCCESS(fs.open(""));
|
||||
SrsFlvTransmuxer enc;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(enc.initialize(&fs));
|
||||
|
||||
// 11 bytes tag header
|
||||
char tag_header[] = {
|
||||
|
|
@ -745,7 +751,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteMetadata)
|
|||
};
|
||||
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)19 };
|
||||
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.write_metadata(18, md, 8));
|
||||
HELPER_ASSERT_SUCCESS(enc.write_metadata(18, md, 8));
|
||||
ASSERT_TRUE(11 + 8 + 4 == fs.tellg());
|
||||
|
||||
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data(), 11));
|
||||
|
|
@ -760,10 +766,12 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteMetadata)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvEncoderWriteAudio)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileWriter fs;
|
||||
SrsFlvTransmuxer enc;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(enc.initialize(&fs));
|
||||
|
||||
// 11bytes tag header
|
||||
char tag_header[] = {
|
||||
|
|
@ -779,7 +787,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteAudio)
|
|||
};
|
||||
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)19 };
|
||||
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.write_audio(0x30, audio, 8));
|
||||
HELPER_ASSERT_SUCCESS(enc.write_audio(0x30, audio, 8));
|
||||
ASSERT_TRUE(11 + 8 + 4 == fs.tellg());
|
||||
|
||||
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data(), 11));
|
||||
|
|
@ -794,10 +802,12 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteAudio)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvEncoderWriteVideo)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileWriter fs;
|
||||
SrsFlvTransmuxer enc;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(enc.initialize(&fs));
|
||||
|
||||
// 11bytes tag header
|
||||
char tag_header[] = {
|
||||
|
|
@ -813,7 +823,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteVideo)
|
|||
};
|
||||
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)19 };
|
||||
|
||||
ASSERT_TRUE(ERROR_SUCCESS == enc.write_video(0x30, video, 8));
|
||||
HELPER_ASSERT_SUCCESS(enc.write_video(0x30, video, 8));
|
||||
ASSERT_TRUE(11 + 8 + 4 == fs.tellg());
|
||||
|
||||
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data(), 11));
|
||||
|
|
@ -1183,10 +1193,12 @@ VOID TEST(KernelFLVTest, CoverFLVVodSHCase)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvDecoderStreamClosed)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvDecoder dec;
|
||||
// The decoder never check the reader status.
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1195,10 +1207,12 @@ VOID TEST(KernelFlvTest, FlvDecoderStreamClosed)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvDecoderHeader)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvDecoder dec;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// 9bytes
|
||||
char flv_header[] = {
|
||||
|
|
@ -1214,10 +1228,10 @@ VOID TEST(KernelFlvTest, FlvDecoderHeader)
|
|||
char data[1024];
|
||||
fs.mock_reset_offset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_header(data));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_header(data));
|
||||
EXPECT_TRUE(srs_bytes_equals(flv_header, data, 9));
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_previous_tag_size(data));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_previous_tag_size(data));
|
||||
EXPECT_TRUE(srs_bytes_equals(pts, data, 4));
|
||||
}
|
||||
|
||||
|
|
@ -1227,10 +1241,12 @@ VOID TEST(KernelFlvTest, FlvDecoderHeader)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvDecoderMetadata)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvDecoder dec;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// 11 bytes tag header
|
||||
char tag_header[] = {
|
||||
|
|
@ -1255,15 +1271,15 @@ VOID TEST(KernelFlvTest, FlvDecoderMetadata)
|
|||
char data[1024];
|
||||
fs.mock_reset_offset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_tag_header(&type, &size, &time));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_tag_header(&type, &size, &time));
|
||||
EXPECT_TRUE(18 == type);
|
||||
EXPECT_TRUE(8 == size);
|
||||
EXPECT_TRUE(0 == time);
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_tag_data(data, size));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_tag_data(data, size));
|
||||
EXPECT_TRUE(srs_bytes_equals(md, data, 8));
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_previous_tag_size(data));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_previous_tag_size(data));
|
||||
EXPECT_TRUE(srs_bytes_equals(pts, data, 4));
|
||||
}
|
||||
|
||||
|
|
@ -1273,10 +1289,12 @@ VOID TEST(KernelFlvTest, FlvDecoderMetadata)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvDecoderAudio)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvDecoder dec;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// 11bytes tag header
|
||||
char tag_header[] = {
|
||||
|
|
@ -1301,15 +1319,15 @@ VOID TEST(KernelFlvTest, FlvDecoderAudio)
|
|||
char data[1024];
|
||||
fs.mock_reset_offset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_tag_header(&type, &size, &time));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_tag_header(&type, &size, &time));
|
||||
EXPECT_TRUE(8 == type);
|
||||
EXPECT_TRUE(8 == size);
|
||||
EXPECT_TRUE(0x30 == time);
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_tag_data(data, size));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_tag_data(data, size));
|
||||
EXPECT_TRUE(srs_bytes_equals(audio, data, 8));
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_previous_tag_size(data));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_previous_tag_size(data));
|
||||
EXPECT_TRUE(srs_bytes_equals(pts, data, 4));
|
||||
}
|
||||
|
||||
|
|
@ -1319,10 +1337,12 @@ VOID TEST(KernelFlvTest, FlvDecoderAudio)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvDecoderVideo)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvDecoder dec;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// 11bytes tag header
|
||||
char tag_header[] = {
|
||||
|
|
@ -1347,15 +1367,15 @@ VOID TEST(KernelFlvTest, FlvDecoderVideo)
|
|||
char data[1024];
|
||||
fs.mock_reset_offset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_tag_header(&type, &size, &time));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_tag_header(&type, &size, &time));
|
||||
EXPECT_TRUE(9 == type);
|
||||
EXPECT_TRUE(8 == size);
|
||||
EXPECT_TRUE(0x30 == time);
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_tag_data(data, size));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_tag_data(data, size));
|
||||
EXPECT_TRUE(srs_bytes_equals(video, data, 8));
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_previous_tag_size(data));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_previous_tag_size(data));
|
||||
EXPECT_TRUE(srs_bytes_equals(pts, data, 4));
|
||||
}
|
||||
|
||||
|
|
@ -1365,6 +1385,8 @@ VOID TEST(KernelFlvTest, FlvDecoderVideo)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvVSDecoderStreamClosed)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
fs.close();
|
||||
|
||||
|
|
@ -1378,11 +1400,13 @@ VOID TEST(KernelFlvTest, FlvVSDecoderStreamClosed)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvVSDecoderHeader)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvVodStreamDecoder dec;
|
||||
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// 9bytes
|
||||
char flv_header[] = {
|
||||
|
|
@ -1398,7 +1422,7 @@ VOID TEST(KernelFlvTest, FlvVSDecoderHeader)
|
|||
char data[1024];
|
||||
fs.mock_reset_offset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_header_ext(data));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_header_ext(data));
|
||||
EXPECT_TRUE(srs_bytes_equals(flv_header, data, 9));
|
||||
}
|
||||
|
||||
|
|
@ -1409,10 +1433,12 @@ VOID TEST(KernelFlvTest, FlvVSDecoderHeader)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvVSDecoderSequenceHeader)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvVodStreamDecoder dec;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// push metadata tag
|
||||
if (true) {
|
||||
|
|
@ -1476,7 +1502,7 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSequenceHeader)
|
|||
|
||||
int64_t start = 0;
|
||||
int size = 0;
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_sequence_header_summary(&start, &size));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_sequence_header_summary(&start, &size));
|
||||
EXPECT_EQ(23, (int)start);
|
||||
EXPECT_EQ(46, size);
|
||||
}
|
||||
|
|
@ -1488,10 +1514,12 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSequenceHeader)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvVSDecoderSequenceHeader2)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvVodStreamDecoder dec;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// push metadata tag
|
||||
if (true) {
|
||||
|
|
@ -1555,7 +1583,7 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSequenceHeader2)
|
|||
|
||||
int64_t start = 0;
|
||||
int size = 0;
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.read_sequence_header_summary(&start, &size));
|
||||
HELPER_EXPECT_SUCCESS(dec.read_sequence_header_summary(&start, &size));
|
||||
EXPECT_EQ(23, (int)start);
|
||||
EXPECT_EQ(46, size);
|
||||
}
|
||||
|
|
@ -1567,10 +1595,12 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSequenceHeader2)
|
|||
*/
|
||||
VOID TEST(KernelFlvTest, FlvVSDecoderSeek)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockSrsFileReader fs;
|
||||
SrsFlvVodStreamDecoder dec;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
|
||||
ASSERT_TRUE(ERROR_SUCCESS == dec.initialize(&fs));
|
||||
HELPER_ASSERT_SUCCESS(fs.open(""));
|
||||
HELPER_ASSERT_SUCCESS(dec.initialize(&fs));
|
||||
|
||||
// 11bytes tag header
|
||||
char tag_header[] = {
|
||||
|
|
@ -1583,10 +1613,10 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSeek)
|
|||
fs.mock_append_data(tag_header, 11);
|
||||
EXPECT_TRUE(11 == fs.tellg());
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.seek2(0));
|
||||
HELPER_EXPECT_SUCCESS(dec.seek2(0));
|
||||
EXPECT_TRUE(0 == fs.tellg());
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == dec.seek2(5));
|
||||
HELPER_EXPECT_SUCCESS(dec.seek2(5));
|
||||
EXPECT_TRUE(5 == fs.tellg());
|
||||
}
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -26,6 +26,8 @@ using namespace std;
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -208,7 +210,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -216,7 +218,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -224,7 +226,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -232,7 +234,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x40, msg->header.timestamp);
|
||||
|
|
@ -247,6 +249,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -430,7 +434,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -438,7 +442,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -446,7 +450,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -454,7 +458,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x40, msg->header.timestamp);
|
||||
|
|
@ -468,6 +472,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt11Length)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -648,7 +654,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -656,7 +662,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -664,7 +670,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -672,7 +678,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x40, msg->header.timestamp);
|
||||
|
|
@ -687,6 +693,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -869,7 +877,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -878,7 +886,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -886,7 +894,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -895,7 +903,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x40, msg->header.timestamp);
|
||||
|
|
@ -910,6 +918,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt12Length)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -940,7 +950,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage)
|
|||
bio.in_buffer.append((char*)data, sizeof(data));
|
||||
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -952,6 +962,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage2)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -982,7 +994,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage2)
|
|||
bio.in_buffer.append((char*)data, sizeof(data));
|
||||
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x7f010203, msg->header.timestamp);
|
||||
|
|
@ -995,6 +1007,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage2)
|
|||
// always use 31bits timestamp, for some server may use 32bits extended timestamp.
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage3)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -1025,7 +1039,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage3)
|
|||
bio.in_buffer.append((char*)data, sizeof(data));
|
||||
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
// always use 31bits timestamp
|
||||
|
|
@ -1055,6 +1069,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvExtTimeMessage3)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -1098,7 +1114,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk)
|
|||
bio.in_buffer.append((char*)data, sizeof(data));
|
||||
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
// 0xCX with extended timestamp.
|
||||
|
|
@ -1112,6 +1128,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk)
|
|||
// FFMPEG/librtmp, RTMP specification standard protocol.
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk2)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -1153,7 +1171,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk2)
|
|||
bio.in_buffer.append((char*)data, sizeof(data));
|
||||
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
// 0xCX without extended timestamp.
|
||||
|
|
@ -1166,6 +1184,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVExtTime2Trunk2)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BMin)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -1204,7 +1224,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BMin)
|
|||
bio.in_buffer.append((char*)data, sizeof(data));
|
||||
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
// 1B cid(6bits), min is 2
|
||||
|
|
@ -1213,6 +1233,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVCid1BMin)
|
|||
|
||||
VOID TEST(ProtocolKbpsTest, Connections)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (true) {
|
||||
MockWallClock* clock = new MockWallClock();
|
||||
SrsAutoFree(MockWallClock, clock);
|
||||
|
|
@ -1378,6 +1400,8 @@ VOID TEST(ProtocolKbpsTest, Connections)
|
|||
|
||||
VOID TEST(ProtocolKbpsTest, Delta)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (true) {
|
||||
MockWallClock* clock = new MockWallClock();
|
||||
SrsAutoFree(MockWallClock, clock);
|
||||
|
|
@ -1460,6 +1484,8 @@ VOID TEST(ProtocolKbpsTest, Delta)
|
|||
|
||||
VOID TEST(ProtocolKbpsTest, RAWStatistic)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (true) {
|
||||
MockWallClock* clock = new MockWallClock();
|
||||
SrsAutoFree(MockWallClock, clock);
|
||||
|
|
@ -1624,6 +1650,8 @@ VOID TEST(ProtocolKbpsTest, WriteLargeIOVs)
|
|||
|
||||
VOID TEST(ProtocolKbpsTest, ConnectionsSugar)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (true) {
|
||||
MockWallClock* clock = new MockWallClock();
|
||||
SrsAutoFree(MockWallClock, clock);
|
||||
|
|
@ -1771,6 +1799,8 @@ VOID TEST(ProtocolKbpsTest, ConnectionsSugar)
|
|||
|
||||
VOID TEST(ProtocolKbpsTest, DeltaSugar)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (true) {
|
||||
MockWallClock* clock = new MockWallClock();
|
||||
SrsAutoFree(MockWallClock, clock);
|
||||
|
|
@ -1810,6 +1840,8 @@ VOID TEST(ProtocolKbpsTest, DeltaSugar)
|
|||
|
||||
VOID TEST(ProtocolKbpsTest, RAWStatisticSugar)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (true) {
|
||||
MockWallClock* clock = new MockWallClock();
|
||||
SrsAutoFree(MockWallClock, clock);
|
||||
|
|
@ -2254,6 +2286,8 @@ VOID TEST(ProtocolProtobufTest, FieldKey)
|
|||
|
||||
VOID TEST(ProtocolKbpsTest, NewDelta)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (true) {
|
||||
SrsEphemeralDelta ed;
|
||||
|
||||
|
|
@ -2305,6 +2339,8 @@ VOID TEST(ProtocolKbpsTest, NewDelta)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -2476,7 +2512,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -2484,7 +2520,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -2492,7 +2528,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -2500,7 +2536,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x30, msg->header.timestamp);
|
||||
|
|
@ -2514,6 +2550,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVMessage)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -2696,7 +2734,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -2704,7 +2742,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -2712,7 +2750,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -2720,7 +2758,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x30, msg->header.timestamp);
|
||||
|
|
@ -2734,6 +2772,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt1)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -2912,7 +2952,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -2920,7 +2960,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -2928,7 +2968,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -2936,7 +2976,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x30, msg->header.timestamp);
|
||||
|
|
@ -2950,6 +2990,8 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt2)
|
|||
*/
|
||||
VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt3)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockBufferIO bio;
|
||||
SrsProtocol proto(&bio);
|
||||
|
||||
|
|
@ -3126,7 +3168,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt3)
|
|||
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x10, msg->header.timestamp);
|
||||
|
|
@ -3134,7 +3176,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt3)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_audio());
|
||||
EXPECT_EQ(0x15, msg->header.timestamp);
|
||||
|
|
@ -3142,7 +3184,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt3)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x20, msg->header.timestamp);
|
||||
|
|
@ -3150,7 +3192,7 @@ VOID TEST(ProtocolStackTest, ProtocolRecvVAVVFmt3)
|
|||
}
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
ASSERT_TRUE(ERROR_SUCCESS == proto.recv_message(&msg));
|
||||
HELPER_ASSERT_SUCCESS(proto.recv_message(&msg));
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
EXPECT_TRUE(msg->header.is_video());
|
||||
EXPECT_EQ(0x30, msg->header.timestamp);
|
||||
|
|
|
|||
|
|
@ -194,51 +194,55 @@ srs_error_t MockSrsReloadConfig::do_reload(string buf)
|
|||
|
||||
VOID TEST(ConfigReloadTest, ReloadEmpty)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_FALSE(ERROR_SUCCESS == conf.parse(""));
|
||||
EXPECT_FALSE(ERROR_SUCCESS == conf.do_reload(""));
|
||||
HELPER_EXPECT_FAILED(conf.parse(""));
|
||||
HELPER_EXPECT_FAILED(conf.do_reload(""));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadListen)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse("listen 1935;"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload("listen 1935;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse("listen 1935;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload("listen 1935;"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload("listen 1936;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload("listen 1936;"));
|
||||
EXPECT_TRUE(handler.listen_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload("listen 1936;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload("listen 1936;"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload("listen 1936 1935;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload("listen 1936 1935;"));
|
||||
EXPECT_TRUE(handler.listen_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload("listen 1935;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload("listen 1935;"));
|
||||
EXPECT_TRUE(handler.listen_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload("listen 1935 1935;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload("listen 1935 1935;"));
|
||||
EXPECT_TRUE(handler.listen_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload("listen 1935;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload("listen 1935;"));
|
||||
EXPECT_TRUE(handler.listen_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
|
@ -246,357 +250,391 @@ VOID TEST(ConfigReloadTest, ReloadListen)
|
|||
|
||||
VOID TEST(ConfigReloadTest, ReloadPithyPrint)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"pithy_print_ms 1000;"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"pithy_print_ms 1000;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"pithy_print_ms 1000;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"pithy_print_ms 1000;"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"pithy_print_ms 2000;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"pithy_print_ms 2000;"));
|
||||
EXPECT_TRUE(handler.pithy_print_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"pithy_print_ms 1000;"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"pithy_print_ms 1000;"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostAdded)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
EXPECT_TRUE(handler.vhost_added_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostRemoved)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{enabled off;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{enabled off;}"));
|
||||
EXPECT_TRUE(handler.vhost_removed_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostRemoved2)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(handler.vhost_removed_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{} vhost b{}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostAtc)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{atc off;}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{atc off;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{atc off;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{atc off;}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{atc on;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{atc on;}"));
|
||||
EXPECT_TRUE(handler.vhost_play_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{atc off;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{atc off;}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostGopCache)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{gop_cache off;}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{gop_cache off;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{gop_cache off;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{gop_cache off;}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{gop_cache on;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{gop_cache on;}"));
|
||||
EXPECT_TRUE(handler.vhost_play_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{gop_cache off;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{gop_cache off;}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostQueueLength)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{queue_length 10;}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{queue_length 10;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{queue_length 10;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{queue_length 10;}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{queue_length 20;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{queue_length 20;}"));
|
||||
EXPECT_TRUE(handler.vhost_play_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{queue_length 10;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{queue_length 10;}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostTimeJitter)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{time_jitter full;}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{time_jitter full;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{time_jitter full;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{time_jitter full;}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{time_jitter zero;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{time_jitter zero;}"));
|
||||
EXPECT_TRUE(handler.vhost_play_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{time_jitter full;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{time_jitter full;}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostForward)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1936;}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1936;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1936;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1936;}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1937;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1937;}"));
|
||||
EXPECT_TRUE(handler.vhost_forward_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1936;}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{forward 127.0.0.1:1936;}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostHls)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{hls {enabled on;}}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{hls {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{hls {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{hls {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{hls {enabled off;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{hls {enabled off;}}"));
|
||||
EXPECT_TRUE(handler.vhost_hls_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{hls {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{hls {enabled on;}}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostDvr)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{dvr {enabled on;}}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{dvr {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{dvr {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{dvr {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{dvr {enabled off;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{dvr {enabled off;}}"));
|
||||
EXPECT_TRUE(handler.vhost_dvr_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{dvr {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{dvr {enabled on;}}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostTranscode)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{transcode {enabled on;}}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{transcode {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{transcode {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{transcode {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{transcode {enabled off;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{transcode {enabled off;}}"));
|
||||
EXPECT_TRUE(handler.vhost_transcode_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{transcode {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{transcode {enabled on;}}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostIngestAdded)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.ingest_added_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostIngestAdded2)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{ingest a {enabled on;}}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest a {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{ingest a {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest a {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest a {enabled on;} ingest b {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest a {enabled on;} ingest b {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.ingest_added_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest a {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest a {enabled on;}}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostIngestRemoved)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{}"));
|
||||
EXPECT_TRUE(handler.ingest_removed_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostIngestRemoved2)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled off;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled off;}}"));
|
||||
EXPECT_TRUE(handler.ingest_removed_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;}}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
||||
VOID TEST(ConfigReloadTest, ReloadVhostIngestUpdated)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
MockReloadHandler handler;
|
||||
MockSrsReloadConfig conf;
|
||||
|
||||
conf.subscribe(&handler);
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
|
||||
EXPECT_TRUE(handler.all_false());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg1;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg1;}}"));
|
||||
EXPECT_TRUE(handler.ingest_updated_reloaded);
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
|
||||
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
|
||||
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF"vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
|
||||
EXPECT_EQ(1, handler.count_true());
|
||||
handler.reset();
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue