external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

For #913, reload use complex error

Browse source
This commit is contained in:
winlin 2017-09-22 16:14:30 +08:00
parent 3744606c9b
commit fd91df9411
28 changed files with 642 additions and 630 deletions
Download patch file Download diff file Expand all files Collapse all files

376
trunk/src/app/srs_app_config.cpp
View file

@ -1220,9 +1220,9 @@ srs_error_t SrsConfig::reload()
return err; return err;
} }
int SrsConfig::reload_vhost(SrsConfDirective* old_root) srs_error_t SrsConfig::reload_vhost(SrsConfDirective* old_root)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
// merge config. // merge config.
std::vector<ISrsReloadHandler*>::iterator it; std::vector<ISrsReloadHandler*>::iterator it;
@ -1265,16 +1265,16 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
// DISABLED => ENABLED // DISABLED => ENABLED
if (!get_vhost_enabled(old_vhost) && get_vhost_enabled(new_vhost)) { if (!get_vhost_enabled(old_vhost) && get_vhost_enabled(new_vhost)) {
if ((ret = do_reload_vhost_added(vhost)) != ERROR_SUCCESS) { if ((err = do_reload_vhost_added(vhost)) != srs_success) {
return ret; return srs_error_wrap(err, "reload vhost added");
} }
continue; continue;
} }
// ENABLED => DISABLED // ENABLED => DISABLED
if (get_vhost_enabled(old_vhost) && !get_vhost_enabled(new_vhost)) { if (get_vhost_enabled(old_vhost) && !get_vhost_enabled(new_vhost)) {
if ((ret = do_reload_vhost_removed(vhost)) != ERROR_SUCCESS) { if ((err = do_reload_vhost_removed(vhost)) != srs_success) {
return ret; return srs_error_wrap(err, "reload vhost removed");
} }
continue; continue;
} }
@ -1287,9 +1287,7 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
// edge will retry and the users connected to edge are ok. // edge will retry and the users connected to edge are ok.
// it's ok to add or remove edge/origin vhost. // it's ok to add or remove edge/origin vhost.
if (get_vhost_is_edge(old_vhost) != get_vhost_is_edge(new_vhost)) { if (get_vhost_is_edge(old_vhost) != get_vhost_is_edge(new_vhost)) {
ret = ERROR_RTMP_EDGE_RELOAD; return srs_error_new(ERROR_RTMP_EDGE_RELOAD, "vhost mode changed");
srs_error("reload never supports mode changed. ret=%d", ret);
return ret;
} }
// the auto reload configs: // the auto reload configs:
@ -1302,9 +1300,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("chunk_size"), old_vhost->get("chunk_size"))) { if (!srs_directive_equals(new_vhost->get("chunk_size"), old_vhost->get("chunk_size"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_chunk_size(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_chunk_size(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes chunk_size failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes chunk_size failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload chunk_size success.", vhost.c_str()); srs_trace("vhost %s reload chunk_size success.", vhost.c_str());
@ -1314,9 +1311,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("tcp_nodelay"), old_vhost->get("tcp_nodelay"))) { if (!srs_directive_equals(new_vhost->get("tcp_nodelay"), old_vhost->get("tcp_nodelay"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_tcp_nodelay(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_tcp_nodelay(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes tcp_nodelay failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes tcp_nodelay failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload tcp_nodelay success.", vhost.c_str()); srs_trace("vhost %s reload tcp_nodelay success.", vhost.c_str());
@ -1326,9 +1322,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("min_latency"), old_vhost->get("min_latency"))) { if (!srs_directive_equals(new_vhost->get("min_latency"), old_vhost->get("min_latency"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_realtime(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_realtime(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes min_latency failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes min_latency failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload min_latency success.", vhost.c_str()); srs_trace("vhost %s reload min_latency success.", vhost.c_str());
@ -1338,9 +1333,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("play"), old_vhost->get("play"))) { if (!srs_directive_equals(new_vhost->get("play"), old_vhost->get("play"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_play(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_play(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes play failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes play failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload play success.", vhost.c_str()); srs_trace("vhost %s reload play success.", vhost.c_str());
@ -1350,9 +1344,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("forward"), old_vhost->get("forward"))) { if (!srs_directive_equals(new_vhost->get("forward"), old_vhost->get("forward"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_forward(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_forward(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes forward failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes forward failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload forward success.", vhost.c_str()); srs_trace("vhost %s reload forward success.", vhost.c_str());
@ -1362,9 +1355,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("dash"), old_vhost->get("dash"))) { if (!srs_directive_equals(new_vhost->get("dash"), old_vhost->get("dash"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_dash(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_dash(vhost)) != srs_success) {
srs_error("Reload vhost %s dash failed, ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "Reload vhost %s dash failed", vhost.c_str());
return ret;
} }
} }
srs_trace("Reload vhost %s dash ok.", vhost.c_str()); srs_trace("Reload vhost %s dash ok.", vhost.c_str());
@ -1375,9 +1367,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("hls"), old_vhost->get("hls"))) { if (!srs_directive_equals(new_vhost->get("hls"), old_vhost->get("hls"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_hls(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_hls(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes hls failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes hls failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload hls success.", vhost.c_str()); srs_trace("vhost %s reload hls success.", vhost.c_str());
@ -1387,9 +1378,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("hds"), old_vhost->get("hds"))) { if (!srs_directive_equals(new_vhost->get("hds"), old_vhost->get("hds"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_hds(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_hds(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes hds failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes hds failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload hds success.", vhost.c_str()); srs_trace("vhost %s reload hds success.", vhost.c_str());
@ -1399,9 +1389,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("dvr"), old_vhost->get("dvr"), "dvr_apply")) { if (!srs_directive_equals(new_vhost->get("dvr"), old_vhost->get("dvr"), "dvr_apply")) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_dvr(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_dvr(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes dvr failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes dvr failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload dvr success.", vhost.c_str()); srs_trace("vhost %s reload dvr success.", vhost.c_str());
@ -1413,8 +1402,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
// @see https://github.com/ossrs/srs/issues/459#issuecomment-140296597 // @see https://github.com/ossrs/srs/issues/459#issuecomment-140296597
SrsConfDirective* nda = new_vhost->get("dvr")? new_vhost->get("dvr")->get("dvr_apply") : NULL; SrsConfDirective* nda = new_vhost->get("dvr")? new_vhost->get("dvr")->get("dvr_apply") : NULL;
SrsConfDirective* oda = old_vhost->get("dvr")? old_vhost->get("dvr")->get("dvr_apply") : NULL; SrsConfDirective* oda = old_vhost->get("dvr")? old_vhost->get("dvr")->get("dvr_apply") : NULL;
if (!srs_directive_equals(nda, oda) && (ret = do_reload_vhost_dvr_apply(vhost)) != ERROR_SUCCESS) { if (!srs_directive_equals(nda, oda) && (err = do_reload_vhost_dvr_apply(vhost)) != srs_success) {
return ret; return srs_error_wrap(err, "reload dvr_apply");
} }
} }
@ -1422,9 +1411,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("exec"), old_vhost->get("exec"))) { if (!srs_directive_equals(new_vhost->get("exec"), old_vhost->get("exec"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_exec(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_exec(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes exec failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes exec failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload exec success.", vhost.c_str()); srs_trace("vhost %s reload exec success.", vhost.c_str());
@ -1434,9 +1422,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("publish"), old_vhost->get("publish"))) { if (!srs_directive_equals(new_vhost->get("publish"), old_vhost->get("publish"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_publish(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_publish(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes publish failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes publish failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload publish success.", vhost.c_str()); srs_trace("vhost %s reload publish success.", vhost.c_str());
@ -1446,9 +1433,8 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("http_static"), old_vhost->get("http_static"))) { if (!srs_directive_equals(new_vhost->get("http_static"), old_vhost->get("http_static"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_http_updated()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_http_updated()) != srs_success) {
srs_error("vhost %s notify subscribes http_static failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes http_static failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload http_static success.", vhost.c_str()); srs_trace("vhost %s reload http_static success.", vhost.c_str());
@ -1458,22 +1444,21 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
if (!srs_directive_equals(new_vhost->get("http_remux"), old_vhost->get("http_remux"))) { if (!srs_directive_equals(new_vhost->get("http_remux"), old_vhost->get("http_remux"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_http_remux_updated(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_http_remux_updated(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes http_remux failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes http_remux failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload http_remux success.", vhost.c_str()); srs_trace("vhost %s reload http_remux success.", vhost.c_str());
} }
// transcode, many per vhost. // transcode, many per vhost.
if ((ret = reload_transcode(new_vhost, old_vhost)) != ERROR_SUCCESS) { if ((err = reload_transcode(new_vhost, old_vhost)) != srs_success) {
return ret; return srs_error_wrap(err, "reload transcode");
} }
// ingest, many per vhost. // ingest, many per vhost.
if ((ret = reload_ingest(new_vhost, old_vhost)) != ERROR_SUCCESS) { if ((err = reload_ingest(new_vhost, old_vhost)) != srs_success) {
return ret; return srs_error_wrap(err, "reload ingest");
} }
continue; continue;
} }
@ -1481,12 +1466,11 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
get_vhost_enabled(old_vhost), get_vhost_enabled(new_vhost)); get_vhost_enabled(old_vhost), get_vhost_enabled(new_vhost));
} }
return ret; return err;
} }
srs_error_t SrsConfig::reload_conf(SrsConfig* conf) srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
SrsConfDirective* old_root = root; SrsConfDirective* old_root = root;
@ -1508,43 +1492,43 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
// merge config: listen // merge config: listen
if (!srs_directive_equals(root->get("listen"), old_root->get("listen"))) { if (!srs_directive_equals(root->get("listen"), old_root->get("listen"))) {
if ((ret = do_reload_listen()) != ERROR_SUCCESS) { if ((err = do_reload_listen()) != srs_success) {
return srs_error_new(ret, "listen"); return srs_error_wrap(err, "listen");
} }
} }
// merge config: pid // merge config: pid
if (!srs_directive_equals(root->get("pid"), old_root->get("pid"))) { if (!srs_directive_equals(root->get("pid"), old_root->get("pid"))) {
if ((ret = do_reload_pid()) != ERROR_SUCCESS) { if ((err = do_reload_pid()) != srs_success) {
return srs_error_new(ret, "pid");; return srs_error_wrap(err, "pid");;
} }
} }
// merge config: srs_log_tank // merge config: srs_log_tank
if (!srs_directive_equals(root->get("srs_log_tank"), old_root->get("srs_log_tank"))) { if (!srs_directive_equals(root->get("srs_log_tank"), old_root->get("srs_log_tank"))) {
if ((ret = do_reload_srs_log_tank()) != ERROR_SUCCESS) { if ((err = do_reload_srs_log_tank()) != srs_success) {
return srs_error_new(ret, "log tank");; return srs_error_wrap(err, "log tank");;
} }
} }
// merge config: srs_log_level // merge config: srs_log_level
if (!srs_directive_equals(root->get("srs_log_level"), old_root->get("srs_log_level"))) { if (!srs_directive_equals(root->get("srs_log_level"), old_root->get("srs_log_level"))) {
if ((ret = do_reload_srs_log_level()) != ERROR_SUCCESS) { if ((err = do_reload_srs_log_level()) != srs_success) {
return srs_error_new(ret, "log level");; return srs_error_wrap(err, "log level");;
} }
} }
// merge config: srs_log_file // merge config: srs_log_file
if (!srs_directive_equals(root->get("srs_log_file"), old_root->get("srs_log_file"))) { if (!srs_directive_equals(root->get("srs_log_file"), old_root->get("srs_log_file"))) {
if ((ret = do_reload_srs_log_file()) != ERROR_SUCCESS) { if ((err = do_reload_srs_log_file()) != srs_success) {
return srs_error_new(ret, "log file");; return srs_error_wrap(err, "log file");;
} }
} }
// merge config: max_connections // merge config: max_connections
if (!srs_directive_equals(root->get("max_connections"), old_root->get("max_connections"))) { if (!srs_directive_equals(root->get("max_connections"), old_root->get("max_connections"))) {
if ((ret = do_reload_max_connections()) != ERROR_SUCCESS) { if ((err = do_reload_max_connections()) != srs_success) {
return srs_error_new(ret, "max connections");; return srs_error_wrap(err, "max connections");;
} }
} }
@ -1557,8 +1541,8 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
// merge config: pithy_print_ms // merge config: pithy_print_ms
if (!srs_directive_equals(root->get("pithy_print_ms"), old_root->get("pithy_print_ms"))) { if (!srs_directive_equals(root->get("pithy_print_ms"), old_root->get("pithy_print_ms"))) {
if ((ret = do_reload_pithy_print_ms()) != ERROR_SUCCESS) { if ((err = do_reload_pithy_print_ms()) != srs_success) {
return srs_error_new(ret, "pithy print ms");; return srs_error_wrap(err, "pithy print ms");;
} }
} }
@ -1576,8 +1560,8 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
// TODO: FIXME: support reload kafka. // TODO: FIXME: support reload kafka.
// merge config: vhost // merge config: vhost
if ((ret = reload_vhost(old_root)) != ERROR_SUCCESS) { if ((err = reload_vhost(old_root)) != srs_success) {
return srs_error_new(ret, "vhost");; return srs_error_wrap(err, "vhost");;
} }
return err; return err;
@ -1585,7 +1569,6 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
srs_error_t SrsConfig::reload_http_api(SrsConfDirective* old_root) srs_error_t SrsConfig::reload_http_api(SrsConfDirective* old_root)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
// merge config. // merge config.
@ -1604,8 +1587,8 @@ srs_error_t SrsConfig::reload_http_api(SrsConfDirective* old_root)
if (!get_http_api_enabled(old_http_api) && get_http_api_enabled(new_http_api)) { if (!get_http_api_enabled(old_http_api) && get_http_api_enabled(new_http_api)) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_http_api_enabled()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_http_api_enabled()) != srs_success) {
return srs_error_new(ret, "http api off=>on"); return srs_error_wrap(err, "http api off=>on");
} }
} }
srs_trace("reload off=>on http_api success."); srs_trace("reload off=>on http_api success.");
@ -1616,8 +1599,8 @@ srs_error_t SrsConfig::reload_http_api(SrsConfDirective* old_root)
if (get_http_api_enabled(old_http_api) && !get_http_api_enabled(new_http_api)) { if (get_http_api_enabled(old_http_api) && !get_http_api_enabled(new_http_api)) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_http_api_disabled()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_http_api_disabled()) != srs_success) {
return srs_error_new(ret, "http api on=>off"); return srs_error_wrap(err, "http api on=>off");
} }
} }
srs_trace("reload http_api on=>off success."); srs_trace("reload http_api on=>off success.");
@ -1630,8 +1613,8 @@ srs_error_t SrsConfig::reload_http_api(SrsConfDirective* old_root)
) { ) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_http_api_enabled()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_http_api_enabled()) != srs_success) {
return srs_error_new(ret, "http api enabled"); return srs_error_wrap(err, "http api enabled");
} }
} }
srs_trace("reload http api enabled success."); srs_trace("reload http api enabled success.");
@ -1649,8 +1632,8 @@ srs_error_t SrsConfig::reload_http_api(SrsConfDirective* old_root)
if (!srs_directive_equals(old_http_api->get("raw_api"), new_http_api->get("raw_api"))) { if (!srs_directive_equals(old_http_api->get("raw_api"), new_http_api->get("raw_api"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_http_api_raw_api()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_http_api_raw_api()) != srs_success) {
return srs_error_new(ret, "http api raw_api"); return srs_error_wrap(err, "http api raw_api");
} }
} }
} }
@ -1664,7 +1647,6 @@ srs_error_t SrsConfig::reload_http_api(SrsConfDirective* old_root)
srs_error_t SrsConfig::reload_http_stream(SrsConfDirective* old_root) srs_error_t SrsConfig::reload_http_stream(SrsConfDirective* old_root)
{ {
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
// merge config. // merge config.
@ -1683,8 +1665,8 @@ srs_error_t SrsConfig::reload_http_stream(SrsConfDirective* old_root)
if (!get_http_stream_enabled(old_http_stream) && get_http_stream_enabled(new_http_stream)) { if (!get_http_stream_enabled(old_http_stream) && get_http_stream_enabled(new_http_stream)) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_http_stream_enabled()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_http_stream_enabled()) != srs_success) {
return srs_error_new(ret, "http stream off=>on"); return srs_error_wrap(err, "http stream off=>on");
} }
} }
srs_trace("reload http stream off=>on success."); srs_trace("reload http stream off=>on success.");
@ -1695,8 +1677,8 @@ srs_error_t SrsConfig::reload_http_stream(SrsConfDirective* old_root)
if (get_http_stream_enabled(old_http_stream) && !get_http_stream_enabled(new_http_stream)) { if (get_http_stream_enabled(old_http_stream) && !get_http_stream_enabled(new_http_stream)) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_http_stream_disabled()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_http_stream_disabled()) != srs_success) {
return srs_error_new(ret, "http stream on=>off"); return srs_error_wrap(err, "http stream on=>off");
} }
} }
srs_trace("reload http stream on=>off success."); srs_trace("reload http stream on=>off success.");
@ -1709,8 +1691,8 @@ srs_error_t SrsConfig::reload_http_stream(SrsConfDirective* old_root)
) { ) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_http_stream_updated()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_http_stream_updated()) != srs_success) {
return srs_error_new(ret, "http stream enabled"); return srs_error_wrap(err, "http stream enabled");
} }
} }
srs_trace("reload http stream enabled success."); srs_trace("reload http stream enabled success.");
@ -1731,9 +1713,9 @@ srs_error_t SrsConfig::reload_http_stream(SrsConfDirective* old_root)
return err; return err;
} }
int SrsConfig::reload_transcode(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost) srs_error_t SrsConfig::reload_transcode(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
std::vector<SrsConfDirective*> old_transcoders; std::vector<SrsConfDirective*> old_transcoders;
for (int i = 0; i < (int)old_vhost->directives.size(); i++) { for (int i = 0; i < (int)old_vhost->directives.size(); i++) {
@ -1804,20 +1786,19 @@ int SrsConfig::reload_transcode(SrsConfDirective* new_vhost, SrsConfDirective* o
if (changed) { if (changed) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_transcode(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_transcode(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes transcode failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes transcode failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload transcode success.", vhost.c_str()); srs_trace("vhost %s reload transcode success.", vhost.c_str());
} }
return ret; return err;
} }
int SrsConfig::reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost) srs_error_t SrsConfig::reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
std::vector<SrsConfDirective*> old_ingesters; std::vector<SrsConfDirective*> old_ingesters;
for (int i = 0; i < (int)old_vhost->directives.size(); i++) { for (int i = 0; i < (int)old_vhost->directives.size(); i++) {
@ -1850,10 +1831,8 @@ int SrsConfig::reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_
// notice handler ingester removed. // notice handler ingester removed.
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_ingest_removed(vhost, ingest_id)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_ingest_removed(vhost, ingest_id)) != srs_success) {
srs_error("vhost %s notify subscribes ingest=%s removed failed. ret=%d", return srs_error_wrap(err, "vhost %s notify subscribes ingest=%s removed failed", vhost.c_str(), ingest_id.c_str());
vhost.c_str(), ingest_id.c_str(), ret);
return ret;
} }
} }
srs_trace("vhost %s reload ingest=%s removed success.", vhost.c_str(), ingest_id.c_str()); srs_trace("vhost %s reload ingest=%s removed success.", vhost.c_str(), ingest_id.c_str());
@ -1870,10 +1849,8 @@ int SrsConfig::reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_
if (!get_ingest_enabled(old_ingester) && get_ingest_enabled(new_ingester)) { if (!get_ingest_enabled(old_ingester) && get_ingest_enabled(new_ingester)) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_ingest_added(vhost, ingest_id)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_ingest_added(vhost, ingest_id)) != srs_success) {
srs_error("vhost %s notify subscribes ingest=%s added failed. ret=%d", return srs_error_wrap(err, "vhost %s notify subscribes ingest=%s added failed", vhost.c_str(), ingest_id.c_str());
vhost.c_str(), ingest_id.c_str(), ret);
return ret;
} }
} }
srs_trace("vhost %s reload ingest=%s added success.", vhost.c_str(), ingest_id.c_str()); srs_trace("vhost %s reload ingest=%s added success.", vhost.c_str(), ingest_id.c_str());
@ -1895,10 +1872,8 @@ int SrsConfig::reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_
// notice handler ingester removed. // notice handler ingester removed.
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_ingest_updated(vhost, ingest_id)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_ingest_updated(vhost, ingest_id)) != srs_success) {
srs_error("vhost %s notify subscribes ingest=%s updated failed. ret=%d", return srs_error_wrap(err, "vhost %s notify subscribes ingest=%s updated failed", vhost.c_str(), ingest_id.c_str());
vhost.c_str(), ingest_id.c_str(), ret);
return ret;
} }
} }
srs_trace("vhost %s reload ingest=%s updated success.", vhost.c_str(), ingest_id.c_str()); srs_trace("vhost %s reload ingest=%s updated success.", vhost.c_str(), ingest_id.c_str());
@ -1907,7 +1882,7 @@ int SrsConfig::reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_
srs_trace("ingest nothing changed for vhost=%s", vhost.c_str()); srs_trace("ingest nothing changed for vhost=%s", vhost.c_str());
return ret; return err;
} }
// see: ngx_get_options // see: ngx_get_options
@ -2814,6 +2789,7 @@ int SrsConfig::raw_to_json(SrsJsonObject* obj)
int SrsConfig::raw_set_listen(const vector<string>& eps, bool& applied) int SrsConfig::raw_set_listen(const vector<string>& eps, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -2827,7 +2803,10 @@ int SrsConfig::raw_set_listen(const vector<string>& eps, bool& applied)
// changed, apply and reload. // changed, apply and reload.
conf->args = eps; conf->args = eps;
if ((ret = do_reload_listen()) != ERROR_SUCCESS) { if ((err = do_reload_listen()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -2839,6 +2818,7 @@ int SrsConfig::raw_set_listen(const vector<string>& eps, bool& applied)
int SrsConfig::raw_set_pid(string pid, bool& applied) int SrsConfig::raw_set_pid(string pid, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -2851,7 +2831,10 @@ int SrsConfig::raw_set_pid(string pid, bool& applied)
conf->args.clear(); conf->args.clear();
conf->args.push_back(pid); conf->args.push_back(pid);
if ((ret = do_reload_pid()) != ERROR_SUCCESS) { if ((err = do_reload_pid()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -2907,6 +2890,7 @@ int SrsConfig::raw_set_ff_log_dir(string ff_log_dir, bool& applied)
int SrsConfig::raw_set_srs_log_tank(string srs_log_tank, bool& applied) int SrsConfig::raw_set_srs_log_tank(string srs_log_tank, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -2919,7 +2903,10 @@ int SrsConfig::raw_set_srs_log_tank(string srs_log_tank, bool& applied)
conf->args.clear(); conf->args.clear();
conf->args.push_back(srs_log_tank); conf->args.push_back(srs_log_tank);
if ((ret = do_reload_srs_log_tank()) != ERROR_SUCCESS) { if ((err = do_reload_srs_log_tank()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -2931,6 +2918,7 @@ int SrsConfig::raw_set_srs_log_tank(string srs_log_tank, bool& applied)
int SrsConfig::raw_set_srs_log_level(string srs_log_level, bool& applied) int SrsConfig::raw_set_srs_log_level(string srs_log_level, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -2943,7 +2931,10 @@ int SrsConfig::raw_set_srs_log_level(string srs_log_level, bool& applied)
conf->args.clear(); conf->args.clear();
conf->args.push_back(srs_log_level); conf->args.push_back(srs_log_level);
if ((ret = do_reload_srs_log_level()) != ERROR_SUCCESS) { if ((err = do_reload_srs_log_level()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -2955,6 +2946,7 @@ int SrsConfig::raw_set_srs_log_level(string srs_log_level, bool& applied)
int SrsConfig::raw_set_srs_log_file(string srs_log_file, bool& applied) int SrsConfig::raw_set_srs_log_file(string srs_log_file, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -2967,7 +2959,10 @@ int SrsConfig::raw_set_srs_log_file(string srs_log_file, bool& applied)
conf->args.clear(); conf->args.clear();
conf->args.push_back(srs_log_file); conf->args.push_back(srs_log_file);
if ((ret = do_reload_srs_log_file()) != ERROR_SUCCESS) { if ((err = do_reload_srs_log_file()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -2979,6 +2974,7 @@ int SrsConfig::raw_set_srs_log_file(string srs_log_file, bool& applied)
int SrsConfig::raw_set_max_connections(string max_connections, bool& applied) int SrsConfig::raw_set_max_connections(string max_connections, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -2991,7 +2987,10 @@ int SrsConfig::raw_set_max_connections(string max_connections, bool& applied)
conf->args.clear(); conf->args.clear();
conf->args.push_back(max_connections); conf->args.push_back(max_connections);
if ((ret = do_reload_max_connections()) != ERROR_SUCCESS) { if ((err = do_reload_max_connections()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -3027,6 +3026,7 @@ srs_error_t SrsConfig::raw_set_utc_time(string utc_time, bool& applied)
int SrsConfig::raw_set_pithy_print_ms(string pithy_print_ms, bool& applied) int SrsConfig::raw_set_pithy_print_ms(string pithy_print_ms, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -3039,7 +3039,10 @@ int SrsConfig::raw_set_pithy_print_ms(string pithy_print_ms, bool& applied)
conf->args.clear(); conf->args.clear();
conf->args.push_back(pithy_print_ms); conf->args.push_back(pithy_print_ms);
if ((ret = do_reload_pithy_print_ms()) != ERROR_SUCCESS) { if ((err = do_reload_pithy_print_ms()) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -3051,13 +3054,17 @@ int SrsConfig::raw_set_pithy_print_ms(string pithy_print_ms, bool& applied)
int SrsConfig::raw_create_vhost(string vhost, bool& applied) int SrsConfig::raw_create_vhost(string vhost, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
SrsConfDirective* conf = root->get_or_create("vhost", vhost); SrsConfDirective* conf = root->get_or_create("vhost", vhost);
conf->get_or_create("enabled")->set_arg0("on"); conf->get_or_create("enabled")->set_arg0("on");
if ((ret = do_reload_vhost_added(vhost)) != ERROR_SUCCESS) { if ((err = do_reload_vhost_added(vhost)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -3103,13 +3110,17 @@ int SrsConfig::raw_delete_vhost(string vhost, bool& applied)
int SrsConfig::raw_disable_vhost(string vhost, bool& applied) int SrsConfig::raw_disable_vhost(string vhost, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
SrsConfDirective* conf = root->get("vhost", vhost); SrsConfDirective* conf = root->get("vhost", vhost);
conf->get_or_create("enabled")->set_arg0("off"); conf->get_or_create("enabled")->set_arg0("off");
if ((ret = do_reload_vhost_removed(vhost)) != ERROR_SUCCESS) { if ((err = do_reload_vhost_removed(vhost)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -3121,13 +3132,17 @@ int SrsConfig::raw_disable_vhost(string vhost, bool& applied)
int SrsConfig::raw_enable_vhost(string vhost, bool& applied) int SrsConfig::raw_enable_vhost(string vhost, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
SrsConfDirective* conf = root->get("vhost", vhost); SrsConfDirective* conf = root->get("vhost", vhost);
conf->get_or_create("enabled")->set_arg0("on"); conf->get_or_create("enabled")->set_arg0("on");
if ((ret = do_reload_vhost_added(vhost)) != ERROR_SUCCESS) { if ((err = do_reload_vhost_added(vhost)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -3139,6 +3154,7 @@ int SrsConfig::raw_enable_vhost(string vhost, bool& applied)
int SrsConfig::raw_enable_dvr(string vhost, string stream, bool& applied) int SrsConfig::raw_enable_dvr(string vhost, string stream, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -3153,7 +3169,10 @@ int SrsConfig::raw_enable_dvr(string vhost, string stream, bool& applied)
conf->args.push_back(stream); conf->args.push_back(stream);
} }
if ((ret = do_reload_vhost_dvr_apply(vhost)) != ERROR_SUCCESS) { if ((err = do_reload_vhost_dvr_apply(vhost)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -3165,6 +3184,7 @@ int SrsConfig::raw_enable_dvr(string vhost, string stream, bool& applied)
int SrsConfig::raw_disable_dvr(string vhost, string stream, bool& applied) int SrsConfig::raw_disable_dvr(string vhost, string stream, bool& applied)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
applied = false; applied = false;
@ -3181,7 +3201,10 @@ int SrsConfig::raw_disable_dvr(string vhost, string stream, bool& applied)
conf->args.push_back("none"); conf->args.push_back("none");
} }
if ((ret = do_reload_vhost_dvr_apply(vhost)) != ERROR_SUCCESS) { if ((err = do_reload_vhost_dvr_apply(vhost)) != srs_success) {
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret; return ret;
} }
@ -3190,106 +3213,100 @@ int SrsConfig::raw_disable_dvr(string vhost, string stream, bool& applied)
return ret; return ret;
} }
int SrsConfig::do_reload_listen() srs_error_t SrsConfig::do_reload_listen()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_listen()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_listen()) != srs_success) {
srs_error("notify subscribes reload listen failed. ret=%d", ret); return srs_error_wrap(err, "notify subscribes reload listen failed");
return ret;
} }
} }
srs_trace("reload listen success."); srs_trace("reload listen success.");
return ret; return err;
} }
int SrsConfig::do_reload_pid() srs_error_t SrsConfig::do_reload_pid()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_pid()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_pid()) != srs_success) {
srs_error("notify subscribes reload pid failed. ret=%d", ret); return srs_error_wrap(err, "notify subscribes reload pid failed");
return ret;
} }
} }
srs_trace("reload pid success."); srs_trace("reload pid success.");
return ret; return err;
} }
int SrsConfig::do_reload_srs_log_tank() srs_error_t SrsConfig::do_reload_srs_log_tank()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_log_tank()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_log_tank()) != srs_success) {
srs_error("notify subscribes reload srs_log_tank failed. ret=%d", ret); return srs_error_wrap(err, "notify subscribes reload srs_log_tank failed");
return ret;
} }
} }
srs_trace("reload srs_log_tank success."); srs_trace("reload srs_log_tank success.");
return ret; return err;
} }
int SrsConfig::do_reload_srs_log_level() srs_error_t SrsConfig::do_reload_srs_log_level()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_log_level()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_log_level()) != srs_success) {
srs_error("notify subscribes reload srs_log_level failed. ret=%d", ret); return srs_error_wrap(err, "notify subscribes reload srs_log_level failed");
return ret;
} }
} }
srs_trace("reload srs_log_level success."); srs_trace("reload srs_log_level success.");
return ret; return err;
} }
int SrsConfig::do_reload_srs_log_file() srs_error_t SrsConfig::do_reload_srs_log_file()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_log_file()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_log_file()) != srs_success) {
srs_error("notify subscribes reload srs_log_file failed. ret=%d", ret); return srs_error_wrap(err, "notify subscribes reload srs_log_file failed");
return ret;
} }
} }
srs_trace("reload srs_log_file success."); srs_trace("reload srs_log_file success.");
return ret; return err;
} }
int SrsConfig::do_reload_max_connections() srs_error_t SrsConfig::do_reload_max_connections()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_max_conns()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_max_conns()) != srs_success) {
srs_error("notify subscribes reload max_connections failed. ret=%d", ret); return srs_error_wrap(err, "notify subscribes reload max_connections failed");
return ret;
} }
} }
srs_trace("reload max_connections success."); srs_trace("reload max_connections success.");
return ret; return err;
} }
srs_error_t SrsConfig::do_reload_utc_time() srs_error_t SrsConfig::do_reload_utc_time()
@ -3308,78 +3325,73 @@ srs_error_t SrsConfig::do_reload_utc_time()
return err; return err;
} }
int SrsConfig::do_reload_pithy_print_ms() srs_error_t SrsConfig::do_reload_pithy_print_ms()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_pithy_print()) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_pithy_print()) != srs_success) {
srs_error("notify subscribes pithy_print_ms failed. ret=%d", ret); return srs_error_wrap(err, "notify subscribes pithy_print_ms failed");
return ret;
} }
} }
srs_trace("reload pithy_print_ms success."); srs_trace("reload pithy_print_ms success.");
return ret; return err;
} }
int SrsConfig::do_reload_vhost_added(string vhost) srs_error_t SrsConfig::do_reload_vhost_added(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
srs_trace("vhost %s added, reload it.", vhost.c_str()); srs_trace("vhost %s added, reload it.", vhost.c_str());
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_added(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_added(vhost)) != srs_success) {
srs_error("notify subscribes added vhost %s failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "notify subscribes added vhost %s failed", vhost.c_str());
return ret;
} }
} }
srs_trace("reload new vhost %s success.", vhost.c_str()); srs_trace("reload new vhost %s success.", vhost.c_str());
return ret; return err;
} }
int SrsConfig::do_reload_vhost_removed(string vhost) srs_error_t SrsConfig::do_reload_vhost_removed(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
srs_trace("vhost %s removed, reload it.", vhost.c_str()); srs_trace("vhost %s removed, reload it.", vhost.c_str());
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_removed(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_removed(vhost)) != srs_success) {
srs_error("notify subscribes removed " return srs_error_wrap(err, "notify subscribes removed vhost %s failed", vhost.c_str());
"vhost %s failed. ret=%d", vhost.c_str(), ret);
return ret;
} }
} }
srs_trace("reload removed vhost %s success.", vhost.c_str()); srs_trace("reload removed vhost %s success.", vhost.c_str());
return ret; return err;
} }
int SrsConfig::do_reload_vhost_dvr_apply(string vhost) srs_error_t SrsConfig::do_reload_vhost_dvr_apply(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
vector<ISrsReloadHandler*>::iterator it; vector<ISrsReloadHandler*>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) { for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler* subscribe = *it; ISrsReloadHandler* subscribe = *it;
if ((ret = subscribe->on_reload_vhost_dvr_apply(vhost)) != ERROR_SUCCESS) { if ((err = subscribe->on_reload_vhost_dvr_apply(vhost)) != srs_success) {
srs_error("vhost %s notify subscribes dvr_apply failed. ret=%d", vhost.c_str(), ret); return srs_error_wrap(err, "vhost %s notify subscribes dvr_apply failed", vhost.c_str());
return ret;
} }
} }
srs_trace("vhost %s reload dvr_apply success.", vhost.c_str()); srs_trace("vhost %s reload dvr_apply success.", vhost.c_str());
return ret; return err;
} }
string SrsConfig::config() string SrsConfig::config()

26
trunk/src/app/srs_app_config.hpp
View file

@ -382,7 +382,7 @@ private:
/** /**
* reload the vhost section of config. * reload the vhost section of config.
*/ */
virtual int reload_vhost(SrsConfDirective* old_root); virtual srs_error_t reload_vhost(SrsConfDirective* old_root);
protected: protected:
/** /**
* reload from the config. * reload from the config.
@ -402,11 +402,11 @@ private:
/** /**
* reload the transcode section of vhost of config. * reload the transcode section of vhost of config.
*/ */
virtual int reload_transcode(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost); virtual srs_error_t reload_transcode(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost);
/** /**
* reload the ingest section of vhost of config. * reload the ingest section of vhost of config.
*/ */
virtual int reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost); virtual srs_error_t reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost);
// parse options and file // parse options and file
public: public:
/** /**
@ -510,17 +510,17 @@ public:
*/ */
virtual int raw_disable_dvr(std::string vhost, std::string stream, bool& applied); virtual int raw_disable_dvr(std::string vhost, std::string stream, bool& applied);
private: private:
virtual int do_reload_listen(); virtual srs_error_t do_reload_listen();
virtual int do_reload_pid(); virtual srs_error_t do_reload_pid();
virtual int do_reload_srs_log_tank(); virtual srs_error_t do_reload_srs_log_tank();
virtual int do_reload_srs_log_level(); virtual srs_error_t do_reload_srs_log_level();
virtual int do_reload_srs_log_file(); virtual srs_error_t do_reload_srs_log_file();
virtual int do_reload_max_connections(); virtual srs_error_t do_reload_max_connections();
virtual srs_error_t do_reload_utc_time(); virtual srs_error_t do_reload_utc_time();
virtual int do_reload_pithy_print_ms(); virtual srs_error_t do_reload_pithy_print_ms();
virtual int do_reload_vhost_added(std::string vhost); virtual srs_error_t do_reload_vhost_added(std::string vhost);
virtual int do_reload_vhost_removed(std::string vhost); virtual srs_error_t do_reload_vhost_removed(std::string vhost);
virtual int do_reload_vhost_dvr_apply(std::string vhost); virtual srs_error_t do_reload_vhost_dvr_apply(std::string vhost);
public: public:
/** /**
* get the config file path. * get the config file path.

45
trunk/src/app/srs_app_dvr.cpp
View file

@ -205,15 +205,6 @@ int SrsDvrSegmenter::close()
return ret; return ret;
} }
int SrsDvrSegmenter::on_update_duration(SrsSharedPtrMessage* msg)
{
int ret = ERROR_SUCCESS;
fragment->append(msg->timestamp);
return ret;
}
string SrsDvrSegmenter::generate_path() string SrsDvrSegmenter::generate_path()
{ {
// the path in config, for example, // the path in config, for example,
@ -233,18 +224,27 @@ string SrsDvrSegmenter::generate_path()
return flv_path; return flv_path;
} }
int SrsDvrSegmenter::on_reload_vhost_dvr(std::string vhost) int SrsDvrSegmenter::on_update_duration(SrsSharedPtrMessage* msg)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
fragment->append(msg->timestamp);
return ret;
}
srs_error_t SrsDvrSegmenter::on_reload_vhost_dvr(std::string vhost)
{
srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
jitter_algorithm = (SrsRtmpJitterAlgorithm)_srs_config->get_dvr_time_jitter(req->vhost); jitter_algorithm = (SrsRtmpJitterAlgorithm)_srs_config->get_dvr_time_jitter(req->vhost);
wait_keyframe = _srs_config->get_dvr_wait_keyframe(req->vhost); wait_keyframe = _srs_config->get_dvr_wait_keyframe(req->vhost);
return ret; return err;
} }
SrsDvrFlvSegmenter::SrsDvrFlvSegmenter() SrsDvrFlvSegmenter::SrsDvrFlvSegmenter()
@ -885,12 +885,12 @@ int SrsDvrSegmentPlan::update_duration(SrsSharedPtrMessage* msg)
return ret; return ret;
} }
int SrsDvrSegmentPlan::on_reload_vhost_dvr(string vhost) srs_error_t SrsDvrSegmentPlan::on_reload_vhost_dvr(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
wait_keyframe = _srs_config->get_dvr_wait_keyframe(req->vhost); wait_keyframe = _srs_config->get_dvr_wait_keyframe(req->vhost);
@ -899,7 +899,7 @@ int SrsDvrSegmentPlan::on_reload_vhost_dvr(string vhost)
// to ms // to ms
cduration *= 1000; cduration *= 1000;
return ret; return err;
} }
SrsDvr::SrsDvr() SrsDvr::SrsDvr()
@ -1006,32 +1006,33 @@ int SrsDvr::on_video(SrsSharedPtrMessage* shared_video, SrsFormat* format)
return plan->on_video(shared_video, format); return plan->on_video(shared_video, format);
} }
int SrsDvr::on_reload_vhost_dvr_apply(string vhost) srs_error_t SrsDvr::on_reload_vhost_dvr_apply(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsConfDirective* conf = _srs_config->get_dvr_apply(req->vhost); SrsConfDirective* conf = _srs_config->get_dvr_apply(req->vhost);
bool v = srs_config_apply_filter(conf, req); bool v = srs_config_apply_filter(conf, req);
// the apply changed, republish the dvr. // the apply changed, republish the dvr.
if (v == actived) { if (v == actived) {
return ret; return err;
} }
actived = v; actived = v;
on_unpublish(); on_unpublish();
if (!actived) { if (!actived) {
return ret; return err;
} }
if ((ret = on_publish()) != ERROR_SUCCESS) { if ((ret = on_publish()) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "on publish");
} }
if ((ret = hub->on_dvr_request_sh()) != ERROR_SUCCESS) { if ((ret = hub->on_dvr_request_sh()) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "request sh");
} }
return ret; return err;
} }

6
trunk/src/app/srs_app_dvr.hpp
View file

@ -107,7 +107,7 @@ private:
virtual int on_update_duration(SrsSharedPtrMessage* msg); virtual int on_update_duration(SrsSharedPtrMessage* msg);
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_vhost_dvr(std::string vhost); virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
}; };
/** /**
@ -243,7 +243,7 @@ private:
virtual int update_duration(SrsSharedPtrMessage* msg); virtual int update_duration(SrsSharedPtrMessage* msg);
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_vhost_dvr(std::string vhost); virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
}; };
/** /**
@ -297,7 +297,7 @@ public:
virtual int on_video(SrsSharedPtrMessage* shared_video, SrsFormat* format); virtual int on_video(SrsSharedPtrMessage* shared_video, SrsFormat* format);
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_vhost_dvr_apply(std::string vhost); virtual srs_error_t on_reload_vhost_dvr_apply(std::string vhost);
}; };
#endif #endif

4
trunk/src/app/srs_app_http_api.cpp
View file

@ -1316,14 +1316,14 @@ srs_error_t SrsGoApiRaw::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage*
return err; return err;
} }
int SrsGoApiRaw::on_reload_http_api_raw_api() srs_error_t SrsGoApiRaw::on_reload_http_api_raw_api()
{ {
raw_api = _srs_config->get_raw_api(); raw_api = _srs_config->get_raw_api();
allow_reload = _srs_config->get_raw_api_allow_reload(); allow_reload = _srs_config->get_raw_api_allow_reload();
allow_query = _srs_config->get_raw_api_allow_query(); allow_query = _srs_config->get_raw_api_allow_query();
allow_update = _srs_config->get_raw_api_allow_update(); allow_update = _srs_config->get_raw_api_allow_update();
return ERROR_SUCCESS; return srs_success;
} }
SrsGoApiError::SrsGoApiError() SrsGoApiError::SrsGoApiError()

2
trunk/src/app/srs_app_http_api.hpp
View file

@ -189,7 +189,7 @@ public:
virtual srs_error_t serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r); virtual srs_error_t serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_http_api_raw_api(); virtual srs_error_t on_reload_http_api_raw_api();
}; };
class SrsGoApiError : public ISrsHttpHandler class SrsGoApiError : public ISrsHttpHandler

12
trunk/src/app/srs_app_http_static.cpp
View file

@ -289,22 +289,22 @@ int SrsHttpStaticServer::mount_vhost(string vhost, string& pmount)
return ret; return ret;
} }
int SrsHttpStaticServer::on_reload_vhost_added(string vhost) srs_error_t SrsHttpStaticServer::on_reload_vhost_added(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
string pmount; string pmount;
if ((ret = mount_vhost(vhost, pmount)) != ERROR_SUCCESS) { if ((ret = mount_vhost(vhost, pmount)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "mount vhost");
} }
return ret; return err;
} }
int SrsHttpStaticServer::on_reload_vhost_http_updated() srs_error_t SrsHttpStaticServer::on_reload_vhost_http_updated()
{ {
int ret = ERROR_SUCCESS;
// TODO: FIXME: implements it. // TODO: FIXME: implements it.
return ret; return srs_success;
} }

4
trunk/src/app/srs_app_http_static.hpp
View file

@ -63,8 +63,8 @@ private:
virtual int mount_vhost(std::string vhost, std::string& pmount); virtual int mount_vhost(std::string vhost, std::string& pmount);
// interface ISrsReloadHandler. // interface ISrsReloadHandler.
public: public:
virtual int on_reload_vhost_added(std::string vhost); virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual int on_reload_vhost_http_updated(); virtual srs_error_t on_reload_vhost_http_updated();
}; };
#endif #endif

24
trunk/src/app/srs_app_http_stream.cpp
View file

@ -813,29 +813,30 @@ void SrsHttpStreamServer::http_unmount(SrsSource* s, SrsRequest* r)
entry->stream->entry->enabled = false; entry->stream->entry->enabled = false;
} }
int SrsHttpStreamServer::on_reload_vhost_added(string vhost) srs_error_t SrsHttpStreamServer::on_reload_vhost_added(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if ((ret = on_reload_vhost_http_remux_updated(vhost)) != ERROR_SUCCESS) { if ((err = on_reload_vhost_http_remux_updated(vhost)) != srs_success) {
return ret; return srs_error_wrap(err, "reload vhost added");
} }
return ret; return err;
} }
int SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost) srs_error_t SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (tflvs.find(vhost) == tflvs.end()) { if (tflvs.find(vhost) == tflvs.end()) {
if ((ret = initialize_flv_entry(vhost)) != ERROR_SUCCESS) { if ((ret = initialize_flv_entry(vhost)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "init flv entry");
} }
// http mount need SrsRequest and SrsSource param, only create a mapping template entry // http mount need SrsRequest and SrsSource param, only create a mapping template entry
// and do mount automatically on playing http flv if this stream is a new http_remux stream. // and do mount automatically on playing http flv if this stream is a new http_remux stream.
return ret; return err;
} }
SrsLiveEntry* tmpl = tflvs[vhost]; SrsLiveEntry* tmpl = tflvs[vhost];
@ -848,7 +849,7 @@ int SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost)
} }
if (!_srs_config->get_vhost_http_remux_enabled(vhost)) { if (!_srs_config->get_vhost_http_remux_enabled(vhost)) {
return ret; return err;
} }
string old_tmpl_mount = tmpl->mount; string old_tmpl_mount = tmpl->mount;
@ -867,8 +868,7 @@ int SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost)
// remount stream. // remount stream.
if ((ret = http_mount(source, req)) != ERROR_SUCCESS) { if ((ret = http_mount(source, req)) != ERROR_SUCCESS) {
srs_trace("vhost %s http_remux reload failed", vhost.c_str()); return srs_error_new(ret, "vhost %s http_remux reload failed", vhost.c_str());
return ret;
} }
} else { } else {
// for without SrsRequest and SrsSource if stream is not played yet, do http mount automatically // for without SrsRequest and SrsSource if stream is not played yet, do http mount automatically
@ -877,7 +877,7 @@ int SrsHttpStreamServer::on_reload_vhost_http_remux_updated(string vhost)
srs_trace("vhost %s http_remux reload success", vhost.c_str()); srs_trace("vhost %s http_remux reload success", vhost.c_str());
return ret; return err;
} }
srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph) srs_error_t SrsHttpStreamServer::hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph)

4
trunk/src/app/srs_app_http_stream.hpp
View file

@ -290,8 +290,8 @@ public:
virtual void http_unmount(SrsSource* s, SrsRequest* r); virtual void http_unmount(SrsSource* s, SrsRequest* r);
// interface ISrsReloadHandler. // interface ISrsReloadHandler.
public: public:
virtual int on_reload_vhost_added(std::string vhost); virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual int on_reload_vhost_http_remux_updated(std::string vhost); virtual srs_error_t on_reload_vhost_http_remux_updated(std::string vhost);
// interface ISrsHttpMatchHijacker // interface ISrsHttpMatchHijacker
public: public:
virtual srs_error_t hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph); virtual srs_error_t hijack(ISrsHttpMessage* request, ISrsHttpHandler** ph);

50
trunk/src/app/srs_app_ingest.cpp
View file

@ -483,9 +483,9 @@ void SrsIngester::show_ingest_log_message()
} }
} }
int SrsIngester::on_reload_vhost_removed(string vhost) srs_error_t SrsIngester::on_reload_vhost_removed(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
std::vector<SrsIngesterFFMPEG*>::iterator it; std::vector<SrsIngesterFFMPEG*>::iterator it;
@ -508,26 +508,27 @@ int SrsIngester::on_reload_vhost_removed(string vhost)
it = ingesters.erase(it); it = ingesters.erase(it);
} }
return ret; return err;
} }
int SrsIngester::on_reload_vhost_added(string vhost) srs_error_t SrsIngester::on_reload_vhost_added(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsConfDirective* _vhost = _srs_config->get_vhost(vhost); SrsConfDirective* _vhost = _srs_config->get_vhost(vhost);
if ((ret = parse_ingesters(_vhost)) != ERROR_SUCCESS) { if ((ret = parse_ingesters(_vhost)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "parse ingesters");
} }
srs_trace("reload add vhost ingesters, vhost=%s", vhost.c_str()); srs_trace("reload add vhost ingesters, vhost=%s", vhost.c_str());
return ret; return err;
} }
int SrsIngester::on_reload_ingest_removed(string vhost, string ingest_id) srs_error_t SrsIngester::on_reload_ingest_removed(string vhost, string ingest_id)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
std::vector<SrsIngesterFFMPEG*>::iterator it; std::vector<SrsIngesterFFMPEG*>::iterator it;
@ -550,48 +551,47 @@ int SrsIngester::on_reload_ingest_removed(string vhost, string ingest_id)
it = ingesters.erase(it); it = ingesters.erase(it);
} }
return ret; return err;
} }
int SrsIngester::on_reload_ingest_added(string vhost, string ingest_id) srs_error_t SrsIngester::on_reload_ingest_added(string vhost, string ingest_id)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
SrsConfDirective* _vhost = _srs_config->get_vhost(vhost); SrsConfDirective* _vhost = _srs_config->get_vhost(vhost);
SrsConfDirective* _ingester = _srs_config->get_ingest_by_id(vhost, ingest_id); SrsConfDirective* _ingester = _srs_config->get_ingest_by_id(vhost, ingest_id);
if ((ret = parse_engines(_vhost, _ingester)) != ERROR_SUCCESS) { if ((ret = parse_engines(_vhost, _ingester)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "parse engines");
} }
srs_trace("reload add ingester, " srs_trace("reload add ingester, vhost=%s, id=%s", vhost.c_str(), ingest_id.c_str());
"vhost=%s, id=%s", vhost.c_str(), ingest_id.c_str());
return ret; return err;
} }
int SrsIngester::on_reload_ingest_updated(string vhost, string ingest_id) srs_error_t SrsIngester::on_reload_ingest_updated(string vhost, string ingest_id)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if ((ret = on_reload_ingest_removed(vhost, ingest_id)) != ERROR_SUCCESS) { if ((err = on_reload_ingest_removed(vhost, ingest_id)) != srs_success) {
return ret; return srs_error_wrap(err, "reload ingest removed");
} }
if ((ret = on_reload_ingest_added(vhost, ingest_id)) != ERROR_SUCCESS) { if ((err = on_reload_ingest_added(vhost, ingest_id)) != srs_success) {
return ret; return srs_error_wrap(err, "reload ingest added");
} }
srs_trace("reload updated ingester, " srs_trace("reload updated ingester, vhost=%s, id=%s", vhost.c_str(), ingest_id.c_str());
"vhost=%s, id=%s", vhost.c_str(), ingest_id.c_str());
return ret; return err;
} }
int SrsIngester::on_reload_listen() srs_error_t SrsIngester::on_reload_listen()
{ {
expired = true; expired = true;
return ERROR_SUCCESS; return srs_success;
} }
#endif #endif

12
trunk/src/app/srs_app_ingest.hpp
View file

@ -106,12 +106,12 @@ private:
virtual void show_ingest_log_message(); virtual void show_ingest_log_message();
// interface ISrsReloadHandler. // interface ISrsReloadHandler.
public: public:
virtual int on_reload_vhost_removed(std::string vhost); virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual int on_reload_vhost_added(std::string vhost); virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual int on_reload_ingest_removed(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_removed(std::string vhost, std::string ingest_id);
virtual int on_reload_ingest_added(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_added(std::string vhost, std::string ingest_id);
virtual int on_reload_ingest_updated(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_updated(std::string vhost, std::string ingest_id);
virtual int on_reload_listen(); virtual srs_error_t on_reload_listen();
}; };
#endif #endif

30
trunk/src/app/srs_app_log.cpp
View file

@ -206,23 +206,23 @@ srs_error_t SrsFastLog::on_reload_utc_time()
return srs_success; return srs_success;
} }
int SrsFastLog::on_reload_log_tank() srs_error_t SrsFastLog::on_reload_log_tank()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (!_srs_config) { if (!_srs_config) {
return ret; return err;
} }
bool tank = log_to_file_tank; bool tank = log_to_file_tank;
log_to_file_tank = _srs_config->get_log_tank_file(); log_to_file_tank = _srs_config->get_log_tank_file();
if (tank) { if (tank) {
return ret; return err;
} }
if (!log_to_file_tank) { if (!log_to_file_tank) {
return ret; return err;
} }
if (fd > 0) { if (fd > 0) {
@ -230,32 +230,32 @@ int SrsFastLog::on_reload_log_tank()
} }
open_log_file(); open_log_file();
return ret; return err;
} }
int SrsFastLog::on_reload_log_level() srs_error_t SrsFastLog::on_reload_log_level()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (!_srs_config) { if (!_srs_config) {
return ret; return err;
} }
level = srs_get_log_level(_srs_config->get_log_level()); level = srs_get_log_level(_srs_config->get_log_level());
return ret; return err;
} }
int SrsFastLog::on_reload_log_file() srs_error_t SrsFastLog::on_reload_log_file()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (!_srs_config) { if (!_srs_config) {
return ret; return err;
} }
if (!log_to_file_tank) { if (!log_to_file_tank) {
return ret; return err;
} }
if (fd > 0) { if (fd > 0) {
@ -263,7 +263,7 @@ int SrsFastLog::on_reload_log_file()
} }
open_log_file(); open_log_file();
return ret; return err;
} }
void SrsFastLog::write_log(int& fd, char *str_log, int size, int level) void SrsFastLog::write_log(int& fd, char *str_log, int size, int level)

6
trunk/src/app/srs_app_log.hpp
View file

@ -66,9 +66,9 @@ public:
// interface ISrsReloadHandler. // interface ISrsReloadHandler.
public: public:
virtual srs_error_t on_reload_utc_time(); virtual srs_error_t on_reload_utc_time();
virtual int on_reload_log_tank(); virtual srs_error_t on_reload_log_tank();
virtual int on_reload_log_level(); virtual srs_error_t on_reload_log_level();
virtual int on_reload_log_file(); virtual srs_error_t on_reload_log_file();
private: private:
virtual void write_log(int& fd, char* str_log, int size, int level); virtual void write_log(int& fd, char* str_log, int size, int level);
virtual void open_log_file(); virtual void open_log_file();

4
trunk/src/app/srs_app_pithy_print.cpp
View file

@ -69,10 +69,10 @@ bool SrsStageInfo::can_print()
return can_print; return can_print;
} }
int SrsStageInfo::on_reload_pithy_print() srs_error_t SrsStageInfo::on_reload_pithy_print()
{ {
update_print_time(); update_print_time();
return ERROR_SUCCESS; return srs_success;
} }
static std::map<int, SrsStageInfo*> _srs_stages; static std::map<int, SrsStageInfo*> _srs_stages;

2
trunk/src/app/srs_app_pithy_print.hpp
View file

@ -47,7 +47,7 @@ public:
virtual void elapse(int64_t diff); virtual void elapse(int64_t diff);
virtual bool can_print(); virtual bool can_print();
public: public:
virtual int on_reload_pithy_print(); virtual srs_error_t on_reload_pithy_print();
}; };
/** /**

16
trunk/src/app/srs_app_recv_thread.cpp
View file

@ -468,12 +468,12 @@ void SrsPublishRecvThread::on_read(ssize_t nread)
} }
#endif #endif
int SrsPublishRecvThread::on_reload_vhost_publish(string vhost) srs_error_t SrsPublishRecvThread::on_reload_vhost_publish(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// the mr settings, // the mr settings,
@ -505,22 +505,22 @@ int SrsPublishRecvThread::on_reload_vhost_publish(string vhost)
mr = mr_enabled; mr = mr_enabled;
mr_sleep = sleep_ms; mr_sleep = sleep_ms;
return ret; return err;
} }
int SrsPublishRecvThread::on_reload_vhost_realtime(string vhost) srs_error_t SrsPublishRecvThread::on_reload_vhost_realtime(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
bool realtime_enabled = _srs_config->get_realtime_enabled(req->vhost); bool realtime_enabled = _srs_config->get_realtime_enabled(req->vhost);
srs_trace("realtime changed %d=>%d", realtime, realtime_enabled); srs_trace("realtime changed %d=>%d", realtime, realtime_enabled);
realtime = realtime_enabled; realtime = realtime_enabled;
return ret; return err;
} }
void SrsPublishRecvThread::set_socket_buffer(int sleep_ms) void SrsPublishRecvThread::set_socket_buffer(int sleep_ms)

4
trunk/src/app/srs_app_recv_thread.hpp
View file

@ -217,8 +217,8 @@ public:
#endif #endif
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_vhost_publish(std::string vhost); virtual srs_error_t on_reload_vhost_publish(std::string vhost);
virtual int on_reload_vhost_realtime(std::string vhost); virtual srs_error_t on_reload_vhost_realtime(std::string vhost);
private: private:
virtual void set_socket_buffer(int sleep_ms); virtual void set_socket_buffer(int sleep_ms);
}; };

136
trunk/src/app/srs_app_reload.cpp
View file

@ -35,9 +35,9 @@ ISrsReloadHandler::~ISrsReloadHandler()
{ {
} }
int ISrsReloadHandler::on_reload_listen() srs_error_t ISrsReloadHandler::on_reload_listen()
{ {
return ERROR_SUCCESS; return srs_success;
} }
srs_error_t ISrsReloadHandler::on_reload_utc_time() srs_error_t ISrsReloadHandler::on_reload_utc_time()
@ -45,44 +45,44 @@ srs_error_t ISrsReloadHandler::on_reload_utc_time()
return srs_success; return srs_success;
} }
int ISrsReloadHandler::on_reload_max_conns() srs_error_t ISrsReloadHandler::on_reload_max_conns()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_pid() srs_error_t ISrsReloadHandler::on_reload_pid()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_log_tank() srs_error_t ISrsReloadHandler::on_reload_log_tank()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_log_level() srs_error_t ISrsReloadHandler::on_reload_log_level()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_log_file() srs_error_t ISrsReloadHandler::on_reload_log_file()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_pithy_print() srs_error_t ISrsReloadHandler::on_reload_pithy_print()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_http_api_enabled() srs_error_t ISrsReloadHandler::on_reload_http_api_enabled()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_http_api_disabled() srs_error_t ISrsReloadHandler::on_reload_http_api_disabled()
{ {
return ERROR_SUCCESS; return srs_success;
} }
srs_error_t ISrsReloadHandler::on_reload_http_api_crossdomain() srs_error_t ISrsReloadHandler::on_reload_http_api_crossdomain()
@ -90,24 +90,24 @@ srs_error_t ISrsReloadHandler::on_reload_http_api_crossdomain()
return srs_success; return srs_success;
} }
int ISrsReloadHandler::on_reload_http_api_raw_api() srs_error_t ISrsReloadHandler::on_reload_http_api_raw_api()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_http_stream_enabled() srs_error_t ISrsReloadHandler::on_reload_http_stream_enabled()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_http_stream_disabled() srs_error_t ISrsReloadHandler::on_reload_http_stream_disabled()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_http_stream_updated() srs_error_t ISrsReloadHandler::on_reload_http_stream_updated()
{ {
return ERROR_SUCCESS; return srs_success;
} }
srs_error_t ISrsReloadHandler::on_reload_http_stream_crossdomain() srs_error_t ISrsReloadHandler::on_reload_http_stream_crossdomain()
@ -115,108 +115,108 @@ srs_error_t ISrsReloadHandler::on_reload_http_stream_crossdomain()
return srs_success; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_http_updated() srs_error_t ISrsReloadHandler::on_reload_vhost_http_updated()
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_http_remux_updated(string vhost) srs_error_t ISrsReloadHandler::on_reload_vhost_http_remux_updated(string vhost)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_added(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_added(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_removed(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_removed(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_play(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_play(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_forward(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_forward(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_dash(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_dash(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_hls(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_hls(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_hds(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_hds(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_dvr(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_dvr(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_dvr_apply(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_dvr_apply(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_publish(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_publish(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_tcp_nodelay(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_tcp_nodelay(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_realtime(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_realtime(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_chunk_size(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_chunk_size(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_transcode(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_transcode(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_vhost_exec(string /*vhost*/) srs_error_t ISrsReloadHandler::on_reload_vhost_exec(string /*vhost*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_ingest_removed(string /*vhost*/, string /*ingest_id*/) srs_error_t ISrsReloadHandler::on_reload_ingest_removed(string /*vhost*/, string /*ingest_id*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_ingest_added(string /*vhost*/, string /*ingest_id*/) srs_error_t ISrsReloadHandler::on_reload_ingest_added(string /*vhost*/, string /*ingest_id*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_ingest_updated(string /*vhost*/, string /*ingest_id*/) srs_error_t ISrsReloadHandler::on_reload_ingest_updated(string /*vhost*/, string /*ingest_id*/)
{ {
return ERROR_SUCCESS; return srs_success;
} }
int ISrsReloadHandler::on_reload_user_info() srs_error_t ISrsReloadHandler::on_reload_user_info()
{ {
return ERROR_SUCCESS; return srs_success;
} }

68
trunk/src/app/srs_app_reload.hpp
View file

@ -42,44 +42,44 @@ public:
virtual ~ISrsReloadHandler(); virtual ~ISrsReloadHandler();
public: public:
virtual srs_error_t on_reload_utc_time(); virtual srs_error_t on_reload_utc_time();
virtual int on_reload_max_conns(); virtual srs_error_t on_reload_max_conns();
virtual int on_reload_listen(); virtual srs_error_t on_reload_listen();
virtual int on_reload_pid(); virtual srs_error_t on_reload_pid();
virtual int on_reload_log_tank(); virtual srs_error_t on_reload_log_tank();
virtual int on_reload_log_level(); virtual srs_error_t on_reload_log_level();
virtual int on_reload_log_file(); virtual srs_error_t on_reload_log_file();
virtual int on_reload_pithy_print(); virtual srs_error_t on_reload_pithy_print();
virtual int on_reload_http_api_enabled(); virtual srs_error_t on_reload_http_api_enabled();
virtual int on_reload_http_api_disabled(); virtual srs_error_t on_reload_http_api_disabled();
virtual srs_error_t on_reload_http_api_crossdomain(); virtual srs_error_t on_reload_http_api_crossdomain();
virtual int on_reload_http_api_raw_api(); virtual srs_error_t on_reload_http_api_raw_api();
virtual int on_reload_http_stream_enabled(); virtual srs_error_t on_reload_http_stream_enabled();
virtual int on_reload_http_stream_disabled(); virtual srs_error_t on_reload_http_stream_disabled();
virtual int on_reload_http_stream_updated(); virtual srs_error_t on_reload_http_stream_updated();
virtual srs_error_t on_reload_http_stream_crossdomain(); virtual srs_error_t on_reload_http_stream_crossdomain();
public: public:
// TODO: FIXME: should rename to http_static // TODO: FIXME: should rename to http_static
virtual int on_reload_vhost_http_updated(); virtual srs_error_t on_reload_vhost_http_updated();
virtual int on_reload_vhost_http_remux_updated(std::string vhost); virtual srs_error_t on_reload_vhost_http_remux_updated(std::string vhost);
virtual int on_reload_vhost_added(std::string vhost); virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual int on_reload_vhost_removed(std::string vhost); virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual int on_reload_vhost_play(std::string vhost); virtual srs_error_t on_reload_vhost_play(std::string vhost);
virtual int on_reload_vhost_forward(std::string vhost); virtual srs_error_t on_reload_vhost_forward(std::string vhost);
virtual int on_reload_vhost_dash(std::string vhost); virtual srs_error_t on_reload_vhost_dash(std::string vhost);
virtual int on_reload_vhost_hls(std::string vhost); virtual srs_error_t on_reload_vhost_hls(std::string vhost);
virtual int on_reload_vhost_hds(std::string vhost); virtual srs_error_t on_reload_vhost_hds(std::string vhost);
virtual int on_reload_vhost_dvr(std::string vhost); virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
virtual int on_reload_vhost_dvr_apply(std::string vhost); virtual srs_error_t on_reload_vhost_dvr_apply(std::string vhost);
virtual int on_reload_vhost_publish(std::string vhost); virtual srs_error_t on_reload_vhost_publish(std::string vhost);
virtual int on_reload_vhost_tcp_nodelay(std::string vhost); virtual srs_error_t on_reload_vhost_tcp_nodelay(std::string vhost);
virtual int on_reload_vhost_realtime(std::string vhost); virtual srs_error_t on_reload_vhost_realtime(std::string vhost);
virtual int on_reload_vhost_chunk_size(std::string vhost); virtual srs_error_t on_reload_vhost_chunk_size(std::string vhost);
virtual int on_reload_vhost_transcode(std::string vhost); virtual srs_error_t on_reload_vhost_transcode(std::string vhost);
virtual int on_reload_vhost_exec(std::string vhost); virtual srs_error_t on_reload_vhost_exec(std::string vhost);
virtual int on_reload_ingest_removed(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_removed(std::string vhost, std::string ingest_id);
virtual int on_reload_ingest_added(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_added(std::string vhost, std::string ingest_id);
virtual int on_reload_ingest_updated(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_updated(std::string vhost, std::string ingest_id);
virtual int on_reload_user_info(); virtual srs_error_t on_reload_user_info();
}; };
#endif #endif

40
trunk/src/app/srs_app_rtmp_conn.cpp
View file

@ -252,14 +252,14 @@ srs_error_t SrsRtmpConn::do_cycle()
return err; return err;
} }
int SrsRtmpConn::on_reload_vhost_removed(string vhost) srs_error_t SrsRtmpConn::on_reload_vhost_removed(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
SrsRequest* req = info->req; SrsRequest* req = info->req;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// if the vhost connected is removed, disconnect the client. // if the vhost connected is removed, disconnect the client.
@ -271,17 +271,17 @@ int SrsRtmpConn::on_reload_vhost_removed(string vhost)
// so we just ignore the vhost enabled event. // so we just ignore the vhost enabled event.
//srs_close_stfd(stfd); //srs_close_stfd(stfd);
return ret; return err;
} }
int SrsRtmpConn::on_reload_vhost_play(string vhost) srs_error_t SrsRtmpConn::on_reload_vhost_play(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
SrsRequest* req = info->req; SrsRequest* req = info->req;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// send_min_interval // send_min_interval
@ -293,32 +293,32 @@ int SrsRtmpConn::on_reload_vhost_play(string vhost)
} }
} }
return ret; return err;
} }
int SrsRtmpConn::on_reload_vhost_tcp_nodelay(string vhost) srs_error_t SrsRtmpConn::on_reload_vhost_tcp_nodelay(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
SrsRequest* req = info->req; SrsRequest* req = info->req;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
set_sock_options(); set_sock_options();
return ret; return err;
} }
int SrsRtmpConn::on_reload_vhost_realtime(string vhost) srs_error_t SrsRtmpConn::on_reload_vhost_realtime(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
SrsRequest* req = info->req; SrsRequest* req = info->req;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
bool realtime_enabled = _srs_config->get_realtime_enabled(req->vhost); bool realtime_enabled = _srs_config->get_realtime_enabled(req->vhost);
@ -327,17 +327,17 @@ int SrsRtmpConn::on_reload_vhost_realtime(string vhost)
realtime = realtime_enabled; realtime = realtime_enabled;
} }
return ret; return err;
} }
int SrsRtmpConn::on_reload_vhost_publish(string vhost) srs_error_t SrsRtmpConn::on_reload_vhost_publish(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
SrsRequest* req = info->req; SrsRequest* req = info->req;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
int p1stpt = _srs_config->get_publish_1stpkt_timeout(req->vhost); int p1stpt = _srs_config->get_publish_1stpkt_timeout(req->vhost);
@ -352,7 +352,7 @@ int SrsRtmpConn::on_reload_vhost_publish(string vhost)
publish_normal_timeout = pnt; publish_normal_timeout = pnt;
} }
return ret; return err;
} }
void SrsRtmpConn::resample() void SrsRtmpConn::resample()

10
trunk/src/app/srs_app_rtmp_conn.hpp
View file

@ -135,11 +135,11 @@ protected:
virtual srs_error_t do_cycle(); virtual srs_error_t do_cycle();
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_vhost_removed(std::string vhost); virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual int on_reload_vhost_play(std::string vhost); virtual srs_error_t on_reload_vhost_play(std::string vhost);
virtual int on_reload_vhost_tcp_nodelay(std::string vhost); virtual srs_error_t on_reload_vhost_tcp_nodelay(std::string vhost);
virtual int on_reload_vhost_realtime(std::string vhost); virtual srs_error_t on_reload_vhost_realtime(std::string vhost);
virtual int on_reload_vhost_publish(std::string vhost); virtual srs_error_t on_reload_vhost_publish(std::string vhost);
// interface IKbpsDelta // interface IKbpsDelta
public: public:
virtual void resample(); virtual void resample();

100
trunk/src/app/srs_app_server.cpp
View file

@ -1283,102 +1283,110 @@ void SrsServer::remove(ISrsConnection* c)
conn_manager->remove(c); conn_manager->remove(c);
} }
int SrsServer::on_reload_listen() srs_error_t SrsServer::on_reload_listen()
{ {
// TODO: FIXME: Use error. srs_error_t err = srs_success;
srs_error_t err = listen();
int ret = srs_error_code(err); if ((err = listen()) != srs_success) {
srs_freep(err); return srs_error_wrap(err, "reload listen");
return ret; }
return err;
} }
int SrsServer::on_reload_pid() srs_error_t SrsServer::on_reload_pid()
{ {
srs_error_t err = srs_success;
if (pid_fd > 0) { if (pid_fd > 0) {
::close(pid_fd); ::close(pid_fd);
pid_fd = -1; pid_fd = -1;
} }
// TODO: FIXME: Use error. if ((err = acquire_pid_file()) != srs_success) {
srs_error_t err = acquire_pid_file(); return srs_error_wrap(err, "reload pid");
int ret = srs_error_code(err); }
srs_freep(err);
return ret; return err;
} }
int SrsServer::on_reload_vhost_added(std::string vhost) srs_error_t SrsServer::on_reload_vhost_added(std::string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (!_srs_config->get_vhost_http_enabled(vhost)) { if (!_srs_config->get_vhost_http_enabled(vhost)) {
return ret; return err;
} }
// TODO: FIXME: should handle the event in SrsHttpStaticServer // TODO: FIXME: should handle the event in SrsHttpStaticServer
if ((ret = on_reload_vhost_http_updated()) != ERROR_SUCCESS) { if ((err = on_reload_vhost_http_updated()) != srs_success) {
return ret; return srs_error_wrap(err, "reload vhost added");
} }
return ret; return err;
} }
int SrsServer::on_reload_vhost_removed(std::string /*vhost*/) srs_error_t SrsServer::on_reload_vhost_removed(std::string /*vhost*/)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
// TODO: FIXME: should handle the event in SrsHttpStaticServer // TODO: FIXME: should handle the event in SrsHttpStaticServer
if ((ret = on_reload_vhost_http_updated()) != ERROR_SUCCESS) { if ((err = on_reload_vhost_http_updated()) != srs_success) {
return ret; return srs_error_wrap(err, "reload vhost removed");
} }
return ret; return err;
} }
int SrsServer::on_reload_http_api_enabled() srs_error_t SrsServer::on_reload_http_api_enabled()
{ {
// TODO: FIXME: Use error. srs_error_t err = srs_success;
srs_error_t err = listen_http_api();
int ret = srs_error_code(err); if ((err = listen_http_api()) != srs_success) {
srs_freep(err); return srs_error_wrap(err, "reload http_api");
return ret; }
return err;
} }
int SrsServer::on_reload_http_api_disabled() srs_error_t SrsServer::on_reload_http_api_disabled()
{ {
close_listeners(SrsListenerHttpApi); close_listeners(SrsListenerHttpApi);
return ERROR_SUCCESS; return srs_success;
} }
int SrsServer::on_reload_http_stream_enabled() srs_error_t SrsServer::on_reload_http_stream_enabled()
{ {
// TODO: FIXME: Use error. srs_error_t err = srs_success;
srs_error_t err = listen_http_stream();
int ret = srs_error_code(err); if ((err = listen_http_stream()) != srs_success) {
srs_freep(err); return srs_error_wrap(err, "reload http_stream enabled");
return ret; }
return err;
} }
int SrsServer::on_reload_http_stream_disabled() srs_error_t SrsServer::on_reload_http_stream_disabled()
{ {
close_listeners(SrsListenerHttpStream); close_listeners(SrsListenerHttpStream);
return ERROR_SUCCESS; return srs_success;
} }
// TODO: FIXME: rename to http_remux // TODO: FIXME: rename to http_remux
int SrsServer::on_reload_http_stream_updated() srs_error_t SrsServer::on_reload_http_stream_updated()
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if ((ret = on_reload_http_stream_enabled()) != ERROR_SUCCESS) { if ((err = on_reload_http_stream_enabled()) != srs_success) {
return ret; return srs_error_wrap(err, "reload http_stream updated");
} }
// TODO: FIXME: should handle the event in SrsHttpStaticServer // TODO: FIXME: should handle the event in SrsHttpStaticServer
if ((ret = on_reload_vhost_http_updated()) != ERROR_SUCCESS) { if ((err = on_reload_vhost_http_updated()) != srs_success) {
return ret; return srs_error_wrap(err, "reload http_stream updated");
} }
return ret; return err;
} }
int SrsServer::on_publish(SrsSource* s, SrsRequest* r) int SrsServer::on_publish(SrsSource* s, SrsRequest* r)

18
trunk/src/app/srs_app_server.hpp
View file

@ -371,15 +371,15 @@ public:
virtual void remove(ISrsConnection* c); virtual void remove(ISrsConnection* c);
// interface ISrsReloadHandler. // interface ISrsReloadHandler.
public: public:
virtual int on_reload_listen(); virtual srs_error_t on_reload_listen();
virtual int on_reload_pid(); virtual srs_error_t on_reload_pid();
virtual int on_reload_vhost_added(std::string vhost); virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual int on_reload_vhost_removed(std::string vhost); virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual int on_reload_http_api_enabled(); virtual srs_error_t on_reload_http_api_enabled();
virtual int on_reload_http_api_disabled(); virtual srs_error_t on_reload_http_api_disabled();
virtual int on_reload_http_stream_enabled(); virtual srs_error_t on_reload_http_stream_enabled();
virtual int on_reload_http_stream_disabled(); virtual srs_error_t on_reload_http_stream_disabled();
virtual int on_reload_http_stream_updated(); virtual srs_error_t on_reload_http_stream_updated();
// interface ISrsSourceHandler // interface ISrsSourceHandler
public: public:
virtual int on_publish(SrsSource* s, SrsRequest* r); virtual int on_publish(SrsSource* s, SrsRequest* r);

119
trunk/src/app/srs_app_source.cpp
View file

@ -1295,12 +1295,13 @@ int SrsOriginHub::on_dvr_request_sh()
return ret; return ret;
} }
int SrsOriginHub::on_reload_vhost_forward(string vhost) srs_error_t SrsOriginHub::on_reload_vhost_forward(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// TODO: FIXME: maybe should ignore when publish already stopped? // TODO: FIXME: maybe should ignore when publish already stopped?
@ -1310,70 +1311,68 @@ int SrsOriginHub::on_reload_vhost_forward(string vhost)
// Don't start forwarders when source is not active. // Don't start forwarders when source is not active.
if (!is_active) { if (!is_active) {
return ret; return err;
} }
if ((ret = create_forwarders()) != ERROR_SUCCESS) { if ((ret = create_forwarders()) != ERROR_SUCCESS) {
srs_error("create forwarders failed. ret=%d", ret); return srs_error_new(ret, "create forwarders");
return ret;
} }
srs_trace("vhost %s forwarders reload success", vhost.c_str()); srs_trace("vhost %s forwarders reload success", vhost.c_str());
return ret; return err;
} }
int SrsOriginHub::on_reload_vhost_dash(string vhost) srs_error_t SrsOriginHub::on_reload_vhost_dash(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
dash->on_unpublish(); dash->on_unpublish();
// Don't start DASH when source is not active. // Don't start DASH when source is not active.
if (!is_active) { if (!is_active) {
return ret; return err;
} }
if ((ret = dash->on_publish()) != ERROR_SUCCESS) { if ((ret = dash->on_publish()) != ERROR_SUCCESS) {
srs_error("DASH start failed, ret=%d", ret); return srs_error_new(ret, "dash start publish");
return ret;
} }
SrsSharedPtrMessage* cache_sh_video = source->meta->vsh(); SrsSharedPtrMessage* cache_sh_video = source->meta->vsh();
if (cache_sh_video) { if (cache_sh_video) {
if ((ret = format->on_video(cache_sh_video)) != ERROR_SUCCESS) { if ((ret = format->on_video(cache_sh_video)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "format on_video");
} }
if ((ret = dash->on_video(cache_sh_video, format)) != ERROR_SUCCESS) { if ((ret = dash->on_video(cache_sh_video, format)) != ERROR_SUCCESS) {
srs_error("DASH consume video failed. ret=%d", ret); return srs_error_new(ret, "dash on_video");
return ret;
} }
} }
SrsSharedPtrMessage* cache_sh_audio = source->meta->ash(); SrsSharedPtrMessage* cache_sh_audio = source->meta->ash();
if (cache_sh_audio) { if (cache_sh_audio) {
if ((ret = format->on_audio(cache_sh_audio)) != ERROR_SUCCESS) { if ((ret = format->on_audio(cache_sh_audio)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "format on_audio");
} }
if ((ret = dash->on_audio(cache_sh_audio, format)) != ERROR_SUCCESS) { if ((ret = dash->on_audio(cache_sh_audio, format)) != ERROR_SUCCESS) {
srs_error("DASH consume audio failed. ret=%d", ret); return srs_error_new(ret, "dash on_audio");
return ret;
} }
} }
return ret; return err;
} }
int SrsOriginHub::on_reload_vhost_hls(string vhost) srs_error_t SrsOriginHub::on_reload_vhost_hls(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// TODO: FIXME: maybe should ignore when publish already stopped? // TODO: FIXME: maybe should ignore when publish already stopped?
@ -1382,12 +1381,11 @@ int SrsOriginHub::on_reload_vhost_hls(string vhost)
// Don't start HLS when source is not active. // Don't start HLS when source is not active.
if (!is_active) { if (!is_active) {
return ret; return err;
} }
if ((ret = hls->on_publish()) != ERROR_SUCCESS) { if ((ret = hls->on_publish()) != ERROR_SUCCESS) {
srs_error("hls publish failed. ret=%d", ret); return srs_error_new(ret, "hls publish failed");
return ret;
} }
srs_trace("vhost %s hls reload success", vhost.c_str()); srs_trace("vhost %s hls reload success", vhost.c_str());
@ -1399,34 +1397,33 @@ int SrsOriginHub::on_reload_vhost_hls(string vhost)
SrsSharedPtrMessage* cache_sh_video = source->meta->vsh(); SrsSharedPtrMessage* cache_sh_video = source->meta->vsh();
if (cache_sh_video) { if (cache_sh_video) {
if ((ret = format->on_video(cache_sh_video)) != ERROR_SUCCESS) { if ((ret = format->on_video(cache_sh_video)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "format on_video");
} }
if ((ret = hls->on_video(cache_sh_video, format)) != ERROR_SUCCESS) { if ((ret = hls->on_video(cache_sh_video, format)) != ERROR_SUCCESS) {
srs_error("hls process video sequence header message failed. ret=%d", ret); return srs_error_new(ret, "hls on_video");
return ret;
} }
} }
SrsSharedPtrMessage* cache_sh_audio = source->meta->ash(); SrsSharedPtrMessage* cache_sh_audio = source->meta->ash();
if (cache_sh_audio) { if (cache_sh_audio) {
if ((ret = format->on_audio(cache_sh_audio)) != ERROR_SUCCESS) { if ((ret = format->on_audio(cache_sh_audio)) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "format on_audio");
} }
if ((ret = hls->on_audio(cache_sh_audio, format)) != ERROR_SUCCESS) { if ((ret = hls->on_audio(cache_sh_audio, format)) != ERROR_SUCCESS) {
srs_error("hls process audio sequence header message failed. ret=%d", ret); return srs_error_new(ret, "hls on_audio");
return ret;
} }
} }
return ret; return err;
} }
int SrsOriginHub::on_reload_vhost_hds(string vhost) srs_error_t SrsOriginHub::on_reload_vhost_hds(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// TODO: FIXME: maybe should ignore when publish already stopped? // TODO: FIXME: maybe should ignore when publish already stopped?
@ -1436,26 +1433,25 @@ int SrsOriginHub::on_reload_vhost_hds(string vhost)
// Don't start HDS when source is not active. // Don't start HDS when source is not active.
if (!is_active) { if (!is_active) {
return ret; return err;
} }
if ((ret = hds->on_publish(req)) != ERROR_SUCCESS) { if ((ret = hds->on_publish(req)) != ERROR_SUCCESS) {
srs_error("hds publish failed. ret=%d", ret); return srs_error_new(ret, "hds publish failed");
return ret;
} }
srs_trace("vhost %s hds reload success", vhost.c_str()); srs_trace("vhost %s hds reload success", vhost.c_str());
#endif #endif
return ret; return err;
} }
int SrsOriginHub::on_reload_vhost_dvr(string vhost) srs_error_t SrsOriginHub::on_reload_vhost_dvr(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success; srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// TODO: FIXME: maybe should ignore when publish already stopped? // TODO: FIXME: maybe should ignore when publish already stopped?
@ -1465,39 +1461,35 @@ int SrsOriginHub::on_reload_vhost_dvr(string vhost)
// Don't start DVR when source is not active. // Don't start DVR when source is not active.
if (!is_active) { if (!is_active) {
return ret; return err;
} }
// reinitialize the dvr, update plan. // reinitialize the dvr, update plan.
if ((err = dvr->initialize(this, req)) != srs_success) { if ((err = dvr->initialize(this, req)) != srs_success) {
// TODO: FIXME: Use error. return srs_error_wrap(err, "reload dvr");
ret = srs_error_code(err);
srs_freep(err);
return ret;
} }
// start to publish by new plan. // start to publish by new plan.
if ((ret = dvr->on_publish()) != ERROR_SUCCESS) { if ((ret = dvr->on_publish()) != ERROR_SUCCESS) {
srs_error("dvr publish failed. ret=%d", ret); return srs_error_new(ret, "dvr publish failed");
return ret;
} }
if ((ret = on_dvr_request_sh()) != ERROR_SUCCESS) { if ((ret = on_dvr_request_sh()) != ERROR_SUCCESS) {
return ret; return srs_error_new(ret, "request sh");
} }
srs_trace("vhost %s dvr reload success", vhost.c_str()); srs_trace("vhost %s dvr reload success", vhost.c_str());
return ret; return err;
} }
int SrsOriginHub::on_reload_vhost_transcode(string vhost) srs_error_t SrsOriginHub::on_reload_vhost_transcode(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// TODO: FIXME: maybe should ignore when publish already stopped? // TODO: FIXME: maybe should ignore when publish already stopped?
@ -1507,25 +1499,25 @@ int SrsOriginHub::on_reload_vhost_transcode(string vhost)
// Don't start transcode when source is not active. // Don't start transcode when source is not active.
if (!is_active) { if (!is_active) {
return ret; return err;
} }
if ((ret = encoder->on_publish(req)) != ERROR_SUCCESS) { if ((ret = encoder->on_publish(req)) != ERROR_SUCCESS) {
srs_error("start encoder failed. ret=%d", ret); return srs_error_new(ret, "start encoder failed");
return ret;
} }
srs_trace("vhost %s transcode reload success", vhost.c_str()); srs_trace("vhost %s transcode reload success", vhost.c_str());
#endif #endif
return ret; return err;
} }
int SrsOriginHub::on_reload_vhost_exec(string vhost) srs_error_t SrsOriginHub::on_reload_vhost_exec(string vhost)
{ {
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// TODO: FIXME: maybe should ignore when publish already stopped? // TODO: FIXME: maybe should ignore when publish already stopped?
@ -1534,16 +1526,15 @@ int SrsOriginHub::on_reload_vhost_exec(string vhost)
// Don't start exec when source is not active. // Don't start exec when source is not active.
if (!is_active) { if (!is_active) {
return ret; return err;
} }
if ((ret = ng_exec->on_publish(req)) != ERROR_SUCCESS) { if ((ret = ng_exec->on_publish(req)) != ERROR_SUCCESS) {
srs_error("start exec failed. ret=%d", ret); return srs_error_new(ret, "start exec failed");
return ret;
} }
srs_trace("vhost %s exec reload success", vhost.c_str()); srs_trace("vhost %s exec reload success", vhost.c_str());
return ret; return err;
} }
int SrsOriginHub::create_forwarders() int SrsOriginHub::create_forwarders()
@ -1993,12 +1984,12 @@ srs_error_t SrsSource::initialize(SrsRequest* r, ISrsSourceHandler* h)
return err; return err;
} }
int SrsSource::on_reload_vhost_play(string vhost) srs_error_t SrsSource::on_reload_vhost_play(string vhost)
{ {
int ret = ERROR_SUCCESS; srs_error_t err = srs_success;
if (req->vhost != vhost) { if (req->vhost != vhost) {
return ret; return err;
} }
// time_jitter // time_jitter
@ -2073,7 +2064,7 @@ int SrsSource::on_reload_vhost_play(string vhost)
#endif #endif
} }
return ret; return err;
} }
int SrsSource::on_source_id_changed(int id) int SrsSource::on_source_id_changed(int id)

16
trunk/src/app/srs_app_source.hpp
View file

@ -472,13 +472,13 @@ public:
virtual int on_dvr_request_sh(); virtual int on_dvr_request_sh();
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_vhost_forward(std::string vhost); virtual srs_error_t on_reload_vhost_forward(std::string vhost);
virtual int on_reload_vhost_dash(std::string vhost); virtual srs_error_t on_reload_vhost_dash(std::string vhost);
virtual int on_reload_vhost_hls(std::string vhost); virtual srs_error_t on_reload_vhost_hls(std::string vhost);
virtual int on_reload_vhost_hds(std::string vhost); virtual srs_error_t on_reload_vhost_hds(std::string vhost);
virtual int on_reload_vhost_dvr(std::string vhost); virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
virtual int on_reload_vhost_transcode(std::string vhost); virtual srs_error_t on_reload_vhost_transcode(std::string vhost);
virtual int on_reload_vhost_exec(std::string vhost); virtual srs_error_t on_reload_vhost_exec(std::string vhost);
private: private:
virtual int create_forwarders(); virtual int create_forwarders();
virtual void destroy_forwarders(); virtual void destroy_forwarders();
@ -631,7 +631,7 @@ public:
virtual srs_error_t initialize(SrsRequest* r, ISrsSourceHandler* h); virtual srs_error_t initialize(SrsRequest* r, ISrsSourceHandler* h);
// interface ISrsReloadHandler // interface ISrsReloadHandler
public: public:
virtual int on_reload_vhost_play(std::string vhost); virtual srs_error_t on_reload_vhost_play(std::string vhost);
// for the tools callback // for the tools callback
public: public:
// source id changed. // source id changed.

92
trunk/src/utest/srs_utest_reload.cpp
View file

@ -137,142 +137,142 @@ bool MockReloadHandler::all_true()
return count_true() == count_total(); return count_true() == count_total();
} }
int MockReloadHandler::on_reload_listen() srs_error_t MockReloadHandler::on_reload_listen()
{ {
listen_reloaded = true; listen_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_pid() srs_error_t MockReloadHandler::on_reload_pid()
{ {
pid_reloaded = true; pid_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_log_tank() srs_error_t MockReloadHandler::on_reload_log_tank()
{ {
log_tank_reloaded = true; log_tank_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_log_level() srs_error_t MockReloadHandler::on_reload_log_level()
{ {
log_level_reloaded = true; log_level_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_log_file() srs_error_t MockReloadHandler::on_reload_log_file()
{ {
log_file_reloaded = true; log_file_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_pithy_print() srs_error_t MockReloadHandler::on_reload_pithy_print()
{ {
pithy_print_reloaded = true; pithy_print_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_http_api_enabled() srs_error_t MockReloadHandler::on_reload_http_api_enabled()
{ {
http_api_enabled_reloaded = true; http_api_enabled_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_http_api_disabled() srs_error_t MockReloadHandler::on_reload_http_api_disabled()
{ {
http_api_disabled_reloaded = true; http_api_disabled_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_http_stream_enabled() srs_error_t MockReloadHandler::on_reload_http_stream_enabled()
{ {
http_stream_enabled_reloaded = true; http_stream_enabled_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_http_stream_disabled() srs_error_t MockReloadHandler::on_reload_http_stream_disabled()
{ {
http_stream_disabled_reloaded = true; http_stream_disabled_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_http_stream_updated() srs_error_t MockReloadHandler::on_reload_http_stream_updated()
{ {
http_stream_updated_reloaded = true; http_stream_updated_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_http_updated() srs_error_t MockReloadHandler::on_reload_vhost_http_updated()
{ {
vhost_http_updated_reloaded = true; vhost_http_updated_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_added(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_added(string /*vhost*/)
{ {
vhost_added_reloaded = true; vhost_added_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_removed(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_removed(string /*vhost*/)
{ {
vhost_removed_reloaded = true; vhost_removed_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_play(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_play(string /*vhost*/)
{ {
vhost_play_reloaded = true; vhost_play_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_forward(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_forward(string /*vhost*/)
{ {
vhost_forward_reloaded = true; vhost_forward_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_hls(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_hls(string /*vhost*/)
{ {
vhost_hls_reloaded = true; vhost_hls_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_hds(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_hds(string /*vhost*/)
{ {
vhost_hls_reloaded = true; vhost_hls_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_dvr(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_dvr(string /*vhost*/)
{ {
vhost_dvr_reloaded = true; vhost_dvr_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_vhost_transcode(string /*vhost*/) srs_error_t MockReloadHandler::on_reload_vhost_transcode(string /*vhost*/)
{ {
vhost_transcode_reloaded = true; vhost_transcode_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_ingest_removed(string /*vhost*/, string /*ingest_id*/) srs_error_t MockReloadHandler::on_reload_ingest_removed(string /*vhost*/, string /*ingest_id*/)
{ {
ingest_removed_reloaded = true; ingest_removed_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_ingest_added(string /*vhost*/, string /*ingest_id*/) srs_error_t MockReloadHandler::on_reload_ingest_added(string /*vhost*/, string /*ingest_id*/)
{ {
ingest_added_reloaded = true; ingest_added_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
int MockReloadHandler::on_reload_ingest_updated(string /*vhost*/, string /*ingest_id*/) srs_error_t MockReloadHandler::on_reload_ingest_updated(string /*vhost*/, string /*ingest_id*/)
{ {
ingest_updated_reloaded = true; ingest_updated_reloaded = true;
return ERROR_SUCCESS; return srs_success;
} }
MockSrsReloadConfig::MockSrsReloadConfig() MockSrsReloadConfig::MockSrsReloadConfig()

46
trunk/src/utest/srs_utest_reload.hpp
View file

@ -68,29 +68,29 @@ public:
virtual int count_true(); virtual int count_true();
virtual int count_false(); virtual int count_false();
public: public:
virtual int on_reload_listen(); virtual srs_error_t on_reload_listen();
virtual int on_reload_pid(); virtual srs_error_t on_reload_pid();
virtual int on_reload_log_tank(); virtual srs_error_t on_reload_log_tank();
virtual int on_reload_log_level(); virtual srs_error_t on_reload_log_level();
virtual int on_reload_log_file(); virtual srs_error_t on_reload_log_file();
virtual int on_reload_pithy_print(); virtual srs_error_t on_reload_pithy_print();
virtual int on_reload_http_api_enabled(); virtual srs_error_t on_reload_http_api_enabled();
virtual int on_reload_http_api_disabled(); virtual srs_error_t on_reload_http_api_disabled();
virtual int on_reload_http_stream_enabled(); virtual srs_error_t on_reload_http_stream_enabled();
virtual int on_reload_http_stream_disabled(); virtual srs_error_t on_reload_http_stream_disabled();
virtual int on_reload_http_stream_updated(); virtual srs_error_t on_reload_http_stream_updated();
virtual int on_reload_vhost_http_updated(); virtual srs_error_t on_reload_vhost_http_updated();
virtual int on_reload_vhost_added(std::string vhost); virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual int on_reload_vhost_removed(std::string vhost); virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual int on_reload_vhost_play(std::string vhost); virtual srs_error_t on_reload_vhost_play(std::string vhost);
virtual int on_reload_vhost_forward(std::string vhost); virtual srs_error_t on_reload_vhost_forward(std::string vhost);
virtual int on_reload_vhost_hls(std::string vhost); virtual srs_error_t on_reload_vhost_hls(std::string vhost);
virtual int on_reload_vhost_hds(std::string vhost); virtual srs_error_t on_reload_vhost_hds(std::string vhost);
virtual int on_reload_vhost_dvr(std::string vhost); virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
virtual int on_reload_vhost_transcode(std::string vhost); virtual srs_error_t on_reload_vhost_transcode(std::string vhost);
virtual int on_reload_ingest_removed(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_removed(std::string vhost, std::string ingest_id);
virtual int on_reload_ingest_added(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_added(std::string vhost, std::string ingest_id);
virtual int on_reload_ingest_updated(std::string vhost, std::string ingest_id); virtual srs_error_t on_reload_ingest_updated(std::string vhost, std::string ingest_id);
}; };
class MockSrsReloadConfig : public MockSrsConfig class MockSrsReloadConfig : public MockSrsConfig