R3944Realms/srs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AI: Remove most of reload, only keep framework. (#4458)

Browse Source 
Co-authored-by: OSSRS-AI <winlinam@gmail.com>
This commit is contained in:
Winlin 2025-08-30 09:44:37 -04:00 committed by GitHub
parent 35e2808f0c
commit 5d69569f07
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 28 additions and 1536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

498
trunk/src/app/srs_app_config.cpp
View File

@ -1462,22 +1462,17 @@ srs_error_t SrsConfig::reload(SrsReloadState *pstate)
}
// LCOV_EXCL_STOP
srs_error_t SrsConfig::reload_vhost(SrsConfDirective *old_root)
srs_error_t SrsConfig::reload_conf(SrsConfig *conf)
{
srs_error_t err = srs_success;
SrsUniquePtr<SrsConfDirective> old_root(root);
root = conf->root;
conf->root = NULL;
// merge config.
std::vector<ISrsReloadHandler *>::iterator it;
// following directly support reload.
// origin, token_traverse, vhost, debug_srs_upnode
// state graph
// old_vhost new_vhost
// DISABLED => ENABLED
// ENABLED => DISABLED
// ENABLED => ENABLED (modified)
// collect all vhost names
std::vector<std::string> vhosts;
for (int i = 0; i < (int)root->directives.size(); i++) {
@ -1501,423 +1496,23 @@ srs_error_t SrsConfig::reload_vhost(SrsConfDirective *old_root)
// process each vhost
for (int i = 0; i < (int)vhosts.size(); i++) {
std::string vhost = vhosts.at(i);
srs_trace("reload vhost %s", vhost.c_str());
SrsConfDirective *old_vhost = old_root->get("vhost", vhost);
SrsConfDirective *new_vhost = root->get("vhost", vhost);
// DISABLED => ENABLED
if (!get_vhost_enabled(old_vhost) && get_vhost_enabled(new_vhost)) {
if ((err = do_reload_vhost_added(vhost)) != srs_success) {
return srs_error_wrap(err, "reload vhost added");
}
continue;
}
// ENABLED => DISABLED
if (get_vhost_enabled(old_vhost) && !get_vhost_enabled(new_vhost)) {
if ((err = do_reload_vhost_removed(vhost)) != srs_success) {
return srs_error_wrap(err, "reload vhost removed");
}
continue;
}
// cluster.mode, never supports reload.
// first, for the origin and edge role change is too complex.
// second, the vhosts in origin device group normally are all origin,
// they never change to edge sometimes.
// third, the origin or upnode device can always be restart,
// edge will retry and the users connected to edge are ok.
// it's ok to add or remove edge/origin vhost.
if (get_vhost_is_edge(old_vhost) != get_vhost_is_edge(new_vhost)) {
return srs_error_new(ERROR_RTMP_EDGE_RELOAD, "vhost mode changed");
}
// the auto reload configs:
// publish.parse_sps
// ENABLED => ENABLED (modified)
if (get_vhost_enabled(new_vhost) && get_vhost_enabled(old_vhost)) {
srs_trace("vhost %s maybe modified, reload its detail.", vhost.c_str());
// chunk_size, only one per vhost.
if (!srs_directive_equals(new_vhost->get("chunk_size"), old_vhost->get("chunk_size"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_chunk_size(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes chunk_size failed", vhost.c_str());
}
}
srs_trace("vhost %s reload chunk_size success.", vhost.c_str());
}
// tcp_nodelay, only one per vhost
if (!srs_directive_equals(new_vhost->get("tcp_nodelay"), old_vhost->get("tcp_nodelay"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_tcp_nodelay(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes tcp_nodelay failed", vhost.c_str());
}
}
srs_trace("vhost %s reload tcp_nodelay success.", vhost.c_str());
}
// min_latency, only one per vhost
if (!srs_directive_equals(new_vhost->get("min_latency"), old_vhost->get("min_latency"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_realtime(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes min_latency failed", vhost.c_str());
}
}
srs_trace("vhost %s reload min_latency success.", vhost.c_str());
}
// play, only one per vhost
if (!srs_directive_equals(new_vhost->get("play"), old_vhost->get("play"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_play(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes play failed", vhost.c_str());
}
}
srs_trace("vhost %s reload play success.", vhost.c_str());
}
// forward, only one per vhost
if (!srs_directive_equals(new_vhost->get("forward"), old_vhost->get("forward"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_forward(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes forward failed", vhost.c_str());
}
}
srs_trace("vhost %s reload forward success.", vhost.c_str());
}
// To reload DASH.
if (!srs_directive_equals(new_vhost->get("dash"), old_vhost->get("dash"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_dash(vhost)) != srs_success) {
return srs_error_wrap(err, "Reload vhost %s dash failed", vhost.c_str());
}
}
srs_trace("Reload vhost %s dash ok.", vhost.c_str());
}
// hls, only one per vhost
// @remark, the hls_on_error directly support reload.
if (!srs_directive_equals(new_vhost->get("hls"), old_vhost->get("hls"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_hls(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes hls failed", vhost.c_str());
}
}
srs_trace("vhost %s reload hls success.", vhost.c_str());
}
// hds reload
if (!srs_directive_equals(new_vhost->get("hds"), old_vhost->get("hds"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_hds(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes hds failed", vhost.c_str());
}
}
srs_trace("vhost %s reload hds success.", vhost.c_str());
}
// dvr, only one per vhost, except the dvr_apply
if (!srs_directive_equals(new_vhost->get("dvr"), old_vhost->get("dvr"), "dvr_apply")) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_dvr(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes dvr failed", vhost.c_str());
}
}
srs_trace("vhost %s reload dvr success.", vhost.c_str());
}
// exec, only one per vhost
if (!srs_directive_equals(new_vhost->get("exec"), old_vhost->get("exec"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_exec(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes exec failed", vhost.c_str());
}
}
srs_trace("vhost %s reload exec success.", vhost.c_str());
}
// publish, only one per vhost
if (!srs_directive_equals(new_vhost->get("publish"), old_vhost->get("publish"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_publish(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes publish failed", vhost.c_str());
}
}
srs_trace("vhost %s reload publish success.", vhost.c_str());
}
// transcode, many per vhost.
if ((err = reload_transcode(new_vhost, old_vhost)) != srs_success) {
return srs_error_wrap(err, "reload transcode");
}
// ingest, many per vhost.
if ((err = reload_ingest(new_vhost, old_vhost)) != srs_success) {
return srs_error_wrap(err, "reload ingest");
}
continue;
}
srs_trace("ignore reload vhost, enabled old: %d, new: %d",
get_vhost_enabled(old_vhost), get_vhost_enabled(new_vhost));
}
return err;
}
srs_error_t SrsConfig::reload_conf(SrsConfig *conf)
{
srs_error_t err = srs_success;
SrsUniquePtr<SrsConfDirective> old_root(root);
root = conf->root;
conf->root = NULL;
// merge config: max_connections
if (!srs_directive_equals(root->get("max_connections"), old_root->get("max_connections"))) {
if ((err = do_reload_max_connections()) != srs_success) {
return srs_error_wrap(err, "max connections");
}
}
// merge config: pithy_print_ms
if (!srs_directive_equals(root->get("pithy_print_ms"), old_root->get("pithy_print_ms"))) {
if ((err = do_reload_pithy_print_ms()) != srs_success) {
return srs_error_wrap(err, "pithy print ms");
}
}
// Merge config: rtc_server
if ((err = reload_rtc_server(old_root.get())) != srs_success) {
return srs_error_wrap(err, "http steram");
;
}
// TODO: FIXME: support reload stream_caster.
// merge config: vhost
if ((err = reload_vhost(old_root.get())) != srs_success) {
return srs_error_wrap(err, "vhost");
;
}
return err;
}
srs_error_t SrsConfig::reload_rtc_server(SrsConfDirective *old_root)
{
srs_error_t err = srs_success;
// merge config.
std::vector<ISrsReloadHandler *>::iterator it;
// state graph
// old_rtc_server new_rtc_server
// ENABLED => ENABLED (modified)
SrsConfDirective *new_rtc_server = root->get("rtc_server");
SrsConfDirective *old_rtc_server = old_root->get("rtc_server");
// TODO: FIXME: Support disable or enable reloading.
// ENABLED => ENABLED (modified)
if (get_rtc_server_enabled(old_rtc_server) && get_rtc_server_enabled(new_rtc_server) && !srs_directive_equals(old_rtc_server, new_rtc_server)) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_rtc_server()) != srs_success) {
return srs_error_wrap(err, "rtc server enabled");
}
}
srs_trace("reload rtc server success.");
return err;
}
srs_trace("reload rtc server success, nothing changed.");
return err;
}
srs_error_t SrsConfig::reload_transcode(SrsConfDirective *new_vhost, SrsConfDirective *old_vhost)
{
srs_error_t err = srs_success;
std::vector<SrsConfDirective *> old_transcoders;
for (int i = 0; i < (int)old_vhost->directives.size(); i++) {
SrsConfDirective *conf = old_vhost->at(i);
if (conf->name == "transcode") {
old_transcoders.push_back(conf);
}
}
std::vector<SrsConfDirective *> new_transcoders;
for (int i = 0; i < (int)new_vhost->directives.size(); i++) {
SrsConfDirective *conf = new_vhost->at(i);
if (conf->name == "transcode") {
new_transcoders.push_back(conf);
}
}
std::vector<ISrsReloadHandler *>::iterator it;
std::string vhost = new_vhost->arg0();
// to be simple:
// whatever, once tiny changed of transcode,
// restart all ffmpeg of vhost.
bool changed = false;
// discovery the removed ffmpeg.
for (int i = 0; !changed && i < (int)old_transcoders.size(); i++) {
SrsConfDirective *old_transcoder = old_transcoders.at(i);
std::string transcoder_id = old_transcoder->arg0();
// if transcoder exists in new vhost, not removed, ignore.
if (new_vhost->get("transcode", transcoder_id)) {
continue;
}
changed = true;
}
// discovery the added ffmpeg.
for (int i = 0; !changed && i < (int)new_transcoders.size(); i++) {
SrsConfDirective *new_transcoder = new_transcoders.at(i);
std::string transcoder_id = new_transcoder->arg0();
// if transcoder exists in old vhost, not added, ignore.
if (old_vhost->get("transcode", transcoder_id)) {
continue;
}
changed = true;
}
// for updated transcoders, restart them.
for (int i = 0; !changed && i < (int)new_transcoders.size(); i++) {
SrsConfDirective *new_transcoder = new_transcoders.at(i);
std::string transcoder_id = new_transcoder->arg0();
SrsConfDirective *old_transcoder = old_vhost->get("transcode", transcoder_id);
srs_assert(old_transcoder);
if (srs_directive_equals(new_transcoder, old_transcoder)) {
continue;
}
changed = true;
}
// transcode, many per vhost
if (changed) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_transcode(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes transcode failed", vhost.c_str());
}
}
srs_trace("vhost %s reload transcode success.", vhost.c_str());
}
return err;
}
srs_error_t SrsConfig::reload_ingest(SrsConfDirective *new_vhost, SrsConfDirective *old_vhost)
{
srs_error_t err = srs_success;
std::vector<SrsConfDirective *> old_ingesters;
for (int i = 0; i < (int)old_vhost->directives.size(); i++) {
SrsConfDirective *conf = old_vhost->at(i);
if (conf->name == "ingest") {
old_ingesters.push_back(conf);
}
}
std::vector<SrsConfDirective *> new_ingesters;
for (int i = 0; i < (int)new_vhost->directives.size(); i++) {
SrsConfDirective *conf = new_vhost->at(i);
if (conf->name == "ingest") {
new_ingesters.push_back(conf);
}
}
std::vector<ISrsReloadHandler *>::iterator it;
std::string vhost = new_vhost->arg0();
// for removed ingesters, stop them.
for (int i = 0; i < (int)old_ingesters.size(); i++) {
SrsConfDirective *old_ingester = old_ingesters.at(i);
std::string ingest_id = old_ingester->arg0();
SrsConfDirective *new_ingester = new_vhost->get("ingest", ingest_id);
// ENABLED => DISABLED
if (get_ingest_enabled(old_ingester) && !get_ingest_enabled(new_ingester)) {
// notice handler ingester removed.
// chunk_size, only one per vhost.
if (!srs_directive_equals(new_vhost->get("chunk_size"), old_vhost->get("chunk_size"))) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_ingest_removed(vhost, ingest_id)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes ingest=%s removed failed", vhost.c_str(), ingest_id.c_str());
if ((err = subscribe->on_reload_vhost_chunk_size(vhost)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes chunk_size failed", vhost.c_str());
}
}
srs_trace("vhost %s reload ingest=%s removed success.", vhost.c_str(), ingest_id.c_str());
srs_trace("vhost %s reload chunk_size success.", vhost.c_str());
}
}
// for added ingesters, start them.
for (int i = 0; i < (int)new_ingesters.size(); i++) {
SrsConfDirective *new_ingester = new_ingesters.at(i);
std::string ingest_id = new_ingester->arg0();
SrsConfDirective *old_ingester = old_vhost->get("ingest", ingest_id);
// DISABLED => ENABLED
if (!get_ingest_enabled(old_ingester) && get_ingest_enabled(new_ingester)) {
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_ingest_added(vhost, ingest_id)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes ingest=%s added failed", vhost.c_str(), ingest_id.c_str());
}
}
srs_trace("vhost %s reload ingest=%s added success.", vhost.c_str(), ingest_id.c_str());
}
}
// for updated ingesters, restart them.
for (int i = 0; i < (int)new_ingesters.size(); i++) {
SrsConfDirective *new_ingester = new_ingesters.at(i);
std::string ingest_id = new_ingester->arg0();
SrsConfDirective *old_ingester = old_vhost->get("ingest", ingest_id);
// ENABLED => ENABLED
if (get_ingest_enabled(old_ingester) && get_ingest_enabled(new_ingester)) {
if (srs_directive_equals(new_ingester, old_ingester)) {
continue;
}
// notice handler ingester removed.
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_ingest_updated(vhost, ingest_id)) != srs_success) {
return srs_error_wrap(err, "vhost %s notify subscribes ingest=%s updated failed", vhost.c_str(), ingest_id.c_str());
}
}
srs_trace("vhost %s reload ingest=%s updated success.", vhost.c_str(), ingest_id.c_str());
}
}
srs_trace("ingest nothing changed for vhost=%s", vhost.c_str());
return err;
}
@ -2121,75 +1716,6 @@ srs_error_t SrsConfig::raw_to_json(SrsJsonObject *obj)
return err;
}
srs_error_t SrsConfig::do_reload_max_connections()
{
srs_error_t err = srs_success;
vector<ISrsReloadHandler *>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_max_conns()) != srs_success) {
return srs_error_wrap(err, "notify subscribes reload max_connections failed");
}
}
srs_trace("reload max_connections success.");
return err;
}
srs_error_t SrsConfig::do_reload_pithy_print_ms()
{
srs_error_t err = srs_success;
vector<ISrsReloadHandler *>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_pithy_print()) != srs_success) {
return srs_error_wrap(err, "notify subscribes pithy_print_ms failed");
}
}
srs_trace("reload pithy_print_ms success.");
return err;
}
srs_error_t SrsConfig::do_reload_vhost_added(string vhost)
{
srs_error_t err = srs_success;
srs_trace("vhost %s added, reload it.", vhost.c_str());
vector<ISrsReloadHandler *>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_added(vhost)) != srs_success) {
return srs_error_wrap(err, "notify subscribes added vhost %s failed", vhost.c_str());
}
}
srs_trace("reload new vhost %s success.", vhost.c_str());
return err;
}
srs_error_t SrsConfig::do_reload_vhost_removed(string vhost)
{
srs_error_t err = srs_success;
srs_trace("vhost %s removed, reload it.", vhost.c_str());
vector<ISrsReloadHandler *>::iterator it;
for (it = subscribes.begin(); it != subscribes.end(); ++it) {
ISrsReloadHandler *subscribe = *it;
if ((err = subscribe->on_reload_vhost_removed(vhost)) != srs_success) {
return srs_error_wrap(err, "notify subscribes removed vhost %s failed", vhost.c_str());
}
}
srs_trace("reload removed vhost %s success.", vhost.c_str());
return err;
}
string SrsConfig::config()
{
return config_file;
@ -7795,7 +7321,7 @@ vector<string> SrsConfig::get_https_api_listens()
return srs_strings_split(srs_getenv("srs.http_api.https.listen"), " ");
}
// If HTTP API uses the same port to HTTP server, then HTTPS API should
// If HTTP API uses the same port to HTTP server, then HTTPS API should
// always default to the same port to HTTPS server.
if (true) {
vector<string> apis = get_http_api_listens();

15
trunk/src/app/srs_app_config.hpp
View File

@ -333,22 +333,12 @@ public:
// @remark, user can test the config before reload it.
virtual srs_error_t reload(SrsReloadState *pstate);
private:
// Reload the vhost section of config.
virtual srs_error_t reload_vhost(SrsConfDirective *old_root);
protected:
// Reload from the config.
// @remark, use protected for the utest to override with mock.
virtual srs_error_t reload_conf(SrsConfig *conf);
private:
// Reload the rtc_server section of config.
virtual srs_error_t reload_rtc_server(SrsConfDirective *old_root);
// Reload the transcode section of vhost of config.
virtual srs_error_t reload_transcode(SrsConfDirective *new_vhost, SrsConfDirective *old_vhost);
// Reload the ingest section of vhost of config.
virtual srs_error_t reload_ingest(SrsConfDirective *new_vhost, SrsConfDirective *old_vhost);
// Parse options and file
public:
// Parse the cli, the main(argc,argv) function.
@ -367,11 +357,6 @@ public:
virtual srs_error_t raw_to_json(SrsJsonObject *obj);
private:
virtual srs_error_t do_reload_max_connections();
virtual srs_error_t do_reload_pithy_print_ms();
virtual srs_error_t do_reload_vhost_added(std::string vhost);
virtual srs_error_t do_reload_vhost_removed(std::string vhost);
public:
// Get the config file path.
virtual std::string config();

52
trunk/src/app/srs_app_recv_thread.cpp
View File

@ -458,58 +458,6 @@ void SrsPublishRecvThread::on_read(ssize_t nread)
}
#endif
srs_error_t SrsPublishRecvThread::on_reload_vhost_publish(string vhost)
{
srs_error_t err = srs_success;
if (req->vhost != vhost) {
return err;
}
// the mr settings,
bool mr_enabled = _srs_config->get_mr_enabled(req->vhost);
srs_utime_t sleep_v = _srs_config->get_mr_sleep(req->vhost);
// update buffer when sleep ms changed.
if (mr_sleep != sleep_v) {
set_socket_buffer(sleep_v);
}
#ifdef SRS_PERF_MERGED_READ
// mr enabled=>disabled
if (mr && !mr_enabled) {
// disable the merge read
rtmp->set_merge_read(false, NULL);
}
// mr disabled=>enabled
if (!mr && mr_enabled) {
// enable the merge read
rtmp->set_merge_read(true, this);
}
#endif
// update to new state
mr = mr_enabled;
mr_sleep = sleep_v;
return err;
}
srs_error_t SrsPublishRecvThread::on_reload_vhost_realtime(string vhost)
{
srs_error_t err = srs_success;
if (req->vhost != vhost) {
return err;
}
bool realtime_enabled = _srs_config->get_realtime_enabled(req->vhost);
srs_trace("realtime changed %d=>%d", realtime, realtime_enabled);
realtime = realtime_enabled;
return err;
}
void SrsPublishRecvThread::set_socket_buffer(srs_utime_t sleep_v)
{
// the bytes:

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

@ -193,10 +193,6 @@ public:
#ifdef SRS_PERF_MERGED_READ
virtual void on_read(ssize_t nread);
#endif
// Interface ISrsReloadHandler
public:
virtual srs_error_t on_reload_vhost_publish(std::string vhost);
virtual srs_error_t on_reload_vhost_realtime(std::string vhost);
private:
virtual void set_socket_buffer(srs_utime_t sleep_v);

105
trunk/src/app/srs_app_reload.cpp
View File

@ -18,112 +18,7 @@ ISrsReloadHandler::~ISrsReloadHandler()
{
}
srs_error_t ISrsReloadHandler::on_reload_max_conns()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_pithy_print()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_http_api_raw_api()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_rtc_server()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_added(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_removed(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_play(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_forward(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_dash(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_hls(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_hds(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_dvr(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_publish(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_tcp_nodelay(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_realtime(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_chunk_size(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_transcode(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_vhost_exec(string /*vhost*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_ingest_removed(string /*vhost*/, string /*ingest_id*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_ingest_added(string /*vhost*/, string /*ingest_id*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_ingest_updated(string /*vhost*/, string /*ingest_id*/)
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_user_info()
{
return srs_success;
}

30
trunk/src/app/srs_app_reload.hpp
View File

@ -11,11 +11,8 @@
#include <string>
// The handler for config reload.
// When reload callback, the config is updated yet.
//
// Features not support reload,
// @see: https://ossrs.io/lts/en-us/docs/v7/doc/reload#notsupportedfeatures
// The main purpose of reload is for quick application during performance optimization.
// So, we only need to keep a basic framework.
class ISrsReloadHandler
{
public:
@ -23,30 +20,7 @@ public:
virtual ~ISrsReloadHandler();
public:
virtual srs_error_t on_reload_max_conns();
virtual srs_error_t on_reload_pithy_print();
virtual srs_error_t on_reload_http_api_raw_api();
virtual srs_error_t on_reload_rtc_server();
public:
virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual srs_error_t on_reload_vhost_play(std::string vhost);
virtual srs_error_t on_reload_vhost_forward(std::string vhost);
virtual srs_error_t on_reload_vhost_dash(std::string vhost);
virtual srs_error_t on_reload_vhost_hls(std::string vhost);
virtual srs_error_t on_reload_vhost_hds(std::string vhost);
virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
virtual srs_error_t on_reload_vhost_publish(std::string vhost);
virtual srs_error_t on_reload_vhost_tcp_nodelay(std::string vhost);
virtual srs_error_t on_reload_vhost_realtime(std::string vhost);
virtual srs_error_t on_reload_vhost_chunk_size(std::string vhost);
virtual srs_error_t on_reload_vhost_transcode(std::string vhost);
virtual srs_error_t on_reload_vhost_exec(std::string vhost);
virtual srs_error_t on_reload_ingest_removed(std::string vhost, std::string ingest_id);
virtual srs_error_t on_reload_ingest_added(std::string vhost, std::string ingest_id);
virtual srs_error_t on_reload_ingest_updated(std::string vhost, std::string ingest_id);
virtual srs_error_t on_reload_user_info();
};
#endif

111
trunk/src/app/srs_app_rtmp_conn.cpp
View File

@ -338,117 +338,6 @@ srs_error_t SrsRtmpConn::do_cycle()
return err;
}
srs_error_t SrsRtmpConn::on_reload_vhost_removed(string vhost)
{
srs_error_t err = srs_success;
ISrsRequest *req = info->req;
if (req->vhost != vhost) {
return err;
}
// if the vhost connected is removed, disconnect the client.
srs_trace("vhost %s removed/disabled, close client url=%s",
vhost.c_str(), req->get_stream_url().c_str());
// should never close the fd in another thread,
// one fd should managed by one thread, we should use interrupt instead.
// so we just ignore the vhost enabled event.
// srs_close_stfd(stfd);
return err;
}
srs_error_t SrsRtmpConn::on_reload_vhost_play(string vhost)
{
srs_error_t err = srs_success;
ISrsRequest *req = info->req;
if (req->vhost != vhost) {
return err;
}
// send_min_interval
if (true) {
srs_utime_t v = _srs_config->get_send_min_interval(vhost);
if (v != send_min_interval) {
srs_trace("apply smi %d=>%d ms", srsu2msi(send_min_interval), srsu2msi(v));
send_min_interval = v;
}
}
mw_msgs = _srs_config->get_mw_msgs(req->vhost, realtime);
mw_sleep = _srs_config->get_mw_sleep(req->vhost);
transport_->set_socket_buffer(mw_sleep);
return err;
}
srs_error_t SrsRtmpConn::on_reload_vhost_tcp_nodelay(string vhost)
{
srs_error_t err = srs_success;
ISrsRequest *req = info->req;
if (req->vhost != vhost) {
return err;
}
set_sock_options();
return err;
}
srs_error_t SrsRtmpConn::on_reload_vhost_realtime(string vhost)
{
srs_error_t err = srs_success;
ISrsRequest *req = info->req;
if (req->vhost != vhost) {
return err;
}
bool realtime_enabled = _srs_config->get_realtime_enabled(req->vhost);
if (realtime_enabled != realtime) {
srs_trace("realtime changed %d=>%d", realtime, realtime_enabled);
realtime = realtime_enabled;
}
mw_msgs = _srs_config->get_mw_msgs(req->vhost, realtime);
mw_sleep = _srs_config->get_mw_sleep(req->vhost);
transport_->set_socket_buffer(mw_sleep);
return err;
}
srs_error_t SrsRtmpConn::on_reload_vhost_publish(string vhost)
{
srs_error_t err = srs_success;
ISrsRequest *req = info->req;
if (req->vhost != vhost) {
return err;
}
srs_utime_t p1stpt = _srs_config->get_publish_1stpkt_timeout(req->vhost);
if (p1stpt != publish_1stpkt_timeout) {
srs_trace("p1stpt changed %d=>%d", srsu2msi(publish_1stpkt_timeout), srsu2msi(p1stpt));
publish_1stpkt_timeout = p1stpt;
}
srs_utime_t pnt = _srs_config->get_publish_normal_timeout(req->vhost);
if (pnt != publish_normal_timeout) {
srs_trace("pnt changed %d=>%d", srsu2msi(publish_normal_timeout), srsu2msi(pnt));
publish_normal_timeout = pnt;
}
return err;
}
ISrsKbpsDelta *SrsRtmpConn::delta()
{
return delta_;

7
trunk/src/app/srs_app_rtmp_conn.hpp
View File

@ -179,13 +179,6 @@ public:
protected:
virtual srs_error_t do_cycle();
// Interface ISrsReloadHandler
public:
virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual srs_error_t on_reload_vhost_play(std::string vhost);
virtual srs_error_t on_reload_vhost_tcp_nodelay(std::string vhost);
virtual srs_error_t on_reload_vhost_realtime(std::string vhost);
virtual srs_error_t on_reload_vhost_publish(std::string vhost);
public:
virtual ISrsKbpsDelta *delta();

200
trunk/src/app/srs_app_source.cpp
View File

@ -1257,206 +1257,6 @@ srs_error_t SrsOriginHub::on_hls_request_sh()
return err;
}
srs_error_t SrsOriginHub::on_reload_vhost_forward(string vhost)
{
srs_error_t err = srs_success;
if (req_->vhost != vhost) {
return err;
}
// TODO: FIXME: Must do async reload, see SrsHls::async_reload.
// forwarders
destroy_forwarders();
// Don't start forwarders when source is not active.
if (!is_active) {
return err;
}
if ((err = create_forwarders()) != srs_success) {
return srs_error_wrap(err, "create forwarders");
}
srs_trace("vhost %s forwarders reload success", vhost.c_str());
return err;
}
srs_error_t SrsOriginHub::on_reload_vhost_dash(string vhost)
{
srs_error_t err = srs_success;
if (req_->vhost != vhost) {
return err;
}
// TODO: FIXME: Must do async reload, see SrsHls::async_reload.
dash->on_unpublish();
// Don't start DASH when source is not active.
if (!is_active) {
return err;
}
if ((err = dash->on_publish()) != srs_success) {
return srs_error_wrap(err, "dash start publish");
}
SrsRtmpFormat *format = source_->format_;
SrsSharedPtrMessage *cache_sh_video = source_->meta->vsh();
if (cache_sh_video) {
if ((err = format->on_video(cache_sh_video)) != srs_success) {
return srs_error_wrap(err, "format on_video");
}
if ((err = dash->on_video(cache_sh_video, format)) != srs_success) {
return srs_error_wrap(err, "dash on_video");
}
}
SrsSharedPtrMessage *cache_sh_audio = source_->meta->ash();
if (cache_sh_audio) {
if ((err = format->on_audio(cache_sh_audio)) != srs_success) {
return srs_error_wrap(err, "format on_audio");
}
if ((err = dash->on_audio(cache_sh_audio, format)) != srs_success) {
return srs_error_wrap(err, "dash on_audio");
}
}
return err;
}
srs_error_t SrsOriginHub::on_reload_vhost_hls(string vhost)
{
srs_error_t err = srs_success;
if (req_->vhost != vhost) {
return err;
}
hls->async_reload();
return err;
}
srs_error_t SrsOriginHub::on_reload_vhost_hds(string vhost)
{
srs_error_t err = srs_success;
if (req_->vhost != vhost) {
return err;
}
// TODO: FIXME: Must do async reload, see SrsHls::async_reload.
#ifdef SRS_HDS
hds->on_unpublish();
// Don't start HDS when source is not active.
if (!is_active) {
return err;
}
if ((err = hds->on_publish(req_)) != srs_success) {
return srs_error_wrap(err, "hds publish failed");
}
srs_trace("vhost %s hds reload success", vhost.c_str());
#endif
return err;
}
srs_error_t SrsOriginHub::on_reload_vhost_dvr(string vhost)
{
srs_error_t err = srs_success;
if (req_->vhost != vhost) {
return err;
}
// TODO: FIXME: Must do async reload, see SrsHls::async_reload.
// cleanup dvr
dvr->on_unpublish();
// Don't start DVR when source is not active.
if (!is_active) {
return err;
}
// reinitialize the dvr, update plan.
if ((err = dvr->initialize(this, req_)) != srs_success) {
return srs_error_wrap(err, "reload dvr");
}
// start to publish by new plan.
if ((err = dvr->on_publish(req_)) != srs_success) {
return srs_error_wrap(err, "dvr publish failed");
}
if ((err = on_dvr_request_sh()) != srs_success) {
return srs_error_wrap(err, "request sh");
}
srs_trace("vhost %s dvr reload success", vhost.c_str());
return err;
}
srs_error_t SrsOriginHub::on_reload_vhost_transcode(string vhost)
{
srs_error_t err = srs_success;
if (req_->vhost != vhost) {
return err;
}
// TODO: FIXME: Must do async reload, see SrsHls::async_reload.
encoder->on_unpublish();
// Don't start transcode when source is not active.
if (!is_active) {
return err;
}
if ((err = encoder->on_publish(req_)) != srs_success) {
return srs_error_wrap(err, "start encoder failed");
}
srs_trace("vhost %s transcode reload success", vhost.c_str());
return err;
}
srs_error_t SrsOriginHub::on_reload_vhost_exec(string vhost)
{
srs_error_t err = srs_success;
if (req_->vhost != vhost) {
return err;
}
// TODO: FIXME: Must do async reload, see SrsHls::async_reload.
ng_exec->on_unpublish();
// Don't start exec when source is not active.
if (!is_active) {
return err;
}
if ((err = ng_exec->on_publish(req_)) != srs_success) {
return srs_error_wrap(err, "start exec failed");
}
srs_trace("vhost %s exec reload success", vhost.c_str());
return err;
}
srs_error_t SrsOriginHub::create_forwarders()
{
srs_error_t err = srs_success;

9
trunk/src/app/srs_app_source.hpp
View File

@ -400,15 +400,6 @@ public:
virtual srs_error_t on_dvr_request_sh();
// For the SrsHls to callback to request the sequence headers.
virtual srs_error_t on_hls_request_sh();
// Interface ISrsReloadHandler
public:
virtual srs_error_t on_reload_vhost_forward(std::string vhost);
virtual srs_error_t on_reload_vhost_dash(std::string vhost);
virtual srs_error_t on_reload_vhost_hls(std::string vhost);
virtual srs_error_t on_reload_vhost_hds(std::string vhost);
virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
virtual srs_error_t on_reload_vhost_transcode(std::string vhost);
virtual srs_error_t on_reload_vhost_exec(std::string vhost);
private:
virtual srs_error_t create_forwarders();

508
trunk/src/utest/srs_utest_reload.cpp
View File

@ -21,49 +21,19 @@ MockReloadHandler::~MockReloadHandler()
void MockReloadHandler::reset()
{
pithy_print_reloaded = false;
vhost_added_reloaded = false;
vhost_removed_reloaded = false;
vhost_play_reloaded = false;
vhost_forward_reloaded = false;
vhost_hls_reloaded = false;
vhost_dvr_reloaded = false;
vhost_transcode_reloaded = false;
ingest_removed_reloaded = false;
ingest_added_reloaded = false;
ingest_updated_reloaded = false;
vhost_chunk_size_reloaded = false;
}
int MockReloadHandler::count_total()
{
return 56 - 31;
return 1;
}
int MockReloadHandler::count_true()
{
int count_true = 0;
if (pithy_print_reloaded)
count_true++;
if (vhost_added_reloaded)
count_true++;
if (vhost_removed_reloaded)
count_true++;
if (vhost_play_reloaded)
count_true++;
if (vhost_forward_reloaded)
count_true++;
if (vhost_hls_reloaded)
count_true++;
if (vhost_dvr_reloaded)
count_true++;
if (vhost_transcode_reloaded)
count_true++;
if (ingest_removed_reloaded)
count_true++;
if (ingest_added_reloaded)
count_true++;
if (ingest_updated_reloaded)
if (vhost_chunk_size_reloaded)
count_true++;
return count_true;
@ -73,27 +43,7 @@ int MockReloadHandler::count_false()
{
int count_false = 0;
if (!pithy_print_reloaded)
count_false++;
if (!vhost_added_reloaded)
count_false++;
if (!vhost_removed_reloaded)
count_false++;
if (!vhost_play_reloaded)
count_false++;
if (!vhost_forward_reloaded)
count_false++;
if (!vhost_hls_reloaded)
count_false++;
if (!vhost_dvr_reloaded)
count_false++;
if (!vhost_transcode_reloaded)
count_false++;
if (!ingest_removed_reloaded)
count_false++;
if (!ingest_added_reloaded)
count_false++;
if (!ingest_updated_reloaded)
if (!vhost_chunk_size_reloaded)
count_false++;
return count_false;
@ -109,75 +59,9 @@ bool MockReloadHandler::all_true()
return count_true() == count_total();
}
srs_error_t MockReloadHandler::on_reload_pithy_print()
srs_error_t MockReloadHandler::on_reload_vhost_chunk_size(string /*vhost*/)
{
pithy_print_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_added(string /*vhost*/)
{
vhost_added_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_removed(string /*vhost*/)
{
vhost_removed_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_play(string /*vhost*/)
{
vhost_play_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_forward(string /*vhost*/)
{
vhost_forward_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_hls(string /*vhost*/)
{
vhost_hls_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_hds(string /*vhost*/)
{
vhost_hls_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_dvr(string /*vhost*/)
{
vhost_dvr_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_vhost_transcode(string /*vhost*/)
{
vhost_transcode_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_ingest_removed(string /*vhost*/, string /*ingest_id*/)
{
ingest_removed_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_ingest_added(string /*vhost*/, string /*ingest_id*/)
{
ingest_added_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_ingest_updated(string /*vhost*/, string /*ingest_id*/)
{
ingest_updated_reloaded = true;
vhost_chunk_size_reloaded = true;
return srs_success;
}
@ -218,7 +102,7 @@ VOID TEST(ConfigReloadTest, ReloadEmpty)
EXPECT_TRUE(handler.all_false());
}
VOID TEST(ConfigReloadTest, ReloadPithyPrint)
VOID TEST(ConfigReloadTest, ReloadVhostChunkSize)
{
srs_error_t err = srs_success;
@ -226,385 +110,17 @@ VOID TEST(ConfigReloadTest, ReloadPithyPrint)
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "pithy_print_ms 1000;"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "pithy_print_ms 1000;"));
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost ossrs.net { chunk_size 60000; }"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost ossrs.net { chunk_size 60000; }"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "pithy_print_ms 2000;"));
EXPECT_TRUE(handler.pithy_print_reloaded);
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost ossrs.net { chunk_size 65536; }"));
EXPECT_TRUE(handler.vhost_chunk_size_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "pithy_print_ms 1000;"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostAdded)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{} vhost b{}"));
EXPECT_TRUE(handler.vhost_added_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostRemoved)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{enabled off;}"));
EXPECT_TRUE(handler.vhost_removed_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostRemoved2)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{} vhost b{}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{} vhost b{}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_TRUE(handler.vhost_removed_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{} vhost b{}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostAtc)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{atc off;}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{atc off;}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{atc on;}"));
EXPECT_TRUE(handler.vhost_play_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{atc off;}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostGopCache)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{gop_cache off;}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{gop_cache off;}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{gop_cache on;}"));
EXPECT_TRUE(handler.vhost_play_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{gop_cache off;}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostQueueLength)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{queue_length 10;}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{queue_length 10;}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{queue_length 20;}"));
EXPECT_TRUE(handler.vhost_play_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{queue_length 10;}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostTimeJitter)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{time_jitter full;}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{time_jitter full;}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{time_jitter zero;}"));
EXPECT_TRUE(handler.vhost_play_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{time_jitter full;}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostForward)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{forward 127.0.0.1:1936;}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{forward 127.0.0.1:1936;}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{forward 127.0.0.1:1937;}"));
EXPECT_TRUE(handler.vhost_forward_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{forward 127.0.0.1:1936;}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostHls)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{hls {enabled on;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{hls {enabled on;}}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{hls {enabled off;}}"));
EXPECT_TRUE(handler.vhost_hls_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{hls {enabled on;}}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostDvr)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{dvr {enabled on;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{dvr {enabled on;}}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{dvr {enabled off;}}"));
EXPECT_TRUE(handler.vhost_dvr_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{dvr {enabled on;}}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostTranscode)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{transcode {enabled on;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{transcode {enabled on;}}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{transcode {enabled off;}}"));
EXPECT_TRUE(handler.vhost_transcode_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{transcode {enabled on;}}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostIngestAdded)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;}}"));
EXPECT_TRUE(handler.ingest_added_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostIngestAdded2)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{ingest a {enabled on;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest a {enabled on;}}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest a {enabled on;} ingest b {enabled on;}}"));
EXPECT_TRUE(handler.ingest_added_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest a {enabled on;}}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostIngestRemoved)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{ingest {enabled on;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;}}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{}"));
EXPECT_TRUE(handler.ingest_removed_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;}}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostIngestRemoved2)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{ingest {enabled on;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;}}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled off;}}"));
EXPECT_TRUE(handler.ingest_removed_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;}}"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadVhostIngestUpdated)
{
srs_error_t err = srs_success;
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
HELPER_EXPECT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
EXPECT_TRUE(handler.all_false());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;ffmpeg ffmpeg1;}}"));
EXPECT_TRUE(handler.ingest_updated_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost a{ingest {enabled on;ffmpeg ffmpeg;}}"));
HELPER_EXPECT_SUCCESS(conf.do_reload(_MIN_OK_CONF "vhost ossrs.net { chunk_size 60000; }"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}

25
trunk/src/utest/srs_utest_reload.hpp
View File

@ -18,17 +18,7 @@
class MockReloadHandler : public ISrsReloadHandler
{
public:
bool pithy_print_reloaded;
bool vhost_added_reloaded;
bool vhost_removed_reloaded;
bool vhost_play_reloaded;
bool vhost_forward_reloaded;
bool vhost_hls_reloaded;
bool vhost_dvr_reloaded;
bool vhost_transcode_reloaded;
bool ingest_removed_reloaded;
bool ingest_added_reloaded;
bool ingest_updated_reloaded;
bool vhost_chunk_size_reloaded;
public:
MockReloadHandler();
@ -43,18 +33,7 @@ public:
virtual int count_false();
public:
virtual srs_error_t on_reload_pithy_print();
virtual srs_error_t on_reload_vhost_added(std::string vhost);
virtual srs_error_t on_reload_vhost_removed(std::string vhost);
virtual srs_error_t on_reload_vhost_play(std::string vhost);
virtual srs_error_t on_reload_vhost_forward(std::string vhost);
virtual srs_error_t on_reload_vhost_hls(std::string vhost);
virtual srs_error_t on_reload_vhost_hds(std::string vhost);
virtual srs_error_t on_reload_vhost_dvr(std::string vhost);
virtual srs_error_t on_reload_vhost_transcode(std::string vhost);
virtual srs_error_t on_reload_ingest_removed(std::string vhost, std::string ingest_id);
virtual srs_error_t on_reload_ingest_added(std::string vhost, std::string ingest_id);
virtual srs_error_t on_reload_ingest_updated(std::string vhost, std::string ingest_id);
virtual srs_error_t on_reload_vhost_chunk_size(std::string vhost);
};
class MockSrsReloadConfig : public MockSrsConfig