From aeca022165941a958e310c25ba78cc1ebdabc99d Mon Sep 17 00:00:00 2001 From: Shengming Yuan <11619780+ssysm@users.noreply.github.com> Date: Mon, 28 Jul 2025 08:37:38 -0400 Subject: [PATCH] Allow Forward to be configured with Env Var. v6.0.170 (#4245) Allow Env Var to control forwarding function. By AI: * [AI: Add utests for PR.](https://github.com/ossrs/srs/pull/4245/commits/1b978d19a55b4ef466633c6626b1c1b8a69a0c50) --------- Co-authored-by: Haibo Chen <495810242@qq.com> Co-authored-by: chundonglinlin Co-authored-by: winlin --- trunk/doc/CHANGELOG.md | 1 + trunk/src/app/srs_app_config.cpp | 10 +- trunk/src/core/srs_core_version6.hpp | 2 +- trunk/src/utest/srs_utest_config.cpp | 576 +++++++++++++++------------ trunk/src/utest/srs_utest_config.hpp | 10 +- 5 files changed, 339 insertions(+), 260 deletions(-) diff --git a/trunk/doc/CHANGELOG.md b/trunk/doc/CHANGELOG.md index 6e8bd209d..d8436494c 100644 --- a/trunk/doc/CHANGELOG.md +++ b/trunk/doc/CHANGELOG.md @@ -7,6 +7,7 @@ The changelog for SRS. ## SRS 6.0 Changelog +* v6.0, 2025-07-28, Merge [#4245](https://github.com/ossrs/srs/pull/4245): Allow Forward to be configured with Env Var. v6.0.170 (#4245) * v6.0, 2025-07-10, Merge [#4414](https://github.com/ossrs/srs/pull/4414): Fix H.264 B-frame detection logic to comply with specification. v6.0.169 (#4414) * v6.0, 2025-06-04, Merge [#4325](https://github.com/ossrs/srs/pull/4325): fix bug: loop transcoding #3516. v6.0.168 (#4325) * v6.0, 2025-05-29, Merge [#4356](https://github.com/ossrs/srs/pull/4356): RTMP: Use extended timestamp as delta when chunk fmt=1/2. v6.0.167 (#4356) diff --git a/trunk/src/app/srs_app_config.cpp b/trunk/src/app/srs_app_config.cpp index d74f4b410..3cafa5604 100644 --- a/trunk/src/app/srs_app_config.cpp +++ b/trunk/src/app/srs_app_config.cpp @@ -5566,7 +5566,10 @@ int SrsConfig::get_global_chunk_size() return ::atoi(conf->arg0().c_str()); } -bool SrsConfig::get_forward_enabled(string vhost) { +bool SrsConfig::get_forward_enabled(string vhost) +{ + SRS_OVERWRITE_BY_ENV_BOOL("srs.vhost.forward.enabled"); // SRS_VHOST_FORWARD_ENABLED + static bool DEFAULT = false; SrsConfDirective* conf = get_vhost(vhost); @@ -5579,6 +5582,8 @@ bool SrsConfig::get_forward_enabled(string vhost) { bool SrsConfig::get_forward_enabled(SrsConfDirective* vhost) { + SRS_OVERWRITE_BY_ENV_BOOL("srs.vhost.forward.enabled"); // SRS_VHOST_FORWARD_ENABLED + static bool DEFAULT = false; SrsConfDirective* conf = vhost->get("forward"); @@ -5611,6 +5616,9 @@ SrsConfDirective* SrsConfig::get_forwards(string vhost) SrsConfDirective* SrsConfig::get_forward_backend(string vhost) { + + SRS_OVERWRITE_BY_ENV_DIRECTIVE("srs.vhost.forward.backend"); // SRS_VHOST_FORWARD_BACKEND + SrsConfDirective* conf = get_vhost(vhost); if (!conf) { return NULL; diff --git a/trunk/src/core/srs_core_version6.hpp b/trunk/src/core/srs_core_version6.hpp index d7db085e5..2de2cc4e7 100644 --- a/trunk/src/core/srs_core_version6.hpp +++ b/trunk/src/core/srs_core_version6.hpp @@ -9,6 +9,6 @@ #define VERSION_MAJOR 6 #define VERSION_MINOR 0 -#define VERSION_REVISION 169 +#define VERSION_REVISION 170 #endif diff --git a/trunk/src/utest/srs_utest_config.cpp b/trunk/src/utest/srs_utest_config.cpp index 4a907dd56..4b4010de2 100644 --- a/trunk/src/utest/srs_utest_config.cpp +++ b/trunk/src/utest/srs_utest_config.cpp @@ -4067,118 +4067,118 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesGlobal) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(pid, "SRS_PID", "xxx"); + SrsSetEnvConfig(conf, pid, "SRS_PID", "xxx"); EXPECT_STREQ("xxx", conf.get_pid_file().c_str()); - SrsSetEnvConfig(log_tank, "SRS_SRS_LOG_TANK", "console"); + SrsSetEnvConfig(conf, log_tank, "SRS_SRS_LOG_TANK", "console"); EXPECT_FALSE(conf.get_log_tank_file()); - SrsSetEnvConfig(log_file, "SRS_SRS_LOG_FILE", "xxx2"); + SrsSetEnvConfig(conf, log_file, "SRS_SRS_LOG_FILE", "xxx2"); EXPECT_STREQ("xxx2", conf.get_log_file().c_str()); - SrsSetEnvConfig(log_level, "SRS_SRS_LOG_LEVEL", "xxx3"); + SrsSetEnvConfig(conf, log_level, "SRS_SRS_LOG_LEVEL", "xxx3"); EXPECT_STREQ("xxx3", conf.get_log_level().c_str()); - SrsSetEnvConfig(log_level_v2, "SRS_SRS_LOG_LEVEL_V2", "xxx4"); + SrsSetEnvConfig(conf, log_level_v2, "SRS_SRS_LOG_LEVEL_V2", "xxx4"); EXPECT_STREQ("xxx4", conf.get_log_level_v2().c_str()); - SrsSetEnvConfig(work_dir, "SRS_WORK_DIR", "xxx5"); + SrsSetEnvConfig(conf, work_dir, "SRS_WORK_DIR", "xxx5"); EXPECT_STREQ("xxx5", conf.get_work_dir().c_str()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(pid, "SRS_PID", "xxx"); + SrsSetEnvConfig(conf, pid, "SRS_PID", "xxx"); EXPECT_STREQ("xxx", conf.get_pid_file().c_str()); - SrsSetEnvConfig(log_tank, "SRS_LOG_TANK", "console"); + SrsSetEnvConfig(conf, log_tank, "SRS_LOG_TANK", "console"); EXPECT_FALSE(conf.get_log_tank_file()); - SrsSetEnvConfig(log_file, "SRS_LOG_FILE", "xxx2"); + SrsSetEnvConfig(conf, log_file, "SRS_LOG_FILE", "xxx2"); EXPECT_STREQ("xxx2", conf.get_log_file().c_str()); - SrsSetEnvConfig(log_level, "SRS_LOG_LEVEL", "xxx3"); + SrsSetEnvConfig(conf, log_level, "SRS_LOG_LEVEL", "xxx3"); EXPECT_STREQ("xxx3", conf.get_log_level().c_str()); - SrsSetEnvConfig(log_level_v2, "SRS_LOG_LEVEL_V2", "xxx4"); + SrsSetEnvConfig(conf, log_level_v2, "SRS_LOG_LEVEL_V2", "xxx4"); EXPECT_STREQ("xxx4", conf.get_log_level_v2().c_str()); - SrsSetEnvConfig(work_dir, "SRS_WORK_DIR", "xxx5"); + SrsSetEnvConfig(conf, work_dir, "SRS_WORK_DIR", "xxx5"); EXPECT_STREQ("xxx5", conf.get_work_dir().c_str()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(ff_log_dir, "SRS_FF_LOG_DIR", "yyy"); + SrsSetEnvConfig(conf, ff_log_dir, "SRS_FF_LOG_DIR", "yyy"); EXPECT_STREQ("yyy", conf.get_ff_log_dir().c_str()); - SrsSetEnvConfig(ff_log_level, "SRS_FF_LOG_LEVEL", "yyy2"); + SrsSetEnvConfig(conf, ff_log_level, "SRS_FF_LOG_LEVEL", "yyy2"); EXPECT_STREQ("yyy2", conf.get_ff_log_level().c_str()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(max_connections, "SRS_MAX_CONNECTIONS", "1024"); + SrsSetEnvConfig(conf, max_connections, "SRS_MAX_CONNECTIONS", "1024"); EXPECT_EQ(1024, conf.get_max_connections()); - SrsSetEnvConfig(utc_time, "SRS_UTC_TIME", "on"); + SrsSetEnvConfig(conf, utc_time, "SRS_UTC_TIME", "on"); EXPECT_TRUE(conf.get_utc_time()); - SrsSetEnvConfig(pithy_print, "SRS_PITHY_PRINT_MS", "20000"); + SrsSetEnvConfig(conf, pithy_print, "SRS_PITHY_PRINT_MS", "20000"); EXPECT_EQ(20 * SRS_UTIME_SECONDS, conf.get_pithy_print()); - SrsSetEnvConfig(asprocess, "SRS_ASPROCESS", "on"); + SrsSetEnvConfig(conf, asprocess, "SRS_ASPROCESS", "on"); EXPECT_TRUE(conf.get_asprocess()); - SrsSetEnvConfig(empty_ip_ok, "SRS_EMPTY_IP_OK", "off"); + SrsSetEnvConfig(conf, empty_ip_ok, "SRS_EMPTY_IP_OK", "off"); EXPECT_FALSE(conf.empty_ip_ok()); - SrsSetEnvConfig(in_docker, "SRS_IN_DOCKER", "on"); + SrsSetEnvConfig(conf, in_docker, "SRS_IN_DOCKER", "on"); EXPECT_TRUE(conf.get_in_docker()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(grace_start_wait, "SRS_GRACE_START_WAIT", "2000"); + SrsSetEnvConfig(conf, grace_start_wait, "SRS_GRACE_START_WAIT", "2000"); EXPECT_EQ(2000 * SRS_UTIME_MILLISECONDS, conf.get_grace_start_wait()); - SrsSetEnvConfig(grace_final_wait, "SRS_GRACE_FINAL_WAIT", "3000"); + SrsSetEnvConfig(conf, grace_final_wait, "SRS_GRACE_FINAL_WAIT", "3000"); EXPECT_EQ(3000 * SRS_UTIME_MILLISECONDS, conf.get_grace_final_wait()); - SrsSetEnvConfig(is_force_grace_quit, "SRS_FORCE_GRACE_QUIT", "on"); + SrsSetEnvConfig(conf, is_force_grace_quit, "SRS_FORCE_GRACE_QUIT", "on"); EXPECT_TRUE(conf.is_force_grace_quit()); - SrsSetEnvConfig(disable_daemon_for_docker, "SRS_DISABLE_DAEMON_FOR_DOCKER", "off"); + SrsSetEnvConfig(conf, disable_daemon_for_docker, "SRS_DISABLE_DAEMON_FOR_DOCKER", "off"); EXPECT_FALSE(conf.disable_daemon_for_docker()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(inotify_auto_reload, "SRS_INOTIFY_AUTO_RELOAD", "on"); + SrsSetEnvConfig(conf, inotify_auto_reload, "SRS_INOTIFY_AUTO_RELOAD", "on"); EXPECT_TRUE(conf.inotify_auto_reload()); - SrsSetEnvConfig(auto_reload_for_docker, "SRS_AUTO_RELOAD_FOR_DOCKER", "off"); + SrsSetEnvConfig(conf, auto_reload_for_docker, "SRS_AUTO_RELOAD_FOR_DOCKER", "off"); EXPECT_FALSE(conf.auto_reload_for_docker()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(tcmalloc_release_rate, "SRS_TCMALLOC_RELEASE_RATE", "20"); + SrsSetEnvConfig(conf, tcmalloc_release_rate, "SRS_TCMALLOC_RELEASE_RATE", "20"); EXPECT_EQ(10, conf.tcmalloc_release_rate()); - SrsSetEnvConfig(tcmalloc_release_rate_low, "SRS_TCMALLOC_RELEASE_RATE", "5.2"); + SrsSetEnvConfig(conf, tcmalloc_release_rate_low, "SRS_TCMALLOC_RELEASE_RATE", "5.2"); EXPECT_EQ(5.2, conf.tcmalloc_release_rate()); - SrsSetEnvConfig(whether_query_latest_version, "SRS_QUERY_LATEST_VERSION", "off"); + SrsSetEnvConfig(conf, whether_query_latest_version, "SRS_QUERY_LATEST_VERSION", "off"); EXPECT_FALSE(conf.whether_query_latest_version()); - SrsSetEnvConfig(first_wait_for_qlv, "SRS_FIRST_WAIT_FOR_QLV", "200"); + SrsSetEnvConfig(conf, first_wait_for_qlv, "SRS_FIRST_WAIT_FOR_QLV", "200"); EXPECT_EQ(200 * SRS_UTIME_SECONDS, conf.first_wait_for_qlv()); } } @@ -4188,7 +4188,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesthreads) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(threads_interval, "SRS_THREADS_INTERVAL", "10"); + SrsSetEnvConfig(conf, threads_interval, "SRS_THREADS_INTERVAL", "10"); EXPECT_EQ(10 * SRS_UTIME_SECONDS, conf.get_threads_interval()); } } @@ -4198,7 +4198,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesRtmp) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(listens, "SRS_LISTEN", "1935"); + SrsSetEnvConfig(conf, listens, "SRS_LISTEN", "1935"); vector listens = conf.get_listens(); EXPECT_EQ(1, (int)listens.size()); EXPECT_STREQ("1935", listens.at(0).c_str()); @@ -4207,7 +4207,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesRtmp) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(listens, "SRS_LISTEN", "1935 1936"); + SrsSetEnvConfig(conf, listens, "SRS_LISTEN", "1935 1936"); vector listens = conf.get_listens(); EXPECT_EQ(2, (int)listens.size()); EXPECT_STREQ("1935", listens.at(0).c_str()); @@ -4217,7 +4217,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesRtmp) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(listens, "SRS_LISTEN", "1935 1936 1937"); + SrsSetEnvConfig(conf, listens, "SRS_LISTEN", "1935 1936 1937"); vector listens = conf.get_listens(); EXPECT_EQ(3, (int)listens.size()); EXPECT_STREQ("1935", listens.at(0).c_str()); @@ -4231,48 +4231,48 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHttpApi) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(http_api_enabled, "SRS_HTTP_API_ENABLED", "on"); + SrsSetEnvConfig(conf, http_api_enabled, "SRS_HTTP_API_ENABLED", "on"); EXPECT_TRUE(conf.get_http_api_enabled()); - SrsSetEnvConfig(http_api_listen, "SRS_HTTP_API_LISTEN", "xxx"); + SrsSetEnvConfig(conf, http_api_listen, "SRS_HTTP_API_LISTEN", "xxx"); EXPECT_STREQ("xxx", conf.get_http_api_listen().c_str()); - SrsSetEnvConfig(http_api_crossdomain, "SRS_HTTP_API_CROSSDOMAIN", "off"); + SrsSetEnvConfig(conf, http_api_crossdomain, "SRS_HTTP_API_CROSSDOMAIN", "off"); EXPECT_FALSE(conf.get_http_api_crossdomain()); - SrsSetEnvConfig(http_api_auth_enabled, "SRS_HTTP_API_AUTH_ENABLED", "on"); + SrsSetEnvConfig(conf, http_api_auth_enabled, "SRS_HTTP_API_AUTH_ENABLED", "on"); EXPECT_TRUE(conf.get_http_api_auth_enabled()); - SrsSetEnvConfig(http_api_auth_username, "SRS_HTTP_API_AUTH_USERNAME", "admin"); + SrsSetEnvConfig(conf, http_api_auth_username, "SRS_HTTP_API_AUTH_USERNAME", "admin"); EXPECT_STREQ("admin", conf.get_http_api_auth_username().c_str()); - SrsSetEnvConfig(http_api_auth_password, "SRS_HTTP_API_AUTH_PASSWORD", "123456"); + SrsSetEnvConfig(conf, http_api_auth_password, "SRS_HTTP_API_AUTH_PASSWORD", "123456"); EXPECT_STREQ("123456", conf.get_http_api_auth_password().c_str()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(raw_api, "SRS_HTTP_API_RAW_API_ENABLED", "on"); + SrsSetEnvConfig(conf, raw_api, "SRS_HTTP_API_RAW_API_ENABLED", "on"); EXPECT_TRUE(conf.get_raw_api()); - SrsSetEnvConfig(raw_api_allow_reload, "SRS_HTTP_API_RAW_API_ALLOW_RELOAD", "on"); + SrsSetEnvConfig(conf, raw_api_allow_reload, "SRS_HTTP_API_RAW_API_ALLOW_RELOAD", "on"); EXPECT_TRUE(conf.get_raw_api_allow_reload()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(https_api_enabled, "SRS_HTTP_API_HTTPS_ENABLED", "on"); + SrsSetEnvConfig(conf, https_api_enabled, "SRS_HTTP_API_HTTPS_ENABLED", "on"); EXPECT_TRUE(conf.get_https_api_enabled()); - SrsSetEnvConfig(https_api_listen, "SRS_HTTP_API_HTTPS_LISTEN", "xxx"); + SrsSetEnvConfig(conf, https_api_listen, "SRS_HTTP_API_HTTPS_LISTEN", "xxx"); EXPECT_STREQ("xxx", conf.get_https_api_listen().c_str()); - SrsSetEnvConfig(https_api_ssl_key, "SRS_HTTP_API_HTTPS_KEY", "xxx2"); + SrsSetEnvConfig(conf, https_api_ssl_key, "SRS_HTTP_API_HTTPS_KEY", "xxx2"); EXPECT_STREQ("xxx2", conf.get_https_api_ssl_key().c_str()); - SrsSetEnvConfig(https_api_ssl_cert, "SRS_HTTP_API_HTTPS_CERT", "xxx3"); + SrsSetEnvConfig(conf, https_api_ssl_cert, "SRS_HTTP_API_HTTPS_CERT", "xxx3"); EXPECT_STREQ("xxx3", conf.get_https_api_ssl_cert().c_str()); } } @@ -4282,32 +4282,32 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHttpServer) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(http_stream_enabled, "SRS_HTTP_SERVER_ENABLED", "on"); + SrsSetEnvConfig(conf, http_stream_enabled, "SRS_HTTP_SERVER_ENABLED", "on"); EXPECT_TRUE(conf.get_http_stream_enabled()); - SrsSetEnvConfig(http_stream_listen, "SRS_HTTP_SERVER_LISTEN", "xxx"); + SrsSetEnvConfig(conf, http_stream_listen, "SRS_HTTP_SERVER_LISTEN", "xxx"); EXPECT_STREQ("xxx", conf.get_http_stream_listen().c_str()); - SrsSetEnvConfig(http_stream_dir, "SRS_HTTP_SERVER_DIR", "xxx2"); + SrsSetEnvConfig(conf, http_stream_dir, "SRS_HTTP_SERVER_DIR", "xxx2"); EXPECT_STREQ("xxx2", conf.get_http_stream_dir().c_str()); - SrsSetEnvConfig(http_stream_crossdomain, "SRS_HTTP_SERVER_CROSSDOMAIN", "off"); + SrsSetEnvConfig(conf, http_stream_crossdomain, "SRS_HTTP_SERVER_CROSSDOMAIN", "off"); EXPECT_FALSE(conf.get_http_stream_crossdomain()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(https_stream_enabled, "SRS_HTTP_SERVER_HTTPS_ENABLED", "on"); + SrsSetEnvConfig(conf, https_stream_enabled, "SRS_HTTP_SERVER_HTTPS_ENABLED", "on"); EXPECT_TRUE(conf.get_https_stream_enabled()); - SrsSetEnvConfig(https_stream_listen, "SRS_HTTP_SERVER_HTTPS_LISTEN", "xxx"); + SrsSetEnvConfig(conf, https_stream_listen, "SRS_HTTP_SERVER_HTTPS_LISTEN", "xxx"); EXPECT_STREQ("xxx", conf.get_https_stream_listen().c_str()); - SrsSetEnvConfig(https_stream_ssl_key, "SRS_HTTP_SERVER_HTTPS_KEY", "xxx2"); + SrsSetEnvConfig(conf, https_stream_ssl_key, "SRS_HTTP_SERVER_HTTPS_KEY", "xxx2"); EXPECT_STREQ("xxx2", conf.get_https_stream_ssl_key().c_str()); - SrsSetEnvConfig(https_stream_ssl_cert, "SRS_HTTP_SERVER_HTTPS_CERT", "xxx3"); + SrsSetEnvConfig(conf, https_stream_ssl_cert, "SRS_HTTP_SERVER_HTTPS_CERT", "xxx3"); EXPECT_STREQ("xxx3", conf.get_https_stream_ssl_cert().c_str()); } } @@ -4317,52 +4317,52 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesSrtServer) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(srt_enabled, "SRS_SRT_SERVER_ENABLED", "on"); + SrsSetEnvConfig(conf, srt_enabled, "SRS_SRT_SERVER_ENABLED", "on"); EXPECT_TRUE(conf.get_srt_enabled()); - SrsSetEnvConfig(srt_listen_port, "SRS_SRT_SERVER_LISTEN", "10000"); + SrsSetEnvConfig(conf, srt_listen_port, "SRS_SRT_SERVER_LISTEN", "10000"); EXPECT_EQ(10000, conf.get_srt_listen_port()); - SrsSetEnvConfig(srto_maxbw, "SRS_SRT_SERVER_MAXBW", "1000000000"); + SrsSetEnvConfig(conf, srto_maxbw, "SRS_SRT_SERVER_MAXBW", "1000000000"); EXPECT_EQ(1000000000, conf.get_srto_maxbw()); - SrsSetEnvConfig(srto_mss, "SRS_SRT_SERVER_MSS", "1000"); + SrsSetEnvConfig(conf, srto_mss, "SRS_SRT_SERVER_MSS", "1000"); EXPECT_EQ(1000, conf.get_srto_mss()); - SrsSetEnvConfig(srto_conntimeout, "SRS_SRT_SERVER_CONNECT_TIMEOUT", "2000"); + SrsSetEnvConfig(conf, srto_conntimeout, "SRS_SRT_SERVER_CONNECT_TIMEOUT", "2000"); EXPECT_EQ(2000 * SRS_UTIME_MILLISECONDS, conf.get_srto_conntimeout()); - SrsSetEnvConfig(srto_peeridletimeout, "SRS_SRT_SERVER_PEER_IDLE_TIMEOUT", "2000"); + SrsSetEnvConfig(conf, srto_peeridletimeout, "SRS_SRT_SERVER_PEER_IDLE_TIMEOUT", "2000"); EXPECT_EQ(2000 * SRS_UTIME_MILLISECONDS, conf.get_srto_peeridletimeout()); - SrsSetEnvConfig(default_app_name, "SRS_SRT_SERVER_DEFAULT_APP", "xxx"); + SrsSetEnvConfig(conf, default_app_name, "SRS_SRT_SERVER_DEFAULT_APP", "xxx"); EXPECT_STREQ("xxx", conf.get_default_app_name().c_str()); - SrsSetEnvConfig(srto_peer_latency, "SRS_SRT_SERVER_PEERLATENCY", "1"); + SrsSetEnvConfig(conf, srto_peer_latency, "SRS_SRT_SERVER_PEERLATENCY", "1"); EXPECT_EQ(1, conf.get_srto_peer_latency()); - SrsSetEnvConfig(srto_recv_latency, "SRS_SRT_SERVER_RECVLATENCY", "100"); + SrsSetEnvConfig(conf, srto_recv_latency, "SRS_SRT_SERVER_RECVLATENCY", "100"); EXPECT_EQ(100, conf.get_srto_recv_latency()); - SrsSetEnvConfig(srto_latency, "SRS_SRT_SERVER_LATENCY", "100"); + SrsSetEnvConfig(conf, srto_latency, "SRS_SRT_SERVER_LATENCY", "100"); EXPECT_EQ(100, conf.get_srto_latency()); - SrsSetEnvConfig(srto_tsbpdmode, "SRS_SRT_SERVER_TSBPDMODE", "off"); + SrsSetEnvConfig(conf, srto_tsbpdmode, "SRS_SRT_SERVER_TSBPDMODE", "off"); EXPECT_FALSE(conf.get_srto_tsbpdmode()); - SrsSetEnvConfig(srto_tlpktdrop, "SRS_SRT_SERVER_TLPKTDROP", "off"); + SrsSetEnvConfig(conf, srto_tlpktdrop, "SRS_SRT_SERVER_TLPKTDROP", "off"); EXPECT_FALSE(conf.get_srto_tlpktdrop()); - SrsSetEnvConfig(srto_sendbuf, "SRS_SRT_SERVER_SENDBUF", "2100000"); + SrsSetEnvConfig(conf, srto_sendbuf, "SRS_SRT_SERVER_SENDBUF", "2100000"); EXPECT_EQ(2100000, conf.get_srto_sendbuf()); - SrsSetEnvConfig(srto_recvbuf, "SRS_SRT_SERVER_RECVBUF", "2100000"); + SrsSetEnvConfig(conf, srto_recvbuf, "SRS_SRT_SERVER_RECVBUF", "2100000"); EXPECT_EQ(2100000, conf.get_srto_recvbuf()); - SrsSetEnvConfig(srto_passphrase, "SRS_SRT_SERVER_PASSPHRASE", "xxx2"); + SrsSetEnvConfig(conf, srto_passphrase, "SRS_SRT_SERVER_PASSPHRASE", "xxx2"); EXPECT_STREQ("xxx2", conf.get_srto_passphrase().c_str()); - SrsSetEnvConfig(srto_pbkeylen, "SRS_SRT_SERVER_PBKEYLEN", "16"); + SrsSetEnvConfig(conf, srto_pbkeylen, "SRS_SRT_SERVER_PBKEYLEN", "16"); EXPECT_EQ(16, conf.get_srto_pbkeylen()); } } @@ -4372,13 +4372,13 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesVhostSrt) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(srt_enabled, "SRS_VHOST_SRT_ENABLED", "on"); + SrsSetEnvConfig(conf, srt_enabled, "SRS_VHOST_SRT_ENABLED", "on"); EXPECT_TRUE(conf.get_srt_enabled("__defaultVhost__")); - SrsSetEnvConfig(srt_to_rtmp, "SRS_VHOST_SRT_SRT_TO_RTMP", "off"); + SrsSetEnvConfig(conf, srt_to_rtmp, "SRS_VHOST_SRT_SRT_TO_RTMP", "off"); EXPECT_FALSE(conf.get_srt_to_rtmp("__defaultVhost__")); - SrsSetEnvConfig(srt_to_rtmp2, "SRS_VHOST_SRT_TO_RTMP", "off"); + SrsSetEnvConfig(conf, srt_to_rtmp2, "SRS_VHOST_SRT_TO_RTMP", "off"); EXPECT_FALSE(conf.get_srt_to_rtmp("__defaultVhost__")); } } @@ -4388,80 +4388,80 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesRtcServer) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(rtc_server_enabled, "SRS_RTC_SERVER_ENABLED", "on"); + SrsSetEnvConfig(conf, rtc_server_enabled, "SRS_RTC_SERVER_ENABLED", "on"); EXPECT_TRUE(conf.get_rtc_server_enabled()); - SrsSetEnvConfig(rtc_server_listen, "SRS_RTC_SERVER_LISTEN", "8080"); + SrsSetEnvConfig(conf, rtc_server_listen, "SRS_RTC_SERVER_LISTEN", "8080"); EXPECT_EQ(8080, conf.get_rtc_server_listen()); - SrsSetEnvConfig(rtc_server_protocol, "SRS_RTC_SERVER_PROTOCOL", "xxx"); + SrsSetEnvConfig(conf, rtc_server_protocol, "SRS_RTC_SERVER_PROTOCOL", "xxx"); EXPECT_STREQ("xxx", conf.get_rtc_server_protocol().c_str()); - SrsSetEnvConfig(rtc_server_candidates, "SRS_RTC_SERVER_CANDIDATE", "192.168.0.1"); + SrsSetEnvConfig(conf, rtc_server_candidates, "SRS_RTC_SERVER_CANDIDATE", "192.168.0.1"); EXPECT_STREQ("192.168.0.1", conf.get_rtc_server_candidates().c_str()); - SrsSetEnvConfig(use_auto_detect_network_ip, "SRS_RTC_SERVER_USE_AUTO_DETECT_NETWORK_IP", "off"); + SrsSetEnvConfig(conf, use_auto_detect_network_ip, "SRS_RTC_SERVER_USE_AUTO_DETECT_NETWORK_IP", "off"); EXPECT_FALSE(conf.get_use_auto_detect_network_ip()); - SrsSetEnvConfig(rtc_server_ip_family, "SRS_RTC_SERVER_IP_FAMILY", "xxx2"); + SrsSetEnvConfig(conf, rtc_server_ip_family, "SRS_RTC_SERVER_IP_FAMILY", "xxx2"); EXPECT_STREQ("xxx2", conf.get_rtc_server_ip_family().c_str()); - SrsSetEnvConfig(api_as_candidates, "SRS_RTC_SERVER_API_AS_CANDIDATES", "off"); + SrsSetEnvConfig(conf, api_as_candidates, "SRS_RTC_SERVER_API_AS_CANDIDATES", "off"); EXPECT_FALSE(conf.get_api_as_candidates()); - SrsSetEnvConfig(resolve_api_domain, "SRS_RTC_SERVER_RESOLVE_API_DOMAIN", "off"); + SrsSetEnvConfig(conf, resolve_api_domain, "SRS_RTC_SERVER_RESOLVE_API_DOMAIN", "off"); EXPECT_FALSE(conf.get_resolve_api_domain()); - SrsSetEnvConfig(keep_api_domain, "SRS_RTC_SERVER_KEEP_API_DOMAIN", "on"); + SrsSetEnvConfig(conf, keep_api_domain, "SRS_RTC_SERVER_KEEP_API_DOMAIN", "on"); EXPECT_TRUE(conf.get_keep_api_domain()); - SrsSetEnvConfig(rtc_server_ecdsa, "SRS_RTC_SERVER_ECDSA", "off"); + SrsSetEnvConfig(conf, rtc_server_ecdsa, "SRS_RTC_SERVER_ECDSA", "off"); EXPECT_FALSE(conf.get_rtc_server_ecdsa()); - SrsSetEnvConfig(rtc_server_encrypt, "SRS_RTC_SERVER_ENCRYPT", "off"); + SrsSetEnvConfig(conf, rtc_server_encrypt, "SRS_RTC_SERVER_ENCRYPT", "off"); EXPECT_FALSE(conf.get_rtc_server_encrypt()); - SrsSetEnvConfig(rtc_server_reuseport, "SRS_RTC_SERVER_REUSEPORT", "0"); + SrsSetEnvConfig(conf, rtc_server_reuseport, "SRS_RTC_SERVER_REUSEPORT", "0"); EXPECT_EQ(0, conf.get_rtc_server_reuseport2()); - SrsSetEnvConfig(rtc_server_merge_nalus, "SRS_RTC_SERVER_MERGE_NALUS", "on"); + SrsSetEnvConfig(conf, rtc_server_merge_nalus, "SRS_RTC_SERVER_MERGE_NALUS", "on"); EXPECT_TRUE(conf.get_rtc_server_merge_nalus()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(rtc_server_tcp_enabled, "SRS_RTC_SERVER_TCP_ENABLED", "on"); + SrsSetEnvConfig(conf, rtc_server_tcp_enabled, "SRS_RTC_SERVER_TCP_ENABLED", "on"); EXPECT_TRUE(conf.get_rtc_server_tcp_enabled()); - SrsSetEnvConfig(get_rtc_server_tcp_listen, "SRS_RTC_SERVER_TCP_LISTEN", "8080"); + SrsSetEnvConfig(conf, get_rtc_server_tcp_listen, "SRS_RTC_SERVER_TCP_LISTEN", "8080"); EXPECT_EQ(8080, conf.get_rtc_server_tcp_listen()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(rtc_server_black_hole, "SRS_RTC_SERVER_BLACK_HOLE_ENABLED", "on"); + SrsSetEnvConfig(conf, rtc_server_black_hole, "SRS_RTC_SERVER_BLACK_HOLE_ENABLED", "on"); EXPECT_TRUE(conf.get_rtc_server_black_hole()); - SrsSetEnvConfig(rtc_server_black_hole_addr, "SRS_RTC_SERVER_BLACK_HOLE_ADDR", "xxx"); + SrsSetEnvConfig(conf, rtc_server_black_hole_addr, "SRS_RTC_SERVER_BLACK_HOLE_ADDR", "xxx"); EXPECT_STREQ("xxx", conf.get_rtc_server_black_hole_addr().c_str()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(rtc_server_candidates, "SRS_RTC_SERVER_CANDIDATE", "192.168.0.1"); + SrsSetEnvConfig(conf, rtc_server_candidates, "SRS_RTC_SERVER_CANDIDATE", "192.168.0.1"); EXPECT_STREQ("192.168.0.1", conf.get_rtc_server_candidates().c_str()); - SrsSetEnvConfig(rtc_server_candidates2, "SRS_RTC_SERVER_CANDIDATE", "MY_CANDIDATE"); + SrsSetEnvConfig(conf, rtc_server_candidates2, "SRS_RTC_SERVER_CANDIDATE", "MY_CANDIDATE"); EXPECT_STREQ("MY_CANDIDATE", conf.get_rtc_server_candidates().c_str()); - SrsSetEnvConfig(rtc_server_candidates3, "SRS_RTC_SERVER_CANDIDATE", "$MY_CANDIDATE"); + SrsSetEnvConfig(conf, rtc_server_candidates3, "SRS_RTC_SERVER_CANDIDATE", "$MY_CANDIDATE"); EXPECT_STREQ("*", conf.get_rtc_server_candidates().c_str()); - SrsSetEnvConfig(candidates, "MY_CANDIDATE", "192.168.0.11"); - SrsSetEnvConfig(rtc_server_candidates4, "SRS_RTC_SERVER_CANDIDATE", "$MY_CANDIDATE"); + SrsSetEnvConfig(conf, candidates, "MY_CANDIDATE", "192.168.0.11"); + SrsSetEnvConfig(conf, rtc_server_candidates4, "SRS_RTC_SERVER_CANDIDATE", "$MY_CANDIDATE"); EXPECT_STREQ("192.168.0.11", conf.get_rtc_server_candidates().c_str()); } } @@ -4471,62 +4471,62 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesVhostRtc) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(rtc_enabled, "SRS_VHOST_RTC_ENABLED", "on"); + SrsSetEnvConfig(conf, rtc_enabled, "SRS_VHOST_RTC_ENABLED", "on"); EXPECT_TRUE(conf.get_rtc_enabled("__defaultVhost__")); - SrsSetEnvConfig(rtc_nack_enabled, "SRS_VHOST_RTC_NACK", "off"); + SrsSetEnvConfig(conf, rtc_nack_enabled, "SRS_VHOST_RTC_NACK", "off"); EXPECT_FALSE(conf.get_rtc_nack_enabled("__defaultVhost__")); - SrsSetEnvConfig(rtc_nack_no_copy, "SRS_VHOST_RTC_NACK_NO_COPY", "off"); + SrsSetEnvConfig(conf, rtc_nack_no_copy, "SRS_VHOST_RTC_NACK_NO_COPY", "off"); EXPECT_FALSE(conf.get_rtc_nack_no_copy("__defaultVhost__")); - SrsSetEnvConfig(rtc_twcc_enabled, "SRS_VHOST_RTC_TWCC", "off"); + SrsSetEnvConfig(conf, rtc_twcc_enabled, "SRS_VHOST_RTC_TWCC", "off"); EXPECT_FALSE(conf.get_rtc_twcc_enabled("__defaultVhost__")); - SrsSetEnvConfig(rtc_stun_timeout, "SRS_VHOST_RTC_STUN_TIMEOUT", "15"); + SrsSetEnvConfig(conf, rtc_stun_timeout, "SRS_VHOST_RTC_STUN_TIMEOUT", "15"); EXPECT_EQ(15 * SRS_UTIME_SECONDS, conf.get_rtc_stun_timeout("__defaultVhost__")); - SrsSetEnvConfig(rtc_stun_strict_check, "SRS_VHOST_RTC_STUN_STRICT_CHECK", "on"); + SrsSetEnvConfig(conf, rtc_stun_strict_check, "SRS_VHOST_RTC_STUN_STRICT_CHECK", "on"); EXPECT_TRUE(conf.get_rtc_stun_strict_check("__defaultVhost__")); - SrsSetEnvConfig(rtc_dtls_role, "SRS_VHOST_RTC_DTLS_ROLE", "xxx"); + SrsSetEnvConfig(conf, rtc_dtls_role, "SRS_VHOST_RTC_DTLS_ROLE", "xxx"); EXPECT_STREQ("xxx", conf.get_rtc_dtls_role("__defaultVhost__").c_str()); - SrsSetEnvConfig(rtc_dtls_version, "SRS_VHOST_RTC_DTLS_VERSION", "xxx2"); + SrsSetEnvConfig(conf, rtc_dtls_version, "SRS_VHOST_RTC_DTLS_VERSION", "xxx2"); EXPECT_STREQ("xxx2", conf.get_rtc_dtls_version("__defaultVhost__").c_str()); - SrsSetEnvConfig(rtc_drop_for_pt, "SRS_VHOST_RTC_DROP_FOR_PT", "1"); + SrsSetEnvConfig(conf, rtc_drop_for_pt, "SRS_VHOST_RTC_DROP_FOR_PT", "1"); EXPECT_EQ(1, conf.get_rtc_drop_for_pt("__defaultVhost__")); - SrsSetEnvConfig(rtc_from_rtmp, "SRS_VHOST_RTC_RTMP_TO_RTC", "on"); + SrsSetEnvConfig(conf, rtc_from_rtmp, "SRS_VHOST_RTC_RTMP_TO_RTC", "on"); EXPECT_TRUE(conf.get_rtc_from_rtmp("__defaultVhost__")); - SrsSetEnvConfig(rtc_to_rtmp, "SRS_VHOST_RTC_RTC_TO_RTMP", "on"); + SrsSetEnvConfig(conf, rtc_to_rtmp, "SRS_VHOST_RTC_RTC_TO_RTMP", "on"); EXPECT_TRUE(conf.get_rtc_to_rtmp("__defaultVhost__")); - SrsSetEnvConfig(rtc_keep_bframe, "SRS_VHOST_RTC_KEEP_BFRAME", "on"); + SrsSetEnvConfig(conf, rtc_keep_bframe, "SRS_VHOST_RTC_KEEP_BFRAME", "on"); EXPECT_TRUE(conf.get_rtc_keep_bframe("__defaultVhost__")); { // make sure the default value is false, if defined incorrect env value. - SrsSetEnvConfig(rtc_keep_bframe, "SRS_VHOST_RTC_KEEP_BFRAME", "onn"); + SrsSetEnvConfig(conf, rtc_keep_bframe, "SRS_VHOST_RTC_KEEP_BFRAME", "onn"); EXPECT_FALSE(conf.get_rtc_keep_bframe("__defaultVhost__")); } { - SrsSetEnvConfig(rtc_keep_avc_nalu_sei, "SRS_VHOST_RTC_KEEP_AVC_NALU_SEI", "off"); + SrsSetEnvConfig(conf, rtc_keep_avc_nalu_sei, "SRS_VHOST_RTC_KEEP_AVC_NALU_SEI", "off"); EXPECT_FALSE(conf.get_rtc_keep_avc_nalu_sei("__defaultVhost__")); } { - SrsSetEnvConfig(rtc_keep_avc_nalu_sei, "SRS_VHOST_RTC_KEEP_AVC_NALU_SEI", "on"); + SrsSetEnvConfig(conf, rtc_keep_avc_nalu_sei, "SRS_VHOST_RTC_KEEP_AVC_NALU_SEI", "on"); EXPECT_TRUE(conf.get_rtc_keep_avc_nalu_sei("__defaultVhost__")); } { // make sure the default value is true, if defined incorrect env value. - SrsSetEnvConfig(rtc_keep_avc_nalu_sei, "SRS_VHOST_RTC_KEEP_AVC_NALU_SEI", "xx"); + SrsSetEnvConfig(conf, rtc_keep_avc_nalu_sei, "SRS_VHOST_RTC_KEEP_AVC_NALU_SEI", "xx"); EXPECT_TRUE(conf.get_rtc_keep_avc_nalu_sei("__defaultVhost__")); } } @@ -4534,14 +4534,14 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesVhostRtc) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(rtc_pli_for_rtmp, "SRS_VHOST_RTC_PLI_FOR_RTMP", "15"); + SrsSetEnvConfig(conf, rtc_pli_for_rtmp, "SRS_VHOST_RTC_PLI_FOR_RTMP", "15"); EXPECT_EQ(15 * SRS_UTIME_SECONDS, conf.get_rtc_pli_for_rtmp("__defaultVhost__")); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(rtc_pli_for_rtmp, "SRS_VHOST_RTC_PLI_FOR_RTMP", "60"); + SrsSetEnvConfig(conf, rtc_pli_for_rtmp, "SRS_VHOST_RTC_PLI_FOR_RTMP", "60"); EXPECT_EQ(6 * SRS_UTIME_SECONDS, conf.get_rtc_pli_for_rtmp("__defaultVhost__")); } } @@ -4551,66 +4551,66 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesVhostPlay) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(mw_msgs, "SRS_VHOST_PLAY_MW_MSGS", "64"); + SrsSetEnvConfig(conf, mw_msgs, "SRS_VHOST_PLAY_MW_MSGS", "64"); EXPECT_EQ(64, conf.get_mw_msgs("__defaultVhost__", true, true)); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(mw_msgs, "SRS_VHOST_PLAY_MW_MSGS", "256"); + SrsSetEnvConfig(conf, mw_msgs, "SRS_VHOST_PLAY_MW_MSGS", "256"); EXPECT_EQ(128, conf.get_mw_msgs("__defaultVhost__", true, true)); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(mw_sleep, "SRS_VHOST_PLAY_MW_LATENCY", "300"); + SrsSetEnvConfig(conf, mw_sleep, "SRS_VHOST_PLAY_MW_LATENCY", "300"); EXPECT_EQ(0, conf.get_mw_sleep("__defaultVhost__", true)); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(mw_sleep, "SRS_VHOST_PLAY_MW_LATENCY", "300"); + SrsSetEnvConfig(conf, mw_sleep, "SRS_VHOST_PLAY_MW_LATENCY", "300"); EXPECT_EQ(300 * SRS_UTIME_MILLISECONDS, conf.get_mw_sleep("__defaultVhost__", false)); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(time_jitter, "SRS_VHOST_PLAY_TIME_JITTER", "full"); + SrsSetEnvConfig(conf, time_jitter, "SRS_VHOST_PLAY_TIME_JITTER", "full"); EXPECT_EQ(0x1, conf.get_time_jitter("__defaultVhost__")); - SrsSetEnvConfig(time_jitter_zero, "SRS_VHOST_PLAY_TIME_JITTER", "zero"); + SrsSetEnvConfig(conf, time_jitter_zero, "SRS_VHOST_PLAY_TIME_JITTER", "zero"); EXPECT_EQ(0x2, conf.get_time_jitter("__defaultVhost__")); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(gop_cache, "SRS_VHOST_PLAY_GOP_CACHE", "off"); + SrsSetEnvConfig(conf, gop_cache, "SRS_VHOST_PLAY_GOP_CACHE", "off"); EXPECT_FALSE(conf.get_gop_cache("__defaultVhost__")); - SrsSetEnvConfig(gop_cache_max_frames, "SRS_VHOST_PLAY_GOP_CACHE_MAX_FRAMES", "2000"); + SrsSetEnvConfig(conf, gop_cache_max_frames, "SRS_VHOST_PLAY_GOP_CACHE_MAX_FRAMES", "2000"); EXPECT_EQ(2000, conf.get_gop_cache_max_frames("__defaultVhost__")); - SrsSetEnvConfig(queue_length, "SRS_VHOST_PLAY_QUEUE_LENGTH", "20"); + SrsSetEnvConfig(conf, queue_length, "SRS_VHOST_PLAY_QUEUE_LENGTH", "20"); EXPECT_EQ(20 * SRS_UTIME_SECONDS, conf.get_queue_length("__defaultVhost__")); - SrsSetEnvConfig(atc, "SRS_VHOST_PLAY_ATC", "on"); + SrsSetEnvConfig(conf, atc, "SRS_VHOST_PLAY_ATC", "on"); EXPECT_TRUE(conf.get_atc("__defaultVhost__")); - SrsSetEnvConfig(mix_correct, "SRS_VHOST_PLAY_MIX_CORRECT", "on"); + SrsSetEnvConfig(conf, mix_correct, "SRS_VHOST_PLAY_MIX_CORRECT", "on"); EXPECT_TRUE(conf.get_mix_correct("__defaultVhost__")); - SrsSetEnvConfig(atc_auto, "SRS_VHOST_PLAY_ATC_AUTO", "on"); + SrsSetEnvConfig(conf, atc_auto, "SRS_VHOST_PLAY_ATC_AUTO", "on"); EXPECT_TRUE(conf.get_atc_auto("__defaultVhost__")); - SrsSetEnvConfig(send_min_interval, "SRS_VHOST_PLAY_SEND_MIN_INTERVAL", "10"); + SrsSetEnvConfig(conf, send_min_interval, "SRS_VHOST_PLAY_SEND_MIN_INTERVAL", "10"); EXPECT_EQ(10 * SRS_UTIME_MILLISECONDS, conf.get_send_min_interval("__defaultVhost__")); - SrsSetEnvConfig(reduce_sequence_header, "SRS_VHOST_PLAY_REDUCE_SEQUENCE_HEADER", "on"); + SrsSetEnvConfig(conf, reduce_sequence_header, "SRS_VHOST_PLAY_REDUCE_SEQUENCE_HEADER", "on"); EXPECT_TRUE(conf.get_reduce_sequence_header("__defaultVhost__")); } } @@ -4620,25 +4620,25 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesVhostPublish) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(mr_enabled, "SRS_VHOST_PUBLISH_MR", "on"); + SrsSetEnvConfig(conf, mr_enabled, "SRS_VHOST_PUBLISH_MR", "on"); EXPECT_TRUE(conf.get_mr_enabled("__defaultVhost__")); - SrsSetEnvConfig(mr_sleep, "SRS_VHOST_PUBLISH_MR_LATENCY", "10"); + SrsSetEnvConfig(conf, mr_sleep, "SRS_VHOST_PUBLISH_MR_LATENCY", "10"); EXPECT_EQ(10 * SRS_UTIME_MILLISECONDS, conf.get_mr_sleep("__defaultVhost__")); - SrsSetEnvConfig(publish_normal_timeout, "SRS_VHOST_PUBLISH_NORMAL_TIMEOUT", "10"); + SrsSetEnvConfig(conf, publish_normal_timeout, "SRS_VHOST_PUBLISH_NORMAL_TIMEOUT", "10"); EXPECT_EQ(10 * SRS_UTIME_MILLISECONDS, conf.get_publish_normal_timeout("__defaultVhost__")); - SrsSetEnvConfig(publish_1stpkt_timeout, "SRS_VHOST_PUBLISH_FIRSTPKT_TIMEOUT", "30"); + SrsSetEnvConfig(conf, publish_1stpkt_timeout, "SRS_VHOST_PUBLISH_FIRSTPKT_TIMEOUT", "30"); EXPECT_EQ(30 * SRS_UTIME_MILLISECONDS, conf.get_publish_1stpkt_timeout("__defaultVhost__")); - SrsSetEnvConfig(parse_sps, "SRS_VHOST_PUBLISH_PARSE_SPS", "off"); + SrsSetEnvConfig(conf, parse_sps, "SRS_VHOST_PUBLISH_PARSE_SPS", "off"); EXPECT_FALSE(conf.get_parse_sps("__defaultVhost__")); - SrsSetEnvConfig(try_annexb_first, "SRS_VHOST_PUBLISH_TRY_ANNEXB_FIRST", "off"); + SrsSetEnvConfig(conf, try_annexb_first, "SRS_VHOST_PUBLISH_TRY_ANNEXB_FIRST", "off"); EXPECT_FALSE(conf.try_annexb_first("__defaultVhost__")); - SrsSetEnvConfig(kickoff_for_idle, "SRS_VHOST_PUBLISH_KICKOFF_FOR_IDLE", "30"); + SrsSetEnvConfig(conf, kickoff_for_idle, "SRS_VHOST_PUBLISH_KICKOFF_FOR_IDLE", "30"); EXPECT_EQ(30 * SRS_UTIME_SECONDS, conf.get_publish_kickoff_for_idle("__defaultVhost__")); } } @@ -4648,25 +4648,25 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesCircuitBreaker) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(circuit_breaker, "SRS_CIRCUIT_BREAKER_ENABLED", "off"); + SrsSetEnvConfig(conf, circuit_breaker, "SRS_CIRCUIT_BREAKER_ENABLED", "off"); EXPECT_FALSE(conf.get_circuit_breaker()); - SrsSetEnvConfig(high_threshold, "SRS_CIRCUIT_BREAKER_HIGH_THRESHOLD", "60"); + SrsSetEnvConfig(conf, high_threshold, "SRS_CIRCUIT_BREAKER_HIGH_THRESHOLD", "60"); EXPECT_EQ(60, conf.get_high_threshold()); - SrsSetEnvConfig(high_pulse, "SRS_CIRCUIT_BREAKER_HIGH_PULSE", "3"); + SrsSetEnvConfig(conf, high_pulse, "SRS_CIRCUIT_BREAKER_HIGH_PULSE", "3"); EXPECT_EQ(3, conf.get_high_pulse()); - SrsSetEnvConfig(critical_threshold, "SRS_CIRCUIT_BREAKER_CRITICAL_THRESHOLD", "100"); + SrsSetEnvConfig(conf, critical_threshold, "SRS_CIRCUIT_BREAKER_CRITICAL_THRESHOLD", "100"); EXPECT_EQ(100, conf.get_critical_threshold()); - SrsSetEnvConfig(critical_pulse, "SRS_CIRCUIT_BREAKER_CRITICAL_PULSE", "2"); + SrsSetEnvConfig(conf, critical_pulse, "SRS_CIRCUIT_BREAKER_CRITICAL_PULSE", "2"); EXPECT_EQ(2, conf.get_critical_pulse()); - SrsSetEnvConfig(dying_threshold, "SRS_CIRCUIT_BREAKER_DYING_THRESHOLD", "88"); + SrsSetEnvConfig(conf, dying_threshold, "SRS_CIRCUIT_BREAKER_DYING_THRESHOLD", "88"); EXPECT_EQ(88, conf.get_dying_threshold()); - SrsSetEnvConfig(dying_pulse, "SRS_CIRCUIT_BREAKER_DYING_PULSE", "2"); + SrsSetEnvConfig(conf, dying_pulse, "SRS_CIRCUIT_BREAKER_DYING_PULSE", "2"); EXPECT_EQ(2, conf.get_dying_pulse()); } } @@ -4676,44 +4676,44 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesTencentcloudCls) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(tencentcloud_cls_enabled, "SRS_TENCENTCLOUD_CLS_ENABLED", "on"); + SrsSetEnvConfig(conf, tencentcloud_cls_enabled, "SRS_TENCENTCLOUD_CLS_ENABLED", "on"); EXPECT_TRUE(conf.get_tencentcloud_cls_enabled()); - SrsSetEnvConfig(tencentcloud_cls_label, "SRS_TENCENTCLOUD_CLS_LABEL", "xxx"); + SrsSetEnvConfig(conf, tencentcloud_cls_label, "SRS_TENCENTCLOUD_CLS_LABEL", "xxx"); EXPECT_STREQ("xxx", conf.get_tencentcloud_cls_label().c_str()); - SrsSetEnvConfig(tencentcloud_cls_tag, "SRS_TENCENTCLOUD_CLS_TAG", "xxx2"); + SrsSetEnvConfig(conf, tencentcloud_cls_tag, "SRS_TENCENTCLOUD_CLS_TAG", "xxx2"); EXPECT_STREQ("xxx2", conf.get_tencentcloud_cls_tag().c_str()); - SrsSetEnvConfig(tencentcloud_cls_secret_id, "SRS_TENCENTCLOUD_CLS_SECRET_ID", "xxx3"); + SrsSetEnvConfig(conf, tencentcloud_cls_secret_id, "SRS_TENCENTCLOUD_CLS_SECRET_ID", "xxx3"); EXPECT_STREQ("xxx3", conf.get_tencentcloud_cls_secret_id().c_str()); - SrsSetEnvConfig(tencentcloud_cls_secret_key, "SRS_TENCENTCLOUD_CLS_SECRET_KEY", "xxx4"); + SrsSetEnvConfig(conf, tencentcloud_cls_secret_key, "SRS_TENCENTCLOUD_CLS_SECRET_KEY", "xxx4"); EXPECT_STREQ("xxx4", conf.get_tencentcloud_cls_secret_key().c_str()); - SrsSetEnvConfig(tencentcloud_cls_endpoint, "SRS_TENCENTCLOUD_CLS_ENDPOINT", "yyy"); + SrsSetEnvConfig(conf, tencentcloud_cls_endpoint, "SRS_TENCENTCLOUD_CLS_ENDPOINT", "yyy"); EXPECT_STREQ("yyy", conf.get_tencentcloud_cls_endpoint().c_str()); - SrsSetEnvConfig(tencentcloud_cls_topic_id, "SRS_TENCENTCLOUD_CLS_TOPIC_ID", "yyy2"); + SrsSetEnvConfig(conf, tencentcloud_cls_topic_id, "SRS_TENCENTCLOUD_CLS_TOPIC_ID", "yyy2"); EXPECT_STREQ("yyy2", conf.get_tencentcloud_cls_topic_id().c_str()); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(tencentcloud_cls_debug_logging, "SRS_TENCENTCLOUD_CLS_DEBUG_LOGGING", "on"); + SrsSetEnvConfig(conf, tencentcloud_cls_debug_logging, "SRS_TENCENTCLOUD_CLS_DEBUG_LOGGING", "on"); EXPECT_TRUE(conf.get_tencentcloud_cls_debug_logging()); - SrsSetEnvConfig(tencentcloud_cls_stat_heartbeat, "SRS_TENCENTCLOUD_CLS_STAT_HEARTBEAT", "off"); + SrsSetEnvConfig(conf, tencentcloud_cls_stat_heartbeat, "SRS_TENCENTCLOUD_CLS_STAT_HEARTBEAT", "off"); EXPECT_FALSE(conf.get_tencentcloud_cls_stat_heartbeat()); - SrsSetEnvConfig(tencentcloud_cls_heartbeat_ratio, "SRS_TENCENTCLOUD_CLS_HEARTBEAT_RATIO", "2"); + SrsSetEnvConfig(conf, tencentcloud_cls_heartbeat_ratio, "SRS_TENCENTCLOUD_CLS_HEARTBEAT_RATIO", "2"); EXPECT_EQ(2, conf.get_tencentcloud_cls_heartbeat_ratio()); - SrsSetEnvConfig(tencentcloud_cls_stat_streams, "SRS_TENCENTCLOUD_CLS_STAT_STREAMS", "off"); + SrsSetEnvConfig(conf, tencentcloud_cls_stat_streams, "SRS_TENCENTCLOUD_CLS_STAT_STREAMS", "off"); EXPECT_FALSE(conf.get_tencentcloud_cls_stat_streams()); - SrsSetEnvConfig(tencentcloud_cls_streams_ratio, "SRS_TENCENTCLOUD_CLS_STREAMS_RATIO", "2"); + SrsSetEnvConfig(conf, tencentcloud_cls_streams_ratio, "SRS_TENCENTCLOUD_CLS_STREAMS_RATIO", "2"); EXPECT_EQ(2, conf.get_tencentcloud_cls_streams_ratio()); } } @@ -4723,22 +4723,22 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesTencentcloudApm) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(tencentcloud_apm_enabled, "SRS_TENCENTCLOUD_APM_ENABLED", "on"); + SrsSetEnvConfig(conf, tencentcloud_apm_enabled, "SRS_TENCENTCLOUD_APM_ENABLED", "on"); EXPECT_TRUE(conf.get_tencentcloud_apm_enabled()); - SrsSetEnvConfig(tencentcloud_apm_team, "SRS_TENCENTCLOUD_APM_TEAM", "xxx"); + SrsSetEnvConfig(conf, tencentcloud_apm_team, "SRS_TENCENTCLOUD_APM_TEAM", "xxx"); EXPECT_STREQ("xxx", conf.get_tencentcloud_apm_team().c_str()); - SrsSetEnvConfig(tencentcloud_apm_token, "SRS_TENCENTCLOUD_APM_TOKEN", "xxx2"); + SrsSetEnvConfig(conf, tencentcloud_apm_token, "SRS_TENCENTCLOUD_APM_TOKEN", "xxx2"); EXPECT_STREQ("xxx2", conf.get_tencentcloud_apm_token().c_str()); - SrsSetEnvConfig(tencentcloud_apm_endpoint, "SRS_TENCENTCLOUD_APM_ENDPOINT", "xxx3"); + SrsSetEnvConfig(conf, tencentcloud_apm_endpoint, "SRS_TENCENTCLOUD_APM_ENDPOINT", "xxx3"); EXPECT_STREQ("xxx3", conf.get_tencentcloud_apm_endpoint().c_str()); - SrsSetEnvConfig(tencentcloud_apm_service_name, "SRS_TENCENTCLOUD_APM_SERVICE_NAME", "srs"); + SrsSetEnvConfig(conf, tencentcloud_apm_service_name, "SRS_TENCENTCLOUD_APM_SERVICE_NAME", "srs"); EXPECT_STREQ("srs", conf.get_tencentcloud_apm_service_name().c_str()); - SrsSetEnvConfig(tencentcloud_apm_debug_logging, "SRS_TENCENTCLOUD_APM_DEBUG_LOGGING", "on"); + SrsSetEnvConfig(conf, tencentcloud_apm_debug_logging, "SRS_TENCENTCLOUD_APM_DEBUG_LOGGING", "on"); EXPECT_TRUE(conf.get_tencentcloud_apm_debug_logging()); } } @@ -4748,16 +4748,16 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesExporter) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(exporter_enabled, "SRS_EXPORTER_ENABLED", "on"); + SrsSetEnvConfig(conf, exporter_enabled, "SRS_EXPORTER_ENABLED", "on"); EXPECT_TRUE(conf.get_exporter_enabled()); - SrsSetEnvConfig(exporter_listen, "SRS_EXPORTER_LISTEN", "xxx"); + SrsSetEnvConfig(conf, exporter_listen, "SRS_EXPORTER_LISTEN", "xxx"); EXPECT_STREQ("xxx", conf.get_exporter_listen().c_str()); - SrsSetEnvConfig(exporter_label, "SRS_EXPORTER_LABEL", "xxx2"); + SrsSetEnvConfig(conf, exporter_label, "SRS_EXPORTER_LABEL", "xxx2"); EXPECT_STREQ("xxx2", conf.get_exporter_label().c_str()); - SrsSetEnvConfig(exporter_tag, "SRS_EXPORTER_TAG", "xxx3"); + SrsSetEnvConfig(conf, exporter_tag, "SRS_EXPORTER_TAG", "xxx3"); EXPECT_STREQ("xxx3", conf.get_exporter_tag().c_str()); } } @@ -4767,19 +4767,19 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHeartbeat) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(heartbeat_enabled, "SRS_HEARTBEAT_ENABLED", "on"); + SrsSetEnvConfig(conf, heartbeat_enabled, "SRS_HEARTBEAT_ENABLED", "on"); EXPECT_TRUE(conf.get_heartbeat_enabled()); - SrsSetEnvConfig(heartbeat_interval, "SRS_HEARTBEAT_INTERVAL", "5"); + SrsSetEnvConfig(conf, heartbeat_interval, "SRS_HEARTBEAT_INTERVAL", "5"); EXPECT_EQ(5 * SRS_UTIME_SECONDS, conf.get_heartbeat_interval()); - SrsSetEnvConfig(heartbeat_url, "SRS_HEARTBEAT_URL", "xxx"); + SrsSetEnvConfig(conf, heartbeat_url, "SRS_HEARTBEAT_URL", "xxx"); EXPECT_STREQ("xxx", conf.get_heartbeat_url().c_str()); - SrsSetEnvConfig(heartbeat_device_id, "SRS_HEARTBEAT_DEVICE_ID", "xxx2"); + SrsSetEnvConfig(conf, heartbeat_device_id, "SRS_HEARTBEAT_DEVICE_ID", "xxx2"); EXPECT_STREQ("xxx2", conf.get_heartbeat_device_id().c_str()); - SrsSetEnvConfig(heartbeat_summaries, "SRS_HEARTBEAT_SUMMARIES", "on"); + SrsSetEnvConfig(conf, heartbeat_summaries, "SRS_HEARTBEAT_SUMMARIES", "on"); EXPECT_TRUE(conf.get_heartbeat_summaries()); } } @@ -4789,30 +4789,30 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesScope) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(realtime_enabled, "SRS_VHOST_MIN_LATENCY", "off"); + SrsSetEnvConfig(conf, realtime_enabled, "SRS_VHOST_MIN_LATENCY", "off"); EXPECT_FALSE(conf.get_realtime_enabled("__defaultVhost__", true)); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(realtime_enabled, "SRS_VHOST_MIN_LATENCY", "on"); + SrsSetEnvConfig(conf, realtime_enabled, "SRS_VHOST_MIN_LATENCY", "on"); EXPECT_TRUE(conf.get_realtime_enabled("__defaultVhost__", false)); } if (true) { MockSrsConfig conf; - SrsSetEnvConfig(tcp_nodelay, "SRS_VHOST_TCP_NODELAY", "on"); + SrsSetEnvConfig(conf, tcp_nodelay, "SRS_VHOST_TCP_NODELAY", "on"); EXPECT_TRUE(conf.get_tcp_nodelay("__defaultVhost__")); - SrsSetEnvConfig(out_ack_size, "SRS_VHOST_OUT_ACK_SIZE", "2000000"); + SrsSetEnvConfig(conf, out_ack_size, "SRS_VHOST_OUT_ACK_SIZE", "2000000"); EXPECT_EQ(2000000, conf.get_out_ack_size("__defaultVhost__")); - SrsSetEnvConfig(in_ack_size, "SRS_VHOST_IN_ACK_SIZE", "1000"); + SrsSetEnvConfig(conf, in_ack_size, "SRS_VHOST_IN_ACK_SIZE", "1000"); EXPECT_EQ(1000, conf.get_in_ack_size("__defaultVhost__")); - SrsSetEnvConfig(chunk_size, "SRS_VHOST_CHUNK_SIZE", "50000"); + SrsSetEnvConfig(conf, chunk_size, "SRS_VHOST_CHUNK_SIZE", "50000"); EXPECT_EQ(50000, conf.get_chunk_size("__defaultVhost__")); } } @@ -4822,13 +4822,13 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHttpStatic) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(http_enabled, "SRS_VHOST_HTTP_STATIC_ENABLED", "on"); + SrsSetEnvConfig(conf, http_enabled, "SRS_VHOST_HTTP_STATIC_ENABLED", "on"); EXPECT_TRUE(conf.get_vhost_http_enabled("__defaultVhost__")); - SrsSetEnvConfig(http_mount, "SRS_VHOST_HTTP_STATIC_MOUNT", "xxx"); + SrsSetEnvConfig(conf, http_mount, "SRS_VHOST_HTTP_STATIC_MOUNT", "xxx"); EXPECT_STREQ("xxx", conf.get_vhost_http_mount("__defaultVhost__").c_str()); - SrsSetEnvConfig(http_dir, "SRS_VHOST_HTTP_STATIC_DIR", "xxx2"); + SrsSetEnvConfig(conf, http_dir, "SRS_VHOST_HTTP_STATIC_DIR", "xxx2"); EXPECT_STREQ("xxx2", conf.get_vhost_http_dir("__defaultVhost__").c_str()); } } @@ -4838,78 +4838,144 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHttpRemux) MockSrsConfig conf; if (true) { - SrsSetEnvConfig(http_remux_enabled, "SRS_VHOST_HTTP_REMUX_ENABLED", "on"); + SrsSetEnvConfig(conf, http_remux_enabled, "SRS_VHOST_HTTP_REMUX_ENABLED", "on"); EXPECT_TRUE(conf.get_vhost_http_remux_enabled("__defaultVhost__")); - SrsSetEnvConfig(http_remux_fast_cache, "SRS_VHOST_HTTP_REMUX_FAST_CACHE", "5"); + SrsSetEnvConfig(conf, http_remux_fast_cache, "SRS_VHOST_HTTP_REMUX_FAST_CACHE", "5"); EXPECT_EQ(5 * SRS_UTIME_SECONDS, conf.get_vhost_http_remux_fast_cache("__defaultVhost__")); - SrsSetEnvConfig(http_remux_mount, "SRS_VHOST_HTTP_REMUX_MOUNT", "xxx"); + SrsSetEnvConfig(conf, http_remux_mount, "SRS_VHOST_HTTP_REMUX_MOUNT", "xxx"); EXPECT_STREQ("xxx", conf.get_vhost_http_remux_mount("__defaultVhost__").c_str()); } if (true) { EXPECT_TRUE(conf.get_vhost_http_remux_drop_if_not_match("__defaultVhost__")); - SrsSetEnvConfig(drop_if_not_match, "SRS_VHOST_HTTP_REMUX_DROP_IF_NOT_MATCH", "off"); + SrsSetEnvConfig(conf, drop_if_not_match, "SRS_VHOST_HTTP_REMUX_DROP_IF_NOT_MATCH", "off"); EXPECT_FALSE(conf.get_vhost_http_remux_drop_if_not_match("__defaultVhost__")); - SrsSetEnvConfig(drop_if_not_match2, "SRS_VHOST_HTTP_REMUX_DROP_IF_NOT_MATCH", "on"); + SrsSetEnvConfig(conf, drop_if_not_match2, "SRS_VHOST_HTTP_REMUX_DROP_IF_NOT_MATCH", "on"); EXPECT_TRUE(conf.get_vhost_http_remux_drop_if_not_match("__defaultVhost__")); } if (true) { EXPECT_TRUE(conf.get_vhost_http_remux_has_audio("__defaultVhost__")); - SrsSetEnvConfig(has_audio, "SRS_VHOST_HTTP_REMUX_HAS_AUDIO", "off"); + SrsSetEnvConfig(conf, has_audio, "SRS_VHOST_HTTP_REMUX_HAS_AUDIO", "off"); EXPECT_FALSE(conf.get_vhost_http_remux_has_audio("__defaultVhost__")); - SrsSetEnvConfig(has_audio2, "SRS_VHOST_HTTP_REMUX_HAS_AUDIO", "on"); + SrsSetEnvConfig(conf, has_audio2, "SRS_VHOST_HTTP_REMUX_HAS_AUDIO", "on"); EXPECT_TRUE(conf.get_vhost_http_remux_has_audio("__defaultVhost__")); } if (true) { EXPECT_TRUE(conf.get_vhost_http_remux_has_video("__defaultVhost__")); - SrsSetEnvConfig(has_video, "SRS_VHOST_HTTP_REMUX_HAS_VIDEO", "off"); + SrsSetEnvConfig(conf, has_video, "SRS_VHOST_HTTP_REMUX_HAS_VIDEO", "off"); EXPECT_FALSE(conf.get_vhost_http_remux_has_video("__defaultVhost__")); - SrsSetEnvConfig(has_video2, "SRS_VHOST_HTTP_REMUX_HAS_VIDEO", "on"); + SrsSetEnvConfig(conf, has_video2, "SRS_VHOST_HTTP_REMUX_HAS_VIDEO", "on"); EXPECT_TRUE(conf.get_vhost_http_remux_has_video("__defaultVhost__")); } if (true) { EXPECT_TRUE(conf.get_vhost_http_remux_guess_has_av("__defaultVhost__")); - SrsSetEnvConfig(guess_has_av, "SRS_VHOST_HTTP_REMUX_GUESS_HAS_AV", "off"); + SrsSetEnvConfig(conf, guess_has_av, "SRS_VHOST_HTTP_REMUX_GUESS_HAS_AV", "off"); EXPECT_FALSE(conf.get_vhost_http_remux_guess_has_av("__defaultVhost__")); - SrsSetEnvConfig(guess_has_av2, "SRS_VHOST_HTTP_REMUX_GUESS_HAS_AV", "on"); + SrsSetEnvConfig(conf, guess_has_av2, "SRS_VHOST_HTTP_REMUX_GUESS_HAS_AV", "on"); EXPECT_TRUE(conf.get_vhost_http_remux_guess_has_av("__defaultVhost__")); } } +VOID TEST(ConfigEnvTest, CheckEnvValuesForward) +{ + srs_error_t err; + MockSrsConfig conf; + + if (true) { + // Test forward enabled environment variable + SrsSetEnvConfig(conf, forward_enabled, "SRS_VHOST_FORWARD_ENABLED", "on"); + EXPECT_TRUE(conf.get_forward_enabled("__defaultVhost__")); + } + + if (true) { + // Test forward enabled environment variable with off value + SrsSetEnvConfig(conf, forward_enabled, "SRS_VHOST_FORWARD_ENABLED", "off"); + EXPECT_FALSE(conf.get_forward_enabled("__defaultVhost__")); + } + + if (true) { + // Test forward backend environment variable + SrsSetEnvConfig(conf, forward_backend, "SRS_VHOST_FORWARD_BACKEND", "127.0.0.1:1936"); + SrsConfDirective* backend = conf.get_forward_backend("__defaultVhost__"); + ASSERT_TRUE(backend != NULL); + ASSERT_EQ((int)backend->args.size(), 1); + EXPECT_STREQ("127.0.0.1:1936", backend->arg0().c_str()); + } + + if (true) { + // Test forward backend environment variable with multiple backends + SrsSetEnvConfig(conf, forward_backend, "SRS_VHOST_FORWARD_BACKEND", "127.0.0.1:1936 127.0.0.1:1937"); + SrsConfDirective* backend = conf.get_forward_backend("__defaultVhost__"); + ASSERT_TRUE(backend != NULL); + ASSERT_EQ((int)backend->args.size(), 2); + EXPECT_STREQ("127.0.0.1:1936", backend->args.at(0).c_str()); + EXPECT_STREQ("127.0.0.1:1937", backend->args.at(1).c_str()); + } + + if (true) { + // Test that environment variable overrides config file + HELPER_ASSERT_SUCCESS(conf.parse(_MIN_OK_CONF "vhost ossrs.net{forward {enabled off; backend 192.168.1.1:1936;}}")); + + SrsSetEnvConfig(conf, forward_enabled, "SRS_VHOST_FORWARD_ENABLED", "on"); + SrsSetEnvConfig(conf, forward_backend, "SRS_VHOST_FORWARD_BACKEND", "10.0.0.1:1936"); + + // Environment variable should override config file + EXPECT_TRUE(conf.get_forward_enabled("ossrs.net")); + + SrsConfDirective* backend = conf.get_forward_backend("ossrs.net"); + ASSERT_TRUE(backend != NULL); + ASSERT_EQ((int)backend->args.size(), 1); + EXPECT_STREQ("10.0.0.1:1936", backend->arg0().c_str()); + } + + if (true) { + // Test with specific vhost name + SrsSetEnvConfig(conf, forward_enabled, "SRS_VHOST_FORWARD_ENABLED", "on"); + SrsSetEnvConfig(conf, forward_backend, "SRS_VHOST_FORWARD_BACKEND", "example.com:1936"); + + EXPECT_TRUE(conf.get_forward_enabled("test.example.com")); + + SrsConfDirective* backend = conf.get_forward_backend("test.example.com"); + ASSERT_TRUE(backend != NULL); + ASSERT_EQ((int)backend->args.size(), 1); + EXPECT_STREQ("example.com:1936", backend->arg0().c_str()); + } +} + VOID TEST(ConfigEnvTest, CheckEnvValuesDash) { if (true) { MockSrsConfig conf; - SrsSetEnvConfig(dash_enabled, "SRS_VHOST_DASH_ENABLED", "on"); + SrsSetEnvConfig(conf, dash_enabled, "SRS_VHOST_DASH_ENABLED", "on"); EXPECT_TRUE(conf.get_dash_enabled("__defaultVhost__")); - SrsSetEnvConfig(dash_fragment, "SRS_VHOST_DASH_DASH_FRAGMENT", "30"); + SrsSetEnvConfig(conf, dash_fragment, "SRS_VHOST_DASH_DASH_FRAGMENT", "30"); EXPECT_EQ(30 * SRS_UTIME_SECONDS, conf.get_dash_fragment("__defaultVhost__")); - SrsSetEnvConfig(dash_update_period, "SRS_VHOST_DASH_DASH_UPDATE_PERIOD", "10"); + SrsSetEnvConfig(conf, dash_update_period, "SRS_VHOST_DASH_DASH_UPDATE_PERIOD", "10"); EXPECT_EQ(10 * SRS_UTIME_SECONDS, conf.get_dash_update_period("__defaultVhost__")); - SrsSetEnvConfig(dash_timeshift, "SRS_VHOST_DASH_DASH_TIMESHIFT", "100"); + SrsSetEnvConfig(conf, dash_timeshift, "SRS_VHOST_DASH_DASH_TIMESHIFT", "100"); EXPECT_EQ(100 * SRS_UTIME_SECONDS, conf.get_dash_timeshift("__defaultVhost__")); - SrsSetEnvConfig(dash_path, "SRS_VHOST_DASH_DASH_PATH", "xxx"); + SrsSetEnvConfig(conf, dash_path, "SRS_VHOST_DASH_DASH_PATH", "xxx"); EXPECT_STREQ("xxx", conf.get_dash_path("__defaultVhost__").c_str()); - SrsSetEnvConfig(dash_mpd_file, "SRS_VHOST_DASH_DASH_MPD_FILE", "xxx2"); + SrsSetEnvConfig(conf, dash_mpd_file, "SRS_VHOST_DASH_DASH_MPD_FILE", "xxx2"); EXPECT_STREQ("xxx2", conf.get_dash_mpd_file("__defaultVhost__").c_str()); } } @@ -4919,22 +4985,22 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHds) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(hds_enabled, "SRS_VHOST_HDS_ENABLED", "on"); + SrsSetEnvConfig(conf, hds_enabled, "SRS_VHOST_HDS_ENABLED", "on"); EXPECT_TRUE(conf.get_hds_enabled("__defaultVhost__")); - SrsSetEnvConfig(hds_fragment, "SRS_VHOST_HDS_HDS_FRAGMENT", "20"); + SrsSetEnvConfig(conf, hds_fragment, "SRS_VHOST_HDS_HDS_FRAGMENT", "20"); EXPECT_EQ(20 * SRS_UTIME_SECONDS, conf.get_hds_fragment("__defaultVhost__")); - SrsSetEnvConfig(hds_fragment_float, "SRS_VHOST_HDS_HDS_FRAGMENT", "20.1"); + SrsSetEnvConfig(conf, hds_fragment_float, "SRS_VHOST_HDS_HDS_FRAGMENT", "20.1"); EXPECT_EQ(20.1 * SRS_UTIME_SECONDS, conf.get_hds_fragment("__defaultVhost__")); - SrsSetEnvConfig(hds_window, "SRS_VHOST_HDS_HDS_WINDOW", "30"); + SrsSetEnvConfig(conf, hds_window, "SRS_VHOST_HDS_HDS_WINDOW", "30"); EXPECT_EQ(30 * SRS_UTIME_SECONDS, conf.get_hds_window("__defaultVhost__")); - SrsSetEnvConfig(hds_window_float, "SRS_VHOST_HDS_HDS_WINDOW", "30.1"); + SrsSetEnvConfig(conf, hds_window_float, "SRS_VHOST_HDS_HDS_WINDOW", "30.1"); EXPECT_EQ(30.1 * SRS_UTIME_SECONDS, conf.get_hds_window("__defaultVhost__")); - SrsSetEnvConfig(hds_path, "SRS_VHOST_HDS_HDS_PATH", "xxx"); + SrsSetEnvConfig(conf, hds_path, "SRS_VHOST_HDS_HDS_PATH", "xxx"); EXPECT_STREQ("xxx", conf.get_hds_path("__defaultVhost__").c_str()); } } @@ -4944,25 +5010,25 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesDvr) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(dvr_enabled, "SRS_VHOST_DVR_ENABLED", "on"); + SrsSetEnvConfig(conf, dvr_enabled, "SRS_VHOST_DVR_ENABLED", "on"); EXPECT_TRUE(conf.get_dvr_enabled("__defaultVhost__")); - SrsSetEnvConfig(dvr_plan, "SRS_VHOST_DVR_DVR_PLAN", "xxx"); + SrsSetEnvConfig(conf, dvr_plan, "SRS_VHOST_DVR_DVR_PLAN", "xxx"); EXPECT_STREQ("xxx", conf.get_dvr_plan("__defaultVhost__").c_str()); - SrsSetEnvConfig(dvr_path, "SRS_VHOST_DVR_DVR_PATH", "xxx2"); + SrsSetEnvConfig(conf, dvr_path, "SRS_VHOST_DVR_DVR_PATH", "xxx2"); EXPECT_STREQ("xxx2", conf.get_dvr_path("__defaultVhost__").c_str()); - SrsSetEnvConfig(dvr_duration, "SRS_VHOST_DVR_DVR_DURATION", "60"); + SrsSetEnvConfig(conf, dvr_duration, "SRS_VHOST_DVR_DVR_DURATION", "60"); EXPECT_EQ(60 * SRS_UTIME_SECONDS, conf.get_dvr_duration("__defaultVhost__")); - SrsSetEnvConfig(dvr_wait_keyframe, "SRS_VHOST_DVR_DVR_WAIT_KEYFRAME", "off"); + SrsSetEnvConfig(conf, dvr_wait_keyframe, "SRS_VHOST_DVR_DVR_WAIT_KEYFRAME", "off"); EXPECT_FALSE(conf.get_dvr_wait_keyframe("__defaultVhost__")); - SrsSetEnvConfig(dvr_time_jitter_full, "SRS_VHOST_DVR_TIME_JITTER", "full"); + SrsSetEnvConfig(conf, dvr_time_jitter_full, "SRS_VHOST_DVR_TIME_JITTER", "full"); EXPECT_EQ(0x1, conf.get_dvr_time_jitter("__defaultVhost__")); - SrsSetEnvConfig(dvr_time_jitter_zero, "SRS_VHOST_DVR_TIME_JITTER", "zero"); + SrsSetEnvConfig(conf, dvr_time_jitter_zero, "SRS_VHOST_DVR_TIME_JITTER", "zero"); EXPECT_EQ(0x2, conf.get_dvr_time_jitter("__defaultVhost__")); } } @@ -4972,79 +5038,79 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHls) if (true) { MockSrsConfig conf; - SrsSetEnvConfig(hls_enabled, "SRS_VHOST_HLS_ENABLED", "on"); + SrsSetEnvConfig(conf, hls_enabled, "SRS_VHOST_HLS_ENABLED", "on"); EXPECT_TRUE(conf.get_hls_enabled("__defaultVhost__")); - SrsSetEnvConfig(hls_ctx_enabled, "SRS_VHOST_HLS_HLS_CTX", "off"); + SrsSetEnvConfig(conf, hls_ctx_enabled, "SRS_VHOST_HLS_HLS_CTX", "off"); EXPECT_FALSE(conf.get_hls_ctx_enabled("__defaultVhost__")); - SrsSetEnvConfig(hls_ts_ctx_enabled, "SRS_VHOST_HLS_HLS_TS_CTX", "off"); + SrsSetEnvConfig(conf, hls_ts_ctx_enabled, "SRS_VHOST_HLS_HLS_TS_CTX", "off"); EXPECT_FALSE(conf.get_hls_ts_ctx_enabled("__defaultVhost__")); - SrsSetEnvConfig(hls_fragment, "SRS_VHOST_HLS_HLS_FRAGMENT", "5"); + SrsSetEnvConfig(conf, hls_fragment, "SRS_VHOST_HLS_HLS_FRAGMENT", "5"); EXPECT_EQ(5 * SRS_UTIME_SECONDS, conf.get_hls_fragment("__defaultVhost__")); - SrsSetEnvConfig(hls_td_ratio, "SRS_VHOST_HLS_HLS_TD_RATIO", "1.4"); + SrsSetEnvConfig(conf, hls_td_ratio, "SRS_VHOST_HLS_HLS_TD_RATIO", "1.4"); EXPECT_EQ(1.4, conf.get_hls_td_ratio("__defaultVhost__")); - SrsSetEnvConfig(hls_aof_ratio, "SRS_VHOST_HLS_HLS_AOF_RATIO", "2.5"); + SrsSetEnvConfig(conf, hls_aof_ratio, "SRS_VHOST_HLS_HLS_AOF_RATIO", "2.5"); EXPECT_EQ(2.5, conf.get_hls_aof_ratio("__defaultVhost__")); - SrsSetEnvConfig(hls_window, "SRS_VHOST_HLS_HLS_WINDOW", "30"); + SrsSetEnvConfig(conf, hls_window, "SRS_VHOST_HLS_HLS_WINDOW", "30"); EXPECT_EQ(30 * SRS_UTIME_SECONDS, conf.get_hls_window("__defaultVhost__")); - SrsSetEnvConfig(hls_on_error, "SRS_VHOST_HLS_HLS_ON_ERROR", "xxx"); + SrsSetEnvConfig(conf, hls_on_error, "SRS_VHOST_HLS_HLS_ON_ERROR", "xxx"); EXPECT_STREQ("xxx", conf.get_hls_on_error("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_path, "SRS_VHOST_HLS_HLS_PATH", "xxx2"); + SrsSetEnvConfig(conf, hls_path, "SRS_VHOST_HLS_HLS_PATH", "xxx2"); EXPECT_STREQ("xxx2", conf.get_hls_path("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_m3u8_file, "SRS_VHOST_HLS_HLS_M3U8_FILE", "xxx3"); + SrsSetEnvConfig(conf, hls_m3u8_file, "SRS_VHOST_HLS_HLS_M3U8_FILE", "xxx3"); EXPECT_STREQ("xxx3", conf.get_hls_m3u8_file("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_ts_file, "SRS_VHOST_HLS_HLS_TS_FILE", "xxx4"); + SrsSetEnvConfig(conf, hls_ts_file, "SRS_VHOST_HLS_HLS_TS_FILE", "xxx4"); EXPECT_STREQ("xxx4", conf.get_hls_ts_file("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_ts_floor, "SRS_VHOST_HLS_HLS_TS_FLOOR", "on"); + SrsSetEnvConfig(conf, hls_ts_floor, "SRS_VHOST_HLS_HLS_TS_FLOOR", "on"); EXPECT_TRUE(conf.get_hls_ts_floor("__defaultVhost__")); - SrsSetEnvConfig(hls_entry_prefix, "SRS_VHOST_HLS_HLS_ENTRY_PREFIX", "yyy"); + SrsSetEnvConfig(conf, hls_entry_prefix, "SRS_VHOST_HLS_HLS_ENTRY_PREFIX", "yyy"); EXPECT_STREQ("yyy", conf.get_hls_entry_prefix("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_acodec, "SRS_VHOST_HLS_HLS_ACODEC", "yyy2"); + SrsSetEnvConfig(conf, hls_acodec, "SRS_VHOST_HLS_HLS_ACODEC", "yyy2"); EXPECT_STREQ("yyy2", conf.get_hls_acodec("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_vcodec, "SRS_VHOST_HLS_HLS_VCODEC", "yyy3"); + SrsSetEnvConfig(conf, hls_vcodec, "SRS_VHOST_HLS_HLS_VCODEC", "yyy3"); EXPECT_STREQ("yyy3", conf.get_hls_vcodec("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_cleanup, "SRS_VHOST_HLS_HLS_CLEANUP", "off"); + SrsSetEnvConfig(conf, hls_cleanup, "SRS_VHOST_HLS_HLS_CLEANUP", "off"); EXPECT_FALSE(conf.get_hls_cleanup("__defaultVhost__")); - SrsSetEnvConfig(hls_dispose, "SRS_VHOST_HLS_HLS_DISPOSE", "10"); + SrsSetEnvConfig(conf, hls_dispose, "SRS_VHOST_HLS_HLS_DISPOSE", "10"); EXPECT_EQ(10 * SRS_UTIME_SECONDS, conf.get_hls_dispose("__defaultVhost__")); - SrsSetEnvConfig(hls_nb_notify, "SRS_VHOST_HLS_HLS_NB_NOTIFY", "50"); + SrsSetEnvConfig(conf, hls_nb_notify, "SRS_VHOST_HLS_HLS_NB_NOTIFY", "50"); EXPECT_EQ(50, conf.get_vhost_hls_nb_notify("__defaultVhost__")); - SrsSetEnvConfig(hls_wait_keyframe, "SRS_VHOST_HLS_HLS_WAIT_KEYFRAME", "off"); + SrsSetEnvConfig(conf, hls_wait_keyframe, "SRS_VHOST_HLS_HLS_WAIT_KEYFRAME", "off"); EXPECT_FALSE(conf.get_hls_wait_keyframe("__defaultVhost__")); - SrsSetEnvConfig(hls_keys, "SRS_VHOST_HLS_HLS_KEYS", "off"); + SrsSetEnvConfig(conf, hls_keys, "SRS_VHOST_HLS_HLS_KEYS", "off"); EXPECT_FALSE(conf.get_hls_keys("__defaultVhost__")); - SrsSetEnvConfig(hls_fragments_per_key, "SRS_VHOST_HLS_HLS_FRAGMENTS_PER_KEY", "6"); + SrsSetEnvConfig(conf, hls_fragments_per_key, "SRS_VHOST_HLS_HLS_FRAGMENTS_PER_KEY", "6"); EXPECT_EQ(6, conf.get_hls_fragments_per_key("__defaultVhost__")); - SrsSetEnvConfig(hls_key_file, "SRS_VHOST_HLS_HLS_KEY_FILE", "zzz"); + SrsSetEnvConfig(conf, hls_key_file, "SRS_VHOST_HLS_HLS_KEY_FILE", "zzz"); EXPECT_STREQ("zzz", conf.get_hls_key_file("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_key_file_path, "SRS_VHOST_HLS_HLS_KEY_FILE_PATH", "zzz2"); + SrsSetEnvConfig(conf, hls_key_file_path, "SRS_VHOST_HLS_HLS_KEY_FILE_PATH", "zzz2"); EXPECT_STREQ("zzz2", conf.get_hls_key_file_path("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_key_url, "SRS_VHOST_HLS_HLS_KEY_URL", "zzz3"); + SrsSetEnvConfig(conf, hls_key_url, "SRS_VHOST_HLS_HLS_KEY_URL", "zzz3"); EXPECT_STREQ("zzz3", conf.get_hls_key_url("__defaultVhost__").c_str()); - SrsSetEnvConfig(hls_dts_directly, "SRS_VHOST_HLS_HLS_DTS_DIRECTLY", "off"); + SrsSetEnvConfig(conf, hls_dts_directly, "SRS_VHOST_HLS_HLS_DTS_DIRECTLY", "off"); EXPECT_FALSE(conf.get_vhost_hls_dts_directly("__defaultVhost__")); } } @@ -5054,12 +5120,12 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) MockSrsConfig conf; if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ENABLED", "on"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ENABLED", "on"); EXPECT_TRUE(conf.get_vhost_http_hooks_enabled("__defaultVhost__")); } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_CONNECT", "http://server/api/connect"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_CONNECT", "http://server/api/connect"); SrsConfDirective* dir = conf.get_vhost_on_connect("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_EQ((int)dir->args.size(), 1); @@ -5067,7 +5133,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_CLOSE", "http://server/api/close"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_CLOSE", "http://server/api/close"); SrsConfDirective* dir = conf.get_vhost_on_close("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5075,7 +5141,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_PUBLISH", "http://server/api/publish"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_PUBLISH", "http://server/api/publish"); SrsConfDirective* dir = conf.get_vhost_on_publish("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_EQ((int)dir->args.size(), 1); @@ -5083,7 +5149,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_UNPUBLISH", "http://server/api/unpublish"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_UNPUBLISH", "http://server/api/unpublish"); SrsConfDirective* dir = conf.get_vhost_on_unpublish("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5091,7 +5157,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_PLAY", "http://server/api/play"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_PLAY", "http://server/api/play"); SrsConfDirective* dir = conf.get_vhost_on_play("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5099,7 +5165,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_STOP", "http://server/api/stop"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_STOP", "http://server/api/stop"); SrsConfDirective* dir = conf.get_vhost_on_stop("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5107,7 +5173,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_DVR", "http://server/api/dvr"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_DVR", "http://server/api/dvr"); SrsConfDirective* dir = conf.get_vhost_on_dvr("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5115,7 +5181,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS", "http://server/api/hls"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS", "http://server/api/hls"); SrsConfDirective* dir = conf.get_vhost_on_hls("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5123,7 +5189,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooks) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS_NOTIFY", "http://server/api/hls_notify"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS_NOTIFY", "http://server/api/hls_notify"); SrsConfDirective* dir = conf.get_vhost_on_hls_notify("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5136,7 +5202,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) MockSrsConfig conf; if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_CONNECT", "http://server/api/connect https://server2/api/connect2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_CONNECT", "http://server/api/connect https://server2/api/connect2"); SrsConfDirective* dir = conf.get_vhost_on_connect("__defaultVhost__"); ASSERT_TRUE(dir != NULL); @@ -5146,7 +5212,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_CLOSE", "http://server/api/close close2 close3"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_CLOSE", "http://server/api/close close2 close3"); SrsConfDirective* dir = conf.get_vhost_on_close("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 3); @@ -5156,7 +5222,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_PUBLISH", "http://server/api/publish http://server/api/publish2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_PUBLISH", "http://server/api/publish http://server/api/publish2"); SrsConfDirective* dir = conf.get_vhost_on_publish("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_EQ((int)dir->args.size(), 2); @@ -5165,7 +5231,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_UNPUBLISH", "http://server/api/unpublish 2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_UNPUBLISH", "http://server/api/unpublish 2"); SrsConfDirective* dir = conf.get_vhost_on_unpublish("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 2); @@ -5174,7 +5240,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_PLAY", "http://server/api/play http://server/api/play2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_PLAY", "http://server/api/play http://server/api/play2"); SrsConfDirective* dir = conf.get_vhost_on_play("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 2); @@ -5183,7 +5249,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_STOP", "http://server/api/stop http://server/api/stop2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_STOP", "http://server/api/stop http://server/api/stop2"); SrsConfDirective* dir = conf.get_vhost_on_stop("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 2); @@ -5192,7 +5258,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_DVR", "http://server/api/dvr http://server/api/dvr2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_DVR", "http://server/api/dvr http://server/api/dvr2"); SrsConfDirective* dir = conf.get_vhost_on_dvr("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 2); @@ -5201,7 +5267,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS", "http://server/api/hls http://server/api/hls2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS", "http://server/api/hls http://server/api/hls2"); SrsConfDirective* dir = conf.get_vhost_on_hls("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 2); @@ -5210,7 +5276,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksMultiValues) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS_NOTIFY", "http://server/api/hls_notify http://server/api/hls_notify2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_HLS_NOTIFY", "http://server/api/hls_notify http://server/api/hls_notify2"); SrsConfDirective* dir = conf.get_vhost_on_hls_notify("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 2); @@ -5224,7 +5290,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksWithWhitespaces) MockSrsConfig conf; if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_PUBLISH", "http://server/api/publish http://server/api/publish2"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_PUBLISH", "http://server/api/publish http://server/api/publish2"); SrsConfDirective* dir = conf.get_vhost_on_publish("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_EQ((int)dir->args.size(), 2); @@ -5233,7 +5299,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksWithWhitespaces) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_UNPUBLISH", "http://server/api/unpublish "); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_UNPUBLISH", "http://server/api/unpublish "); SrsConfDirective* dir = conf.get_vhost_on_unpublish("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); @@ -5241,7 +5307,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksWithWhitespaces) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_PLAY", " http://server/api/play play2 play3 "); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_PLAY", " http://server/api/play play2 play3 "); SrsConfDirective* dir = conf.get_vhost_on_play("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 3); @@ -5251,7 +5317,7 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesHooksWithWhitespaces) } if (true) { - SrsSetEnvConfig(hooks, "SRS_VHOST_HTTP_HOOKS_ON_DVR", " dvr"); + SrsSetEnvConfig(conf, hooks, "SRS_VHOST_HTTP_HOOKS_ON_DVR", " dvr"); SrsConfDirective* dir = conf.get_vhost_on_dvr("__defaultVhost__"); ASSERT_TRUE(dir != NULL); ASSERT_TRUE((int)dir->args.size() == 1); diff --git a/trunk/src/utest/srs_utest_config.hpp b/trunk/src/utest/srs_utest_config.hpp index b24624373..1fa2fbffb 100644 --- a/trunk/src/utest/srs_utest_config.hpp +++ b/trunk/src/utest/srs_utest_config.hpp @@ -45,13 +45,17 @@ class ISrsSetEnvConfig { private: std::string key; + SrsConfig* conf; public: - ISrsSetEnvConfig(const std::string& k, const std::string& v, bool overwrite) { + ISrsSetEnvConfig(SrsConfig* c, const std::string& k, const std::string& v, bool overwrite) { + conf = c; key = k; srs_setenv(k, v, overwrite); } virtual ~ISrsSetEnvConfig() { srs_unsetenv(key); + srs_freep(conf->env_cache_); + conf->env_cache_ = new SrsConfDirective(); } private: // Adds, changes environment variables, which may starts with $. @@ -60,8 +64,8 @@ private: int srs_unsetenv(const std::string& key); }; -#define SrsSetEnvConfig(instance, key, value) \ - ISrsSetEnvConfig _SRS_free_##instance(key, value, true) +#define SrsSetEnvConfig(conf, instance, key, value) \ + ISrsSetEnvConfig _SRS_free_##instance(&conf, key, value, true) #endif