support reload http_api

trunk/src/app/srs_app_config.cpp

@@ -568,81 +568,157 @@ int SrsConfig::reload()
         srs_trace("reload pithy_print success.");
     }
     
-    // merge config: vhost added
+    // merge config: http_api
-    for (int i = 0; i < (int)root->directives.size(); i++) {
+    if ((ret = reload_http_api(old_root)) != ERROR_SUCCESS) {
-        // ingest need to start if specified.
+        return ret;
-        // other features, directly supported.
+    }
-        SrsConfDirective* new_vhost = root->at(i);
 
-        // only process vhost directives.
+    // merge config: vhost
-        if (new_vhost->name != "vhost") {
+    if ((ret = reload_vhost(old_root)) != ERROR_SUCCESS) {
-            continue;
+        return ret;
-        }
+    }
     
-        std::string vhost = new_vhost->arg0();
+    return ret;
+}
 
-        // not new added vhost, ignore.
+int SrsConfig::reload_http_api(SrsConfDirective* old_root)
-        if (old_root->get("vhost", vhost)) {
+{
-            continue;
+    int ret = ERROR_SUCCESS;
-        }
     
-        srs_trace("vhost %s added, reload it.", vhost.c_str());
+    // merge config.
+    std::vector<ISrsReloadHandler*>::iterator it;
+    
+    // state graph
+    //      old_http_api    new_http_api
+    //      DISABLED    =>  ENABLED
+    //      ENABLED     =>  DISABLED
+    //      ENABLED     =>  ENABLED (modified)
+    
+    SrsConfDirective* new_http_api = root->get("http_api");
+    SrsConfDirective* old_http_api = old_root->get("http_api");
+
+    // DISABLED    =>      ENABLED
+    if (!get_http_api_enabled(old_http_api) && get_http_api_enabled(new_http_api)) {
         for (it = subscribes.begin(); it != subscribes.end(); ++it) {
             ISrsReloadHandler* subscribe = *it;
-            if ((ret = subscribe->on_reload_vhost_added(vhost)) != ERROR_SUCCESS) {
+            if ((ret = subscribe->on_reload_http_api_enabled()) != ERROR_SUCCESS) {
-                srs_error("notify subscribes pithy_print remove "
+                srs_error("notify subscribes http_api disabled=>enabled failed. ret=%d", ret);
-                    "vhost %s failed. ret=%d", vhost.c_str(), ret);
                 return ret;
             }
         }
-        srs_trace("reload new vhost %s success.", vhost.c_str());
+        srs_trace("reload disabled=>enabled http_api success.");
+        
+        return ret;
     }
 
-    // merge config: vhost removed/disabled/modified.
+    // ENABLED     =>      DISABLED
+    if (get_http_api_enabled(old_http_api) && !get_http_api_enabled(new_http_api)) {
+        for (it = subscribes.begin(); it != subscribes.end(); ++it) {
+            ISrsReloadHandler* subscribe = *it;
+            if ((ret = subscribe->on_reload_http_api_disabled()) != ERROR_SUCCESS) {
+                srs_error("notify subscribes http_api enabled=>disabled failed. ret=%d", ret);
+                return ret;
+            }
+        }
+        srs_trace("reload enabled=>disabled http_api success.");
+        
+        return ret;
+    }
+    
+    //      ENABLED     =>  ENABLED (modified)
+    if (get_http_api_enabled(old_http_api) && get_http_api_enabled(new_http_api)
+        && !srs_directive_equals(old_http_api, new_http_api)
+    ) {
+        for (it = subscribes.begin(); it != subscribes.end(); ++it) {
+            ISrsReloadHandler* subscribe = *it;
+            if ((ret = subscribe->on_reload_http_api_enabled()) != ERROR_SUCCESS) {
+                srs_error("notify subscribes http_api enabled modified failed. ret=%d", ret);
+                return ret;
+            }
+        }
+        srs_trace("reload enabled modified http_api success.");
+        
+        return ret;
+    }
+    
+    srs_trace("reload http_api not changed success.");
+    
+    return ret;
+}
+
+int SrsConfig::reload_vhost(SrsConfDirective* old_root)
+{
+    int ret = ERROR_SUCCESS;
+    
+    // merge config.
+    std::vector<ISrsReloadHandler*>::iterator it;
+    
+    // state graph
+    //      old_vhost       new_vhost
+    //      DISABLED    =>  ENABLED
+    //      ENABLED     =>  DISABLED
+    //      ENABLED     =>  ENABLED (modified)
+
+    // collect all vhost names
+    std::vector<std::string> vhosts;
+    for (int i = 0; i < (int)root->directives.size(); i++) {
+        SrsConfDirective* vhost = root->at(i);
+        if (vhost->name != "vhost") {
+            continue;
+        }
+        vhosts.push_back(vhost->arg0());
+    }
     for (int i = 0; i < (int)old_root->directives.size(); i++) {
-        SrsConfDirective* old_vhost = old_root->at(i);
+        SrsConfDirective* vhost = old_root->at(i);
-        // only process vhost directives.
+        if (vhost->name != "vhost") {
-        if (old_vhost->name != "vhost") {
             continue;
         }
+        if (root->get("vhost", vhost->arg0())) {
+            continue;
+        }
+        vhosts.push_back(vhost->arg0());
+    }
     
-        std::string vhost = old_vhost->arg0();
+    // process each vhost
+    for (int i = 0; i < (int)vhosts.size(); i++) {
+        std::string vhost = vhosts.at(i);
 
+        SrsConfDirective* old_vhost = old_root->get("vhost", vhost);
         SrsConfDirective* new_vhost = root->get("vhost", vhost);
-        // ignore if absolutely equal
-        if (new_vhost && srs_directive_equals(old_vhost, new_vhost)) {
-            srs_trace("vhost %s absolutely equal, ignore.", vhost.c_str());
-            continue;
-        }
-        // ignore if enable the new vhost when old vhost is disabled.
-        if (get_vhost_enabled(new_vhost) && !get_vhost_enabled(old_vhost)) {
-            srs_trace("vhost %s disabled=>enabled, ignore.", vhost.c_str());
-            continue;
-        }
-        // ignore if both old and new vhost are disabled.
-        if (!get_vhost_enabled(new_vhost) && !get_vhost_enabled(old_vhost)) {
-            srs_trace("vhost %s disabled=>disabled, ignore.", vhost.c_str());
-            continue;
-        }
         
-        // merge config: vhost removed/disabled.
+        //      DISABLED    =>  ENABLED
-        if (!get_vhost_enabled(new_vhost) && get_vhost_enabled(old_vhost)) {
+        if (!get_vhost_enabled(old_vhost) && get_vhost_enabled(new_vhost)) {
-            srs_trace("vhost %s disabled, reload it.", vhost.c_str());
+            srs_trace("vhost %s added, reload it.", vhost.c_str());
             for (it = subscribes.begin(); it != subscribes.end(); ++it) {
                 ISrsReloadHandler* subscribe = *it;
-                if ((ret = subscribe->on_reload_vhost_removed(vhost)) != ERROR_SUCCESS) {
+                if ((ret = subscribe->on_reload_vhost_added(vhost)) != ERROR_SUCCESS) {
-                    srs_error("notify subscribes pithy_print remove "
+                    srs_error("notify subscribes added "
                         "vhost %s failed. ret=%d", vhost.c_str(), ret);
                     return ret;
                 }
             }
-            srs_trace("reload remove vhost %s success.", vhost.c_str());
+            srs_trace("reload new vhost %s success.", vhost.c_str());
             continue;
         }
         
-        // merge config: vhost modified.
+        //      ENABLED     =>  DISABLED
-        srs_trace("vhost %s modified, reload its detail.", vhost.c_str());
+        if (get_vhost_enabled(old_vhost) && !get_vhost_enabled(new_vhost)) {
+            srs_trace("vhost %s removed, reload it.", vhost.c_str());
+            for (it = subscribes.begin(); it != subscribes.end(); ++it) {
+                ISrsReloadHandler* subscribe = *it;
+                if ((ret = subscribe->on_reload_vhost_removed(vhost)) != ERROR_SUCCESS) {
+                    srs_error("notify subscribes removed "
+                        "vhost %s failed. ret=%d", vhost.c_str(), ret);
+                    return ret;
+                }
+            }
+            srs_trace("reload removed vhost %s success.", vhost.c_str());
+            continue;
+        }
+    
+        //      ENABLED     =>  ENABLED (modified)
         if (get_vhost_enabled(new_vhost) && get_vhost_enabled(old_vhost)) {
+            srs_trace("vhost %s modified, reload its detail.", vhost.c_str());
             // atc, only one per vhost
             if (!srs_directive_equals(new_vhost->get("atc"), old_vhost->get("atc"))) {
                 for (it = subscribes.begin(); it != subscribes.end(); ++it) {
@@ -706,10 +782,9 @@ int SrsConfig::reload()
             if ((ret = reload_ingest(new_vhost, old_vhost)) != ERROR_SUCCESS) {
                 return ret;
             }
-            // TODO: suppor reload hls/forward/ffmpeg/http
             continue;
         }
-        srs_warn("invalid reload path, enabled old: %d, new: %d", 
+        srs_trace("igreno reload vhost, enabled old: %d, new: %d", 
             get_vhost_enabled(old_vhost), get_vhost_enabled(new_vhost));
     }
     
@@ -2116,7 +2191,11 @@ SrsConfDirective* SrsConfig::get_http_api()
 bool SrsConfig::get_http_api_enabled()
 {
     SrsConfDirective* conf = get_http_api();
+    return get_http_api_enabled(conf);
+}
 
+bool SrsConfig::get_http_api_enabled(SrsConfDirective* conf)
+{
     if (!conf) {
         return false;
     }

trunk/src/app/srs_app_config.hpp

@@ -124,6 +124,8 @@ public:
     virtual void unsubscribe(ISrsReloadHandler* handler);
     virtual int reload();
 private:
+    virtual int reload_http_api(SrsConfDirective* old_root);
+    virtual int reload_vhost(SrsConfDirective* old_root);
     virtual int reload_transcode(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost);
     virtual int reload_ingest(SrsConfDirective* new_vhost, SrsConfDirective* old_vhost);
 // parse options and file
@@ -222,6 +224,7 @@ private:
     virtual SrsConfDirective*   get_http_api();
 public:
     virtual bool                get_http_api_enabled();
+    virtual bool                get_http_api_enabled(SrsConfDirective* conf);
     virtual int                 get_http_api_listen();
 // http stream section
 private:

trunk/src/app/srs_app_reload.cpp

@@ -65,6 +65,16 @@ int ISrsReloadHandler::on_reload_pithy_print()
     return ERROR_SUCCESS;
 }
 
+int ISrsReloadHandler::on_reload_http_api_enabled()
+{
+    return ERROR_SUCCESS;
+}
+
+int ISrsReloadHandler::on_reload_http_api_disabled()
+{
+    return ERROR_SUCCESS;
+}
+
 int ISrsReloadHandler::on_reload_vhost_added(string /*vhost*/)
 {
     return ERROR_SUCCESS;

trunk/src/app/srs_app_reload.hpp

@@ -47,6 +47,8 @@ public:
     virtual int on_reload_log_level();
     virtual int on_reload_log_file();
     virtual int on_reload_pithy_print();
+    virtual int on_reload_http_api_enabled();
+    virtual int on_reload_http_api_disabled();
     virtual int on_reload_vhost_added(std::string vhost);
     virtual int on_reload_vhost_removed(std::string vhost);
     virtual int on_reload_atc(std::string vhost);

trunk/src/app/srs_app_server.cpp

@@ -617,3 +617,17 @@ int SrsServer::on_reload_pid()
     
     return acquire_pid_file();
 }
+
+int SrsServer::on_reload_http_api_enabled()
+{
+    return listen_http_api();
+}
+
+int SrsServer::on_reload_http_api_disabled()
+{
+    int ret = ERROR_SUCCESS;
+    
+    close_listeners(SrsListenerHttpApi);
+    
+    return ret;
+}

trunk/src/app/srs_app_server.hpp

@@ -116,6 +116,8 @@ private:
 public:
     virtual int on_reload_listen();
     virtual int on_reload_pid();
+    virtual int on_reload_http_api_enabled();
+    virtual int on_reload_http_api_disabled();
 };
 
 #endif