For #913, use complex error for reload utc time

winlinvip · winlinvip · commit 661eb8b37c90 · 2017-07-29T20:02:38.000+08:00
diff --git a/trunk/src/app/srs_app_config.cpp b/trunk/src/app/srs_app_config.cpp
@@ -1195,7 +1195,6 @@ void SrsConfig::unsubscribe(ISrsReloadHandler* handler)
 
 srs_error_t SrsConfig::reload()
 {
-    int ret = ERROR_SUCCESS;
     srs_error_t err = srs_success;
     
     SrsConfig conf;
@@ -1214,8 +1213,8 @@ srs_error_t SrsConfig::reload()
         return srs_error_wrap(err, "check config");
     }
     
-    if ((ret = reload_conf(&conf)) != ERROR_SUCCESS) {
-        return srs_error_new(ret, "reload config");
+    if ((err = reload_conf(&conf)) != srs_success) {
+        return srs_error_wrap(err, "reload config");
     }
     
     return err;
@@ -1485,9 +1484,10 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)
     return ret;
 }
 
-int SrsConfig::reload_conf(SrsConfig* conf)
+srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
 {
     int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     SrsConfDirective* old_root = root;
     SrsAutoFree(SrsConfDirective, old_root);
@@ -1509,78 +1509,78 @@ int SrsConfig::reload_conf(SrsConfig* conf)
     // merge config: listen
     if (!srs_directive_equals(root->get("listen"), old_root->get("listen"))) {
         if ((ret = do_reload_listen()) != ERROR_SUCCESS) {
-            return ret;
+            return srs_error_new(ret, "listen");
         }
     }
     
     // merge config: pid
     if (!srs_directive_equals(root->get("pid"), old_root->get("pid"))) {
         if ((ret = do_reload_pid()) != ERROR_SUCCESS) {
-            return ret;
+            return srs_error_new(ret, "pid");;
         }
     }
     
     // merge config: srs_log_tank
     if (!srs_directive_equals(root->get("srs_log_tank"), old_root->get("srs_log_tank"))) {
         if ((ret = do_reload_srs_log_tank()) != ERROR_SUCCESS) {
-            return ret;
+            return srs_error_new(ret, "log tank");;
         }
     }
     
     // merge config: srs_log_level
     if (!srs_directive_equals(root->get("srs_log_level"), old_root->get("srs_log_level"))) {
         if ((ret = do_reload_srs_log_level()) != ERROR_SUCCESS) {
-            return ret;
+            return srs_error_new(ret, "log level");;
         }
     }
     
     // merge config: srs_log_file
     if (!srs_directive_equals(root->get("srs_log_file"), old_root->get("srs_log_file"))) {
         if ((ret = do_reload_srs_log_file()) != ERROR_SUCCESS) {
-            return ret;
+            return srs_error_new(ret, "log file");;
         }
     }
     
     // merge config: max_connections
     if (!srs_directive_equals(root->get("max_connections"), old_root->get("max_connections"))) {
         if ((ret = do_reload_max_connections()) != ERROR_SUCCESS) {
-            return ret;
+            return srs_error_new(ret, "max connections");;
         }
     }
     
     // merge config: utc_time
     if (!srs_directive_equals(root->get("utc_time"), old_root->get("utc_time"))) {
-        if ((ret = do_reload_utc_time()) != ERROR_SUCCESS) {
-            return ret;
+        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 ((ret = do_reload_pithy_print_ms()) != ERROR_SUCCESS) {
-            return ret;
+            return srs_error_new(ret, "pithy print ms");;
         }
     }
     
     // merge config: http_api
     if ((ret = reload_http_api(old_root)) != ERROR_SUCCESS) {
-        return ret;
+        return srs_error_new(ret, "http api");;
     }
     
     // merge config: http_stream
     if ((ret = reload_http_stream(old_root)) != ERROR_SUCCESS) {
-        return ret;
+        return srs_error_new(ret, "http steram");;
     }
     
     // TODO: FIXME: support reload stream_caster.
     // TODO: FIXME: support reload kafka.
     
     // merge config: vhost
     if ((ret = reload_vhost(old_root)) != ERROR_SUCCESS) {
-        return ret;
+        return srs_error_new(ret, "vhost");;
     }
     
-    return ret;
+    return err;
 }
 
 int SrsConfig::reload_http_api(SrsConfDirective* old_root)
@@ -3015,28 +3015,28 @@ int SrsConfig::raw_set_max_connections(string max_connections, bool& applied)
     return ret;
 }
 
-int SrsConfig::raw_set_utc_time(string utc_time, bool& applied)
+srs_error_t SrsConfig::raw_set_utc_time(string utc_time, bool& applied)
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     applied = false;
     
     SrsConfDirective* conf = root->get_or_create("utc_time");
     
     if (conf->arg0() == utc_time) {
-        return ret;
+        return err;
     }
     
     conf->args.clear();
     conf->args.push_back(utc_time);
     
-    if ((ret = do_reload_utc_time()) != ERROR_SUCCESS) {
-        return ret;
+    if ((err = do_reload_utc_time()) != srs_success) {
+        return srs_error_wrap(err, "reload");
     }
     
     applied = true;
     
-    return ret;
+    return err;
 }
 
 int SrsConfig::raw_set_pithy_print_ms(string pithy_print_ms, bool& applied)
@@ -3307,21 +3307,20 @@ int SrsConfig::do_reload_max_connections()
     return ret;
 }
 
-int SrsConfig::do_reload_utc_time()
+srs_error_t SrsConfig::do_reload_utc_time()
 {
-    int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     vector<ISrsReloadHandler*>::iterator it;
     for (it = subscribes.begin(); it != subscribes.end(); ++it) {
         ISrsReloadHandler* subscribe = *it;
-        if ((ret = subscribe->on_reload_utc_time()) != ERROR_SUCCESS) {
-            srs_error("notify subscribes utc_time failed. ret=%d", ret);
-            return ret;
+        if ((err = subscribe->on_reload_utc_time()) != srs_success) {
+            return srs_error_wrap(err, "utc_time");
         }
     }
     srs_trace("reload utc_time success.");
     
-    return ret;
+    return err;
 }
 
 int SrsConfig::do_reload_pithy_print_ms()
diff --git a/trunk/src/app/srs_app_config.hpp b/trunk/src/app/srs_app_config.hpp
@@ -388,7 +388,7 @@ class SrsConfig
      * reload from the config.
      * @remark, use protected for the utest to override with mock.
      */
-    virtual int reload_conf(SrsConfig* conf);
+    virtual srs_error_t reload_conf(SrsConfig* conf);
 private:
     /**
      * reload the http_api section of config.
@@ -476,7 +476,7 @@ class SrsConfig
     /**
      * raw set the global whether use utc time.
      */
-    virtual int raw_set_utc_time(std::string utc_time, bool& applied);
+    virtual srs_error_t raw_set_utc_time(std::string utc_time, bool& applied);
     /**
      * raw set the global pithy print interval in ms.
      */
@@ -516,7 +516,7 @@ class SrsConfig
     virtual int do_reload_srs_log_level();
     virtual int do_reload_srs_log_file();
     virtual int do_reload_max_connections();
-    virtual int do_reload_utc_time();
+    virtual srs_error_t do_reload_utc_time();
     virtual int do_reload_pithy_print_ms();
     virtual int do_reload_vhost_added(std::string vhost);
     virtual int do_reload_vhost_removed(std::string vhost);
diff --git a/trunk/src/app/srs_app_http_api.cpp b/trunk/src/app/srs_app_http_api.cpp
@@ -85,6 +85,16 @@ int srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callback, int
     return srs_api_response_jsonp(w, callback, obj->dumps());
 }
 
+int srs_api_response_jsonp_code(ISrsHttpResponseWriter* w, string callback, srs_error_t err)
+{
+    SrsJsonObject* obj = SrsJsonAny::object();
+    SrsAutoFree(SrsJsonObject, obj);
+    
+    obj->set("code", SrsJsonAny::integer(srs_error_code(err)));
+    
+    return srs_api_response_jsonp(w, callback, obj->dumps());
+}
+
 int srs_api_response_json(ISrsHttpResponseWriter* w, string data)
 {
     SrsHttpHeader* h = w->header();
@@ -105,6 +115,16 @@ int srs_api_response_json_code(ISrsHttpResponseWriter* w, int code)
     return srs_api_response_json(w, obj->dumps());
 }
 
+int srs_api_response_json_code(ISrsHttpResponseWriter* w, srs_error_t err)
+{
+    SrsJsonObject* obj = SrsJsonAny::object();
+    SrsAutoFree(SrsJsonObject, obj);
+    
+    obj->set("code", SrsJsonAny::integer(srs_error_code(err)));
+    
+    return srs_api_response_json(w, obj->dumps());
+}
+
 int srs_api_response(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, std::string json)
 {
     // no jsonp, directly response.
@@ -129,6 +149,26 @@ int srs_api_response_code(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, int cod
     return srs_api_response_jsonp_code(w, callback, code);
 }
 
+int srs_api_response_code(ISrsHttpResponseWriter* w, ISrsHttpMessage* r, srs_error_t err)
+{
+    int ret = ERROR_SUCCESS;
+    
+    // no jsonp, directly response.
+    if (!r->is_jsonp()) {
+        ret = srs_api_response_json_code(w, err);
+    } else {
+        // jsonp, get function name from query("callback")
+        string callback = r->query_get("callback");
+        ret = srs_api_response_jsonp_code(w, callback, err);
+    }
+    
+    if (err != srs_success) {
+        srs_warn("error %s", srs_error_desc(err).c_str());
+        srs_freep(err);
+    }
+    return ret;
+}
+
 SrsGoApiRoot::SrsGoApiRoot()
 {
 }
@@ -852,6 +892,7 @@ SrsGoApiRaw::~SrsGoApiRaw()
 int SrsGoApiRaw::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
 {
     int ret = ERROR_SUCCESS;
+    srs_error_t err = srs_success;
     
     std::string rpc = r->query_get("rpc");
     
@@ -1126,9 +1167,8 @@ int SrsGoApiRaw::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
                 return srs_api_response_code(w, r, ret);
             }
             
-            if ((ret = _srs_config->raw_set_utc_time(srs_config_bool2switch(value), applied)) != ERROR_SUCCESS) {
-                srs_error("raw api update utc_time=%s failed. ret=%d", value.c_str(), ret);
-                return srs_api_response_code(w, r, ret);
+            if ((err = _srs_config->raw_set_utc_time(srs_config_bool2switch(value), applied)) != srs_success) {
+                return srs_api_response_code(w, r, srs_error_wrap(err, "raw api update utc_time=%s", value.c_str()));
             }
         } else if (scope == "pithy_print_ms") {
             int ppmv = ::atoi(value.c_str());
diff --git a/trunk/src/app/srs_app_log.cpp b/trunk/src/app/srs_app_log.cpp
@@ -199,11 +199,11 @@ void SrsFastLog::error(const char* tag, int context_id, const char* fmt, ...)
     write_log(fd, log_data, size, SrsLogLevelError);
 }
 
-int SrsFastLog::on_reload_utc_time()
+srs_error_t SrsFastLog::on_reload_utc_time()
 {
     utc = _srs_config->get_utc_time();
     
-    return ERROR_SUCCESS;
+    return srs_success;
 }
 
 int SrsFastLog::on_reload_log_tank()
diff --git a/trunk/src/app/srs_app_log.hpp b/trunk/src/app/srs_app_log.hpp
@@ -65,7 +65,7 @@ class SrsFastLog : public ISrsLog, public ISrsReloadHandler
     virtual void error(const char* tag, int context_id, const char* fmt, ...);
 // interface ISrsReloadHandler.
 public:
-    virtual int on_reload_utc_time();
+    virtual srs_error_t on_reload_utc_time();
     virtual int on_reload_log_tank();
     virtual int on_reload_log_level();
     virtual int on_reload_log_file();
diff --git a/trunk/src/app/srs_app_reload.cpp b/trunk/src/app/srs_app_reload.cpp
@@ -40,9 +40,9 @@ int ISrsReloadHandler::on_reload_listen()
     return ERROR_SUCCESS;
 }
 
-int ISrsReloadHandler::on_reload_utc_time()
+srs_error_t ISrsReloadHandler::on_reload_utc_time()
 {
-    return ERROR_SUCCESS;
+    return srs_success;
 }
 
 int ISrsReloadHandler::on_reload_max_conns()
diff --git a/trunk/src/app/srs_app_reload.hpp b/trunk/src/app/srs_app_reload.hpp
@@ -41,7 +41,7 @@ class ISrsReloadHandler
     ISrsReloadHandler();
     virtual ~ISrsReloadHandler();
 public:
-    virtual int on_reload_utc_time();
+    virtual srs_error_t on_reload_utc_time();
     virtual int on_reload_max_conns();
     virtual int on_reload_listen();
     virtual int on_reload_pid();
diff --git a/trunk/src/app/srs_app_server.cpp b/trunk/src/app/srs_app_server.cpp
@@ -150,7 +150,7 @@ srs_error_t SrsBufferListener::listen(string i, int p)
     listener = new SrsTcpListener(this, ip, port);
     
     if ((err = listener->listen()) != srs_success) {
-        return srs_error_wrap(err, "buffer tcp listen %s:%d", ip.c_str(), port);
+        return srs_error_wrap(err, "buffered tcp listen");
     }
     
     string v = srs_listener_type2string(type);
@@ -1227,7 +1227,8 @@ srs_error_t SrsServer::fd2conn(SrsListenerType type, srs_netfd_t stfd, SrsConnec
             fd, max_connections, (int)conns.size(), srs_error_desc(err).c_str());
     }
     if ((int)conns.size() >= max_connections) {
-        return srs_error_new(ERROR_EXCEED_CONNECTIONS, "drop fd=%d, max=%d, cur=%d for exceed connection limits",
+        return srs_error_new(ERROR_EXCEED_CONNECTIONS,
+            "drop fd=%d, max=%d, cur=%d for exceed connection limits",
             fd, max_connections, (int)conns.size());
     }
     
@@ -1278,8 +1279,7 @@ void SrsServer::remove(ISrsConnection* c)
     stat->kbps_add_delta(conn);
     stat->on_disconnect(conn->srs_id());
     
-    // all connections are created by server,
-    // so we free it here.
+    // use manager to free it async.
     conn_manager->remove(c);
 }
 
diff --git a/trunk/src/utest/srs_utest_reload.cpp b/trunk/src/utest/srs_utest_reload.cpp
@@ -285,16 +285,15 @@ MockSrsReloadConfig::~MockSrsReloadConfig()
 
 srs_error_t MockSrsReloadConfig::do_reload(string buf)
 {
-    int ret = ERROR_SUCCESS;
     srs_error_t err = srs_success;
     
     MockSrsReloadConfig conf;
     if ((err = conf.parse(buf)) != srs_success) {
         return srs_error_wrap(err, "parse");
     }
 
-    if ((ret = MockSrsConfig::reload_conf(&conf)) != ERROR_SUCCESS) {
-        return srs_error_new(ret, "reload conf");
+    if ((err = MockSrsConfig::reload_conf(&conf)) != srs_success) {
+        return srs_error_wrap(err, "reload conf");
     }
     
     return err;

Original file line number	Diff line number	Diff line change
`@@ -1195,7 +1195,6 @@ void SrsConfig::unsubscribe(ISrsReloadHandler* handler)`
`1195`	`1195`
`1196`	`1196`	`srs_error_t SrsConfig::reload()`
`1197`	`1197`	`{`
`1198`		`- int ret = ERROR_SUCCESS;`
`1199`	`1198`	`srs_error_t err = srs_success;`
`1200`	`1199`
`1201`	`1200`	`SrsConfig conf;`
`@@ -1214,8 +1213,8 @@ srs_error_t SrsConfig::reload()`
`1214`	`1213`	`return srs_error_wrap(err, "check config");`
`1215`	`1214`	`}`
`1216`	`1215`
`1217`		`- if ((ret = reload_conf(&conf)) != ERROR_SUCCESS) {`
`1218`		`- return srs_error_new(ret, "reload config");`
	`1216`	`+ if ((err = reload_conf(&conf)) != srs_success) {`
	`1217`	`+ return srs_error_wrap(err, "reload config");`
`1219`	`1218`	`}`
`1220`	`1219`
`1221`	`1220`	`return err;`
`@@ -1485,9 +1484,10 @@ int SrsConfig::reload_vhost(SrsConfDirective* old_root)`
`1485`	`1484`	`return ret;`
`1486`	`1485`	`}`
`1487`	`1486`
`1488`		`-int SrsConfig::reload_conf(SrsConfig* conf)`
	`1487`	`+srs_error_t SrsConfig::reload_conf(SrsConfig* conf)`
`1489`	`1488`	`{`
`1490`	`1489`	`int ret = ERROR_SUCCESS;`
	`1490`	`+ srs_error_t err = srs_success;`
`1491`	`1491`
`1492`	`1492`	`SrsConfDirective* old_root = root;`
`1493`	`1493`	`SrsAutoFree(SrsConfDirective, old_root);`
`@@ -1509,78 +1509,78 @@ int SrsConfig::reload_conf(SrsConfig* conf)`
`1509`	`1509`	`// merge config: listen`
`1510`	`1510`	`if (!srs_directive_equals(root->get("listen"), old_root->get("listen"))) {`
`1511`	`1511`	`if ((ret = do_reload_listen()) != ERROR_SUCCESS) {`
`1512`		`- return ret;`
	`1512`	`+ return srs_error_new(ret, "listen");`
`1513`	`1513`	`}`
`1514`	`1514`	`}`
`1515`	`1515`
`1516`	`1516`	`// merge config: pid`
`1517`	`1517`	`if (!srs_directive_equals(root->get("pid"), old_root->get("pid"))) {`
`1518`	`1518`	`if ((ret = do_reload_pid()) != ERROR_SUCCESS) {`
`1519`		`- return ret;`
	`1519`	`+ return srs_error_new(ret, "pid");;`
`1520`	`1520`	`}`
`1521`	`1521`	`}`
`1522`	`1522`
`1523`	`1523`	`// merge config: srs_log_tank`
`1524`	`1524`	`if (!srs_directive_equals(root->get("srs_log_tank"), old_root->get("srs_log_tank"))) {`
`1525`	`1525`	`if ((ret = do_reload_srs_log_tank()) != ERROR_SUCCESS) {`
`1526`		`- return ret;`
	`1526`	`+ return srs_error_new(ret, "log tank");;`
`1527`	`1527`	`}`
`1528`	`1528`	`}`
`1529`	`1529`
`1530`	`1530`	`// merge config: srs_log_level`
`1531`	`1531`	`if (!srs_directive_equals(root->get("srs_log_level"), old_root->get("srs_log_level"))) {`
`1532`	`1532`	`if ((ret = do_reload_srs_log_level()) != ERROR_SUCCESS) {`
`1533`		`- return ret;`
	`1533`	`+ return srs_error_new(ret, "log level");;`
`1534`	`1534`	`}`
`1535`	`1535`	`}`
`1536`	`1536`
`1537`	`1537`	`// merge config: srs_log_file`
`1538`	`1538`	`if (!srs_directive_equals(root->get("srs_log_file"), old_root->get("srs_log_file"))) {`
`1539`	`1539`	`if ((ret = do_reload_srs_log_file()) != ERROR_SUCCESS) {`
`1540`		`- return ret;`
	`1540`	`+ return srs_error_new(ret, "log file");;`
`1541`	`1541`	`}`
`1542`	`1542`	`}`
`1543`	`1543`
`1544`	`1544`	`// merge config: max_connections`
`1545`	`1545`	`if (!srs_directive_equals(root->get("max_connections"), old_root->get("max_connections"))) {`
`1546`	`1546`	`if ((ret = do_reload_max_connections()) != ERROR_SUCCESS) {`
`1547`		`- return ret;`
	`1547`	`+ return srs_error_new(ret, "max connections");;`
`1548`	`1548`	`}`
`1549`	`1549`	`}`
`1550`	`1550`
`1551`	`1551`	`// merge config: utc_time`
`1552`	`1552`	`if (!srs_directive_equals(root->get("utc_time"), old_root->get("utc_time"))) {`
`1553`		`- if ((ret = do_reload_utc_time()) != ERROR_SUCCESS) {`
`1554`		`- return ret;`
	`1553`	`+ if ((err = do_reload_utc_time()) != srs_success) {`
	`1554`	`+ return srs_error_wrap(err, "utc time");;`
`1555`	`1555`	`}`
`1556`	`1556`	`}`
`1557`	`1557`
`1558`	`1558`	`// merge config: pithy_print_ms`
`1559`	`1559`	`if (!srs_directive_equals(root->get("pithy_print_ms"), old_root->get("pithy_print_ms"))) {`
`1560`	`1560`	`if ((ret = do_reload_pithy_print_ms()) != ERROR_SUCCESS) {`
`1561`		`- return ret;`
	`1561`	`+ return srs_error_new(ret, "pithy print ms");;`
`1562`	`1562`	`}`
`1563`	`1563`	`}`
`1564`	`1564`
`1565`	`1565`	`// merge config: http_api`
`1566`	`1566`	`if ((ret = reload_http_api(old_root)) != ERROR_SUCCESS) {`
`1567`		`- return ret;`
	`1567`	`+ return srs_error_new(ret, "http api");;`
`1568`	`1568`	`}`
`1569`	`1569`
`1570`	`1570`	`// merge config: http_stream`
`1571`	`1571`	`if ((ret = reload_http_stream(old_root)) != ERROR_SUCCESS) {`
`1572`		`- return ret;`
	`1572`	`+ return srs_error_new(ret, "http steram");;`
`1573`	`1573`	`}`
`1574`	`1574`
`1575`	`1575`	`// TODO: FIXME: support reload stream_caster.`
`1576`	`1576`	`// TODO: FIXME: support reload kafka.`
`1577`	`1577`
`1578`	`1578`	`// merge config: vhost`
`1579`	`1579`	`if ((ret = reload_vhost(old_root)) != ERROR_SUCCESS) {`
`1580`		`- return ret;`
	`1580`	`+ return srs_error_new(ret, "vhost");;`
`1581`	`1581`	`}`
`1582`	`1582`
`1583`		`- return ret;`
	`1583`	`+ return err;`
`1584`	`1584`	`}`
`1585`	`1585`
`1586`	`1586`	`int SrsConfig::reload_http_api(SrsConfDirective* old_root)`
`@@ -3015,28 +3015,28 @@ int SrsConfig::raw_set_max_connections(string max_connections, bool& applied)`
`3015`	`3015`	`return ret;`
`3016`	`3016`	`}`
`3017`	`3017`
`3018`		`-int SrsConfig::raw_set_utc_time(string utc_time, bool& applied)`
	`3018`	`+srs_error_t SrsConfig::raw_set_utc_time(string utc_time, bool& applied)`
`3019`	`3019`	`{`
`3020`		`- int ret = ERROR_SUCCESS;`
	`3020`	`+ srs_error_t err = srs_success;`
`3021`	`3021`
`3022`	`3022`	`applied = false;`
`3023`	`3023`
`3024`	`3024`	`SrsConfDirective* conf = root->get_or_create("utc_time");`
`3025`	`3025`
`3026`	`3026`	`if (conf->arg0() == utc_time) {`
`3027`		`- return ret;`
	`3027`	`+ return err;`
`3028`	`3028`	`}`
`3029`	`3029`
`3030`	`3030`	`conf->args.clear();`
`3031`	`3031`	`conf->args.push_back(utc_time);`
`3032`	`3032`
`3033`		`- if ((ret = do_reload_utc_time()) != ERROR_SUCCESS) {`
`3034`		`- return ret;`
	`3033`	`+ if ((err = do_reload_utc_time()) != srs_success) {`
	`3034`	`+ return srs_error_wrap(err, "reload");`
`3035`	`3035`	`}`
`3036`	`3036`
`3037`	`3037`	`applied = true;`
`3038`	`3038`
`3039`		`- return ret;`
	`3039`	`+ return err;`
`3040`	`3040`	`}`
`3041`	`3041`
`3042`	`3042`	`int SrsConfig::raw_set_pithy_print_ms(string pithy_print_ms, bool& applied)`
`@@ -3307,21 +3307,20 @@ int SrsConfig::do_reload_max_connections()`
`3307`	`3307`	`return ret;`
`3308`	`3308`	`}`
`3309`	`3309`
`3310`		`-int SrsConfig::do_reload_utc_time()`
	`3310`	`+srs_error_t SrsConfig::do_reload_utc_time()`
`3311`	`3311`	`{`
`3312`		`- int ret = ERROR_SUCCESS;`
	`3312`	`+ srs_error_t err = srs_success;`
`3313`	`3313`
`3314`	`3314`	`vector<ISrsReloadHandler*>::iterator it;`
`3315`	`3315`	`for (it = subscribes.begin(); it != subscribes.end(); ++it) {`
`3316`	`3316`	`ISrsReloadHandler* subscribe = *it;`
`3317`		`- if ((ret = subscribe->on_reload_utc_time()) != ERROR_SUCCESS) {`
`3318`		`- srs_error("notify subscribes utc_time failed. ret=%d", ret);`
`3319`		`- return ret;`
	`3317`	`+ if ((err = subscribe->on_reload_utc_time()) != srs_success) {`
	`3318`	`+ return srs_error_wrap(err, "utc_time");`
`3320`	`3319`	`}`
`3321`	`3320`	`}`
`3322`	`3321`	`srs_trace("reload utc_time success.");`
`3323`	`3322`
`3324`		`- return ret;`
	`3323`	`+ return err;`
`3325`	`3324`	`}`
`3326`	`3325`
`3327`	`3326`	`int SrsConfig::do_reload_pithy_print_ms()`
Original file line number	Diff line number	Diff line change
`@@ -199,11 +199,11 @@ void SrsFastLog::error(const char* tag, int context_id, const char* fmt, ...)`
`199`	`199`	`write_log(fd, log_data, size, SrsLogLevelError);`
`200`	`200`	`}`
`201`	`201`
`202`		`-int SrsFastLog::on_reload_utc_time()`
	`202`	`+srs_error_t SrsFastLog::on_reload_utc_time()`
`203`	`203`	`{`
`204`	`204`	`utc = _srs_config->get_utc_time();`
`205`	`205`
`206`		`- return ERROR_SUCCESS;`
	`206`	`+ return srs_success;`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`int SrsFastLog::on_reload_log_tank()`
Original file line number	Diff line number	Diff line change
`@@ -40,9 +40,9 @@ int ISrsReloadHandler::on_reload_listen()`
`40`	`40`	`return ERROR_SUCCESS;`
`41`	`41`	`}`
`42`	`42`
`43`		`-int ISrsReloadHandler::on_reload_utc_time()`
	`43`	`+srs_error_t ISrsReloadHandler::on_reload_utc_time()`
`44`	`44`	`{`
`45`		`- return ERROR_SUCCESS;`
	`45`	`+ return srs_success;`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`int ISrsReloadHandler::on_reload_max_conns()`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ srs_error_t SrsBufferListener::listen(string i, int p)`
`150`	`150`	`listener = new SrsTcpListener(this, ip, port);`
`151`	`151`
`152`	`152`	`if ((err = listener->listen()) != srs_success) {`
`153`		`- return srs_error_wrap(err, "buffer tcp listen %s:%d", ip.c_str(), port);`
	`153`	`+ return srs_error_wrap(err, "buffered tcp listen");`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`string v = srs_listener_type2string(type);`
`@@ -1227,7 +1227,8 @@ srs_error_t SrsServer::fd2conn(SrsListenerType type, srs_netfd_t stfd, SrsConnec`
`1227`	`1227`	`fd, max_connections, (int)conns.size(), srs_error_desc(err).c_str());`
`1228`	`1228`	`}`
`1229`	`1229`	`if ((int)conns.size() >= max_connections) {`
`1230`		`- return srs_error_new(ERROR_EXCEED_CONNECTIONS, "drop fd=%d, max=%d, cur=%d for exceed connection limits",`
	`1230`	`+ return srs_error_new(ERROR_EXCEED_CONNECTIONS,`
	`1231`	`+ "drop fd=%d, max=%d, cur=%d for exceed connection limits",`
`1231`	`1232`	`fd, max_connections, (int)conns.size());`
`1232`	`1233`	`}`
`1233`	`1234`
`@@ -1278,8 +1279,7 @@ void SrsServer::remove(ISrsConnection* c)`
`1278`	`1279`	`stat->kbps_add_delta(conn);`
`1279`	`1280`	`stat->on_disconnect(conn->srs_id());`
`1280`	`1281`
`1281`		`- // all connections are created by server,`
`1282`		`- // so we free it here.`
	`1282`	`+ // use manager to free it async.`
`1283`	`1283`	`conn_manager->remove(c);`
`1284`	`1284`	`}`
`1285`	`1285`
Original file line number	Diff line number	Diff line change
`@@ -285,16 +285,15 @@ MockSrsReloadConfig::~MockSrsReloadConfig()`
`285`	`285`
`286`	`286`	`srs_error_t MockSrsReloadConfig::do_reload(string buf)`
`287`	`287`	`{`
`288`		`- int ret = ERROR_SUCCESS;`
`289`	`288`	`srs_error_t err = srs_success;`
`290`	`289`
`291`	`290`	`MockSrsReloadConfig conf;`
`292`	`291`	`if ((err = conf.parse(buf)) != srs_success) {`
`293`	`292`	`return srs_error_wrap(err, "parse");`
`294`	`293`	`}`
`295`	`294`
`296`		`- if ((ret = MockSrsConfig::reload_conf(&conf)) != ERROR_SUCCESS) {`
`297`		`- return srs_error_new(ret, "reload conf");`
	`295`	`+ if ((err = MockSrsConfig::reload_conf(&conf)) != srs_success) {`
	`296`	`+ return srs_error_wrap(err, "reload conf");`
`298`	`297`	`}`
`299`	`298`
`300`	`299`	`return err;`