Merge SRT

trunk/src/app/srs_app_config.cpp

@@ -479,7 +479,7 @@ srs_error_t srs_config_transform_vhost(SrsConfDirective* root)
                 ++it;
                 continue;
             }
-            
+
             // SRS3.0, change the folowing like a shadow:
             //      mode, origin, token_traverse, vhost, debug_srs_upnode
             //  SRS1/2:
@@ -3470,7 +3470,7 @@ srs_error_t SrsConfig::check_normal_config()
             && n != "srs_log_tank" && n != "srs_log_level" && n != "srs_log_file"
             && n != "max_connections" && n != "daemon" && n != "heartbeat"
             && n != "http_api" && n != "stats" && n != "vhost" && n != "pithy_print_ms"
-            && n != "http_server" && n != "stream_caster"
+            && n != "http_server" && n != "stream_caster" && n != "srt_server"
             && n != "utc_time" && n != "work_dir" && n != "asprocess"
             ) {
             return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "illegal directive %s", n.c_str());
@@ -3504,6 +3504,15 @@ srs_error_t SrsConfig::check_normal_config()
             }
         }
     }
+    if (true) {
+        SrsConfDirective* conf = root->get("srt_server");
+        for (int i = 0; conf && i < (int)conf->directives.size(); i++) {
+            string n = conf->at(i)->name;
+            if (n != "enabled" && n != "listen") {
+                return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "illegal srt_stream.%s", n.c_str());
+            }
+        }
+    }
     if (true) {
         SrsConfDirective* conf = get_heartbeart();
         for (int i = 0; conf && i < (int)conf->directives.size(); i++) {
@@ -3631,6 +3640,7 @@ srs_error_t SrsConfig::check_normal_config()
     get_vhosts(vhosts);
     for (int n = 0; n < (int)vhosts.size(); n++) {
         SrsConfDirective* vhost = vhosts[n];
+
         for (int i = 0; vhost && i < (int)vhost->directives.size(); i++) {
             SrsConfDirective* conf = vhost->at(i);
             string n = conf->name;
@@ -6629,6 +6639,39 @@ bool SrsConfig::get_raw_api_allow_update()
     return SRS_CONF_PERFER_FALSE(conf->arg0());
 }
 
+
+bool SrsConfig::get_srt_enabled()
+{
+    static bool DEFAULT = false;
+    
+    SrsConfDirective* conf = root->get("srt_server");
+    if (!conf) {
+        return DEFAULT;
+    }
+    
+    conf = conf->get("enabled");
+    if (!conf || conf->arg0().empty()) {
+        return DEFAULT;
+    }
+    
+    return SRS_CONF_PERFER_FALSE(conf->arg0());
+}
+
+unsigned short SrsConfig::get_srt_listen_port()
+{
+    static unsigned short DEFAULT = 10080;
+    SrsConfDirective* conf = root->get("srt_server");
+    if (!conf) {
+        return DEFAULT;
+    }
+    
+    conf = conf->get("listen");
+    if (!conf || conf->arg0().empty()) {
+        return DEFAULT;
+    }
+    return (unsigned short)atoi(conf->arg0().c_str());
+}
+
 bool SrsConfig::get_http_stream_enabled()
 {
     SrsConfDirective* conf = root->get("http_server");

trunk/src/app/srs_app_config.hpp

@@ -588,6 +588,13 @@ public:
     virtual bool get_forward_enabled(std::string vhost);
     // Get the forward directive of vhost.
     virtual SrsConfDirective* get_forwards(std::string vhost);
+
+public:
+    // Whether the srt sevice enabled
+    virtual bool get_srt_enabled();
+    // Get the srt service listen port
+    virtual unsigned short get_srt_listen_port();
+
 // http_hooks section
 private:
     // Get the http_hooks directive of vhost.

trunk/src/app/srs_app_hybrid.cpp

@@ -0,0 +1,185 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2020 Winlin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <srs_app_hybrid.hpp>
+
+#include <srs_app_server.hpp>
+#include <srs_app_config.hpp>
+#include <srs_kernel_error.hpp>
+#include <srs_service_st.hpp>
+
+using namespace std;
+
+ISrsHybridServer::ISrsHybridServer()
+{
+}
+
+ISrsHybridServer::~ISrsHybridServer()
+{
+}
+
+SrsServerAdapter::SrsServerAdapter()
+{
+    srs = new SrsServer();
+}
+
+SrsServerAdapter::~SrsServerAdapter()
+{
+    srs_freep(srs);
+}
+
+srs_error_t SrsServerAdapter::initialize()
+{
+    srs_error_t err = srs_success;
+    return err;
+}
+
+srs_error_t SrsServerAdapter::run()
+{
+    srs_error_t err = srs_success;
+
+    // Initialize the whole system, set hooks to handle server level events.
+    if ((err = srs->initialize(NULL)) != srs_success) {
+        return srs_error_wrap(err, "server initialize");
+    }
+
+    if ((err = srs->initialize_st()) != srs_success) {
+        return srs_error_wrap(err, "initialize st");
+    }
+
+    if ((err = srs->acquire_pid_file()) != srs_success) {
+        return srs_error_wrap(err, "acquire pid file");
+    }
+
+    if ((err = srs->initialize_signal()) != srs_success) {
+        return srs_error_wrap(err, "initialize signal");
+    }
+
+    if ((err = srs->listen()) != srs_success) {
+        return srs_error_wrap(err, "listen");
+    }
+
+    if ((err = srs->register_signal()) != srs_success) {
+        return srs_error_wrap(err, "register signal");
+    }
+
+    if ((err = srs->http_handle()) != srs_success) {
+        return srs_error_wrap(err, "http handle");
+    }
+
+    if ((err = srs->ingest()) != srs_success) {
+        return srs_error_wrap(err, "ingest");
+    }
+
+    if ((err = srs->cycle()) != srs_success) {
+        return srs_error_wrap(err, "main cycle");
+    }
+
+    return err;
+}
+
+void SrsServerAdapter::stop()
+{
+}
+
+SrsHybridServer::SrsHybridServer()
+{
+}
+
+SrsHybridServer::~SrsHybridServer()
+{
+    vector<ISrsHybridServer*>::iterator it;
+    for (it = servers.begin(); it != servers.end(); ++it) {
+        ISrsHybridServer* server = *it;
+        srs_freep(server);
+    }
+    servers.clear();
+}
+
+void SrsHybridServer::register_server(ISrsHybridServer* svr)
+{
+    servers.push_back(svr);
+}
+
+srs_error_t SrsHybridServer::initialize()
+{
+    srs_error_t err = srs_success;
+
+    // init st
+    if ((err = srs_st_init()) != srs_success) {
+        return srs_error_wrap(err, "initialize st failed");
+    }
+
+    vector<ISrsHybridServer*>::iterator it;
+    for (it = servers.begin(); it != servers.end(); ++it) {
+        ISrsHybridServer* server = *it;
+
+        if ((err = server->initialize()) != srs_success) {
+            return srs_error_wrap(err, "init server");
+        }
+    }
+
+    return err;
+}
+
+srs_error_t SrsHybridServer::run()
+{
+    srs_error_t err = srs_success;
+
+    // Run master server in this main thread.
+    SrsServerAdapter* master_server = NULL;
+
+    vector<ISrsHybridServer*>::iterator it;
+    for (it = servers.begin(); it != servers.end(); ++it) {
+        ISrsHybridServer* server = *it;
+
+        if (!master_server) {
+            master_server = dynamic_cast<SrsServerAdapter*>(server);
+            if (master_server) {
+                continue;
+            }
+        }
+
+        if ((err = server->run()) != srs_success) {
+            return srs_error_wrap(err, "run server");
+        }
+    }
+
+    if (master_server) {
+        return master_server->run();
+    }
+
+    return err;
+}
+
+void SrsHybridServer::stop()
+{
+    vector<ISrsHybridServer*>::iterator it;
+    for (it = servers.begin(); it != servers.end(); ++it) {
+        ISrsHybridServer* server = *it;
+        server->stop();
+    }
+}
+
+SrsHybridServer* _srs_hybrid = new SrsHybridServer();
+

trunk/src/app/srs_app_hybrid.hpp

@@ -0,0 +1,80 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2020 Winlin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef SRS_APP_HYBRID_HPP
+#define SRS_APP_HYBRID_HPP
+
+#include <srs_core.hpp>
+
+#include <vector>
+
+class SrsServer;
+
+// The hibrid server interfaces, we could register many servers.
+class ISrsHybridServer
+{
+public:
+    ISrsHybridServer();
+    virtual ~ISrsHybridServer();
+public:
+    // Only ST initialized before each server, we could fork processes as such.
+    virtual srs_error_t initialize() = 0;
+    // Run each server, should never block except the SRS master server.
+    virtual srs_error_t run() = 0;
+    // Stop each server, should do cleanup, for example, kill processes forked by server.
+    virtual void stop() = 0;
+};
+
+// The SRS server adapter, the master server.
+class SrsServerAdapter : public ISrsHybridServer
+{
+private:
+    SrsServer* srs;
+public:
+    SrsServerAdapter();
+    virtual ~SrsServerAdapter();
+public:
+    virtual srs_error_t initialize();
+    virtual srs_error_t run();
+    virtual void stop();
+};
+
+// The hybrid server manager.
+class SrsHybridServer
+{
+private:
+    std::vector<ISrsHybridServer*> servers;
+public:
+    SrsHybridServer();
+    virtual ~SrsHybridServer();
+public:
+    virtual void register_server(ISrsHybridServer* svr);
+public:
+    virtual srs_error_t initialize();
+    virtual srs_error_t run();
+    virtual void stop();
+};
+
+extern SrsHybridServer* _srs_hybrid;
+
+#endif

trunk/src/app/srs_app_server.cpp

@@ -565,11 +565,6 @@ srs_error_t SrsServer::initialize_st()
 {
     srs_error_t err = srs_success;
     
-    // init st
-    if ((err = srs_st_init()) != srs_success) {
-        return srs_error_wrap(err, "initialize st failed");
-    }
-    
     // @remark, st alloc segment use mmap, which only support 32757 threads,
     // if need to support more, for instance, 100k threads, define the macro MALLOC_STACK.
     // TODO: FIXME: maybe can use "sysctl vm.max_map_count" to refine.
@@ -688,7 +683,7 @@ srs_error_t SrsServer::listen()
     if ((err = conn_manager->start()) != srs_success) {
         return srs_error_wrap(err, "connection manager");
     }
-    
+
     return err;
 }