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

Disable reload for log config.

Browse source
This commit is contained in:
winlin 2022-06-29 19:29:50 +08:00
parent cb6a4d0143
commit e05535267b
11 changed files with 6 additions and 368 deletions
Download patch file Download diff file Expand all files Collapse all files

6
trunk/conf/full.conf
View file

@ -22,23 +22,28 @@ chunk_size 60000;
# the log dir for FFMPEG.
# if enabled ffmpeg, each transcoding stream will create a log file.
# /dev/null to disable the log.
# Note: Do not support reloading, for SRS5+
# default: ./objs
ff_log_dir ./objs;
# the log level for FFMPEG.
# info warning error fatal panic quiet
# trace debug verbose
# Note: Do not support reloading, for SRS5+
# default: info
ff_log_level info;
# the log tank, console or file.
# if console, print log to console.
# if file, write log to file. requires srs_log_file if log to file.
# Note: Do not support reloading, for SRS5+
# default: file.
srs_log_tank console;
# the log level, for all log tanks.
# can be: verbose, info, trace, warn, error
# Note: Do not support reloading, for SRS5+
# default: trace
srs_log_level trace;
# when srs_log_tank is file, specifies the log file.
# Note: Do not support reloading, for SRS5+
# default: ./objs/srs.log
srs_log_file ./objs/srs.log;
# the max connections.
@ -52,6 +57,7 @@ daemon off;
# whether use utc_time to generate the time struct,
# if off, use localtime() to generate it,
# if on, use gmtime() instead, which use UTC time.
# Note: Do not support reloading, for SRS5+
# default: off
utc_time off;
# config for the pithy print in ms,

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

@ -1530,34 +1530,6 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
}
}
// merge config: pid
if (!srs_directive_equals(root->get("pid"), old_root->get("pid"))) {
if ((err = do_reload_pid()) != srs_success) {
return srs_error_wrap(err, "pid");;
}
}
// merge config: srs_log_tank
if (!srs_directive_equals(root->get("srs_log_tank"), old_root->get("srs_log_tank"))) {
if ((err = do_reload_srs_log_tank()) != srs_success) {
return srs_error_wrap(err, "log tank");;
}
}
// merge config: srs_log_level
if (!srs_directive_equals(root->get("srs_log_level"), old_root->get("srs_log_level"))) {
if ((err = do_reload_srs_log_level()) != srs_success) {
return srs_error_wrap(err, "log level");;
}
}
// merge config: srs_log_file
if (!srs_directive_equals(root->get("srs_log_file"), old_root->get("srs_log_file"))) {
if ((err = do_reload_srs_log_file()) != srs_success) {
return srs_error_wrap(err, "log file");;
}
}
// 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) {
@ -1565,13 +1537,6 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
}
}
// merge config: utc_time
if (!srs_directive_equals(root->get("utc_time"), old_root->get("utc_time"))) {
if ((err = do_reload_utc_time()) != srs_success) {
return srs_error_wrap(err, "utc time");;
}
}
// 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) {
@ -2167,70 +2132,6 @@ srs_error_t SrsConfig::do_reload_listen()
return err;
}
srs_error_t SrsConfig::do_reload_pid()
{
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_pid()) != srs_success) {
return srs_error_wrap(err, "notify subscribes reload pid failed");
}
}
srs_trace("reload pid success.");
return err;
}
srs_error_t SrsConfig::do_reload_srs_log_tank()
{
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_log_tank()) != srs_success) {
return srs_error_wrap(err, "notify subscribes reload srs_log_tank failed");
}
}
srs_trace("reload srs_log_tank success.");
return err;
}
srs_error_t SrsConfig::do_reload_srs_log_level()
{
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_log_level()) != srs_success) {
return srs_error_wrap(err, "notify subscribes reload srs_log_level failed");
}
}
srs_trace("reload srs_log_level success.");
return err;
}
srs_error_t SrsConfig::do_reload_srs_log_file()
{
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_log_file()) != srs_success) {
return srs_error_wrap(err, "notify subscribes reload srs_log_file failed");
}
}
srs_trace("reload srs_log_file success.");
return err;
}
srs_error_t SrsConfig::do_reload_max_connections()
{
srs_error_t err = srs_success;
@ -2247,22 +2148,6 @@ srs_error_t SrsConfig::do_reload_max_connections()
return err;
}
srs_error_t SrsConfig::do_reload_utc_time()
{
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_utc_time()) != srs_success) {
return srs_error_wrap(err, "utc_time");
}
}
srs_trace("reload utc_time success.");
return err;
}
srs_error_t SrsConfig::do_reload_pithy_print_ms()
{
srs_error_t err = srs_success;

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

@ -349,12 +349,7 @@ public:
virtual srs_error_t raw_to_json(SrsJsonObject* obj);
private:
virtual srs_error_t do_reload_listen();
virtual srs_error_t do_reload_pid();
virtual srs_error_t do_reload_srs_log_tank();
virtual srs_error_t do_reload_srs_log_level();
virtual srs_error_t do_reload_srs_log_file();
virtual srs_error_t do_reload_max_connections();
virtual srs_error_t do_reload_utc_time();
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);

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

@ -198,73 +198,6 @@ void SrsFileLog::error(const char* tag, SrsContextId context_id, const char* fmt
write_log(fd, log_data, size, SrsLogLevelError);
}
srs_error_t SrsFileLog::on_reload_utc_time()
{
utc = _srs_config->get_utc_time();
return srs_success;
}
srs_error_t SrsFileLog::on_reload_log_tank()
{
srs_error_t err = srs_success;
if (!_srs_config) {
return err;
}
bool tank = log_to_file_tank;
log_to_file_tank = _srs_config->get_log_tank_file();
if (tank) {
return err;
}
if (!log_to_file_tank) {
return err;
}
if (fd > 0) {
::close(fd);
}
open_log_file();
return err;
}
srs_error_t SrsFileLog::on_reload_log_level()
{
srs_error_t err = srs_success;
if (!_srs_config) {
return err;
}
level = srs_get_log_level(_srs_config->get_log_level());
return err;
}
srs_error_t SrsFileLog::on_reload_log_file()
{
srs_error_t err = srs_success;
if (!_srs_config) {
return err;
}
if (!log_to_file_tank) {
return err;
}
if (fd > 0) {
::close(fd);
}
open_log_file();
return err;
}
void SrsFileLog::write_log(int& fd, char *str_log, int size, int level)
{
// ensure the tail and EOF of string

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

@ -56,12 +56,6 @@ public:
virtual void trace(const char* tag, SrsContextId context_id, const char* fmt, ...);
virtual void warn(const char* tag, SrsContextId context_id, const char* fmt, ...);
virtual void error(const char* tag, SrsContextId context_id, const char* fmt, ...);
// Interface ISrsReloadHandler.
public:
virtual srs_error_t on_reload_utc_time();
virtual srs_error_t on_reload_log_tank();
virtual srs_error_t on_reload_log_level();
virtual srs_error_t on_reload_log_file();
private:
virtual void write_log(int& fd, char* str_log, int size, int level);
virtual void open_log_file();

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

@ -23,36 +23,11 @@ srs_error_t ISrsReloadHandler::on_reload_listen()
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_utc_time()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_max_conns()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_pid()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_log_tank()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_log_level()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_log_file()
{
return srs_success;
}
srs_error_t ISrsReloadHandler::on_reload_pithy_print()
{
return srs_success;

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

@ -22,13 +22,8 @@ public:
ISrsReloadHandler();
virtual ~ISrsReloadHandler();
public:
virtual srs_error_t on_reload_utc_time();
virtual srs_error_t on_reload_max_conns();
virtual srs_error_t on_reload_listen();
virtual srs_error_t on_reload_pid();
virtual srs_error_t on_reload_log_tank();
virtual srs_error_t on_reload_log_level();
virtual srs_error_t on_reload_log_file();
virtual srs_error_t on_reload_pithy_print();
virtual srs_error_t on_reload_http_api_enabled();
virtual srs_error_t on_reload_http_api_disabled();

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

@ -1495,22 +1495,6 @@ srs_error_t SrsServer::on_reload_listen()
return err;
}
srs_error_t SrsServer::on_reload_pid()
{
srs_error_t err = srs_success;
if (pid_fd > 0) {
::close(pid_fd);
pid_fd = -1;
}
if ((err = acquire_pid_file()) != srs_success) {
return srs_error_wrap(err, "reload pid");
}
return err;
}
srs_error_t SrsServer::on_reload_vhost_added(std::string vhost)
{
srs_error_t err = srs_success;

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

@ -319,7 +319,6 @@ public:
// Interface ISrsReloadHandler.
public:
virtual srs_error_t on_reload_listen();
virtual srs_error_t on_reload_pid();
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_http_api_enabled();

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

@ -22,10 +22,6 @@ MockReloadHandler::~MockReloadHandler()
void MockReloadHandler::reset()
{
listen_reloaded = false;
pid_reloaded = false;
log_tank_reloaded = false;
log_level_reloaded = false;
log_file_reloaded = false;
pithy_print_reloaded = false;
http_api_enabled_reloaded = false;
http_api_disabled_reloaded = false;
@ -55,10 +51,6 @@ int MockReloadHandler::count_true()
int count_true = 0;
if (listen_reloaded) count_true++;
if (pid_reloaded) count_true++;
if (log_tank_reloaded) count_true++;
if (log_level_reloaded) count_true++;
if (log_file_reloaded) count_true++;
if (pithy_print_reloaded) count_true++;
if (http_api_enabled_reloaded) count_true++;
if (http_api_disabled_reloaded) count_true++;
@ -85,10 +77,6 @@ int MockReloadHandler::count_false()
int count_false = 0;
if (!listen_reloaded) count_false++;
if (!pid_reloaded) count_false++;
if (!log_tank_reloaded) count_false++;
if (!log_level_reloaded) count_false++;
if (!log_file_reloaded) count_false++;
if (!pithy_print_reloaded) count_false++;
if (!http_api_enabled_reloaded) count_false++;
if (!http_api_disabled_reloaded) count_false++;
@ -126,30 +114,6 @@ srs_error_t MockReloadHandler::on_reload_listen()
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_pid()
{
pid_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_log_tank()
{
log_tank_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_log_level()
{
log_level_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_log_file()
{
log_file_reloaded = true;
return srs_success;
}
srs_error_t MockReloadHandler::on_reload_pithy_print()
{
pithy_print_reloaded = true;
@ -334,90 +298,6 @@ VOID TEST(ConfigReloadTest, ReloadListen)
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadPid)
{
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"pid srs.pid;"));
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"pid srs.pid;"));
EXPECT_TRUE(handler.all_false());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"pid srs1.pid;"));
EXPECT_TRUE(handler.pid_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"pid srs.pid;"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadLogTank)
{
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"srs_log_tank console;"));
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_tank console;"));
EXPECT_TRUE(handler.all_false());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_tank file;"));
EXPECT_TRUE(handler.log_tank_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_tank console;"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadLogLevel)
{
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"srs_log_level trace;"));
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_level trace;"));
EXPECT_TRUE(handler.all_false());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_level warn;"));
EXPECT_TRUE(handler.log_level_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_level trace;"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadLogFile)
{
MockReloadHandler handler;
MockSrsReloadConfig conf;
conf.subscribe(&handler);
EXPECT_TRUE(ERROR_SUCCESS == conf.parse(_MIN_OK_CONF"srs_log_file srs.log;"));
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_file srs.log;"));
EXPECT_TRUE(handler.all_false());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_file srs1.log;"));
EXPECT_TRUE(handler.log_file_reloaded);
EXPECT_EQ(1, handler.count_true());
handler.reset();
EXPECT_TRUE(ERROR_SUCCESS == conf.do_reload(_MIN_OK_CONF"srs_log_file srs.log;"));
EXPECT_EQ(1, handler.count_true());
handler.reset();
}
VOID TEST(ConfigReloadTest, ReloadPithyPrint)
{
MockReloadHandler handler;

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

@ -19,10 +19,6 @@ class MockReloadHandler : public ISrsReloadHandler
{
public:
bool listen_reloaded;
bool pid_reloaded;
bool log_tank_reloaded;
bool log_level_reloaded;
bool log_file_reloaded;
bool pithy_print_reloaded;
bool http_api_enabled_reloaded;
bool http_api_disabled_reloaded;
@ -52,10 +48,6 @@ public:
virtual int count_false();
public:
virtual srs_error_t on_reload_listen();
virtual srs_error_t on_reload_pid();
virtual srs_error_t on_reload_log_tank();
virtual srs_error_t on_reload_log_level();
virtual srs_error_t on_reload_log_file();
virtual srs_error_t on_reload_pithy_print();
virtual srs_error_t on_reload_http_api_enabled();
virtual srs_error_t on_reload_http_api_disabled();