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

GB28181: Refine SRS listeners without wrapper.

Browse source
This commit is contained in:
winlin 2022-09-17 13:38:28 +08:00
parent b452144fb7
commit 173c683566
13 changed files with 601 additions and 762 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -37,97 +37,9 @@ class SrsAppCasterFlv;
class SrsResourceManager;
class SrsLatestVersion;
class SrsWaitGroup;
// The listener type for server to identify the connection,
// that is, use different type to process the connection.
enum SrsListenerType
{
// RTMP client,
SrsListenerRtmpStream = 0,
// HTTP api,
SrsListenerHttpApi = 1,
// HTTP stream, HDS/HLS/DASH
SrsListenerHttpStream = 2,
// UDP stream, MPEG-TS over udp.
SrsListenerMpegTsOverUdp = 3,
// TCP stream, FLV stream over HTTP.
SrsListenerFlv = 5,
// HTTPS api,
SrsListenerHttpsApi = 8,
// HTTPS stream,
SrsListenerHttpsStream = 9,
// WebRTC over TCP,
SrsListenerTcp = 10,
};
// A common tcp listener, for RTMP/HTTP server.
class SrsListener
{
protected:
SrsListenerType type;
protected:
std::string ip;
int port;
SrsServer* server;
public:
SrsListener(SrsServer* svr, SrsListenerType t);
virtual ~SrsListener();
public:
virtual SrsListenerType listen_type();
virtual srs_error_t listen(std::string i, int p) = 0;
};
// A buffered TCP listener.
class SrsBufferListener : public SrsListener, public ISrsTcpHandler
{
private:
SrsTcpListener* listener;
public:
SrsBufferListener(SrsServer* server, SrsListenerType type);
virtual ~SrsBufferListener();
public:
virtual srs_error_t listen(std::string ip, int port);
// Interface ISrsTcpHandler
public:
virtual srs_error_t on_tcp_client(srs_netfd_t stfd);
};
// A TCP listener, for flv stream server.
class SrsHttpFlvListener : public SrsListener, public ISrsTcpHandler
{
private:
SrsTcpListener* listener;
SrsAppCasterFlv* caster;
public:
SrsHttpFlvListener(SrsServer* svr, SrsListenerType t, SrsConfDirective* c);
virtual ~SrsHttpFlvListener();
public:
virtual srs_error_t listen(std::string i, int p);
// Interface ISrsTcpHandler
public:
virtual srs_error_t on_tcp_client(srs_netfd_t stfd);
};
// A UDP listener, for udp server.
class SrsUdpStreamListener : public SrsListener
{
protected:
SrsUdpListener* listener;
ISrsUdpHandler* caster;
public:
SrsUdpStreamListener(SrsServer* svr, SrsListenerType t, ISrsUdpHandler* c);
virtual ~SrsUdpStreamListener();
public:
virtual srs_error_t listen(std::string i, int p);
};
// A UDP listener, for udp stream caster server.
class SrsUdpCasterListener : public SrsUdpStreamListener
{
public:
SrsUdpCasterListener(SrsServer* svr, SrsListenerType t, SrsConfDirective* c);
virtual ~SrsUdpCasterListener();
};
class SrsMultipleTcpListeners;
class SrsHttpFlvListener;
class SrsUdpCasterListener;
// Convert signal to io,
// @see: st-1.9/docs/notes.html
@ -176,37 +88,15 @@ public:
virtual srs_error_t cycle();
};
// A handler to the handle cycle in SRS RTMP server.
class ISrsServerCycle
{
public:
ISrsServerCycle();
virtual ~ISrsServerCycle();
public:
// Initialize the cycle handler.
virtual srs_error_t initialize() = 0;
// Do on_cycle while server doing cycle.
virtual srs_error_t on_cycle() = 0;
// Callback the handler when got client.
virtual srs_error_t on_accept_client(int max, int cur) = 0;
// Callback for logrotate.
virtual void on_logrotate() = 0;
};
// TODO: FIXME: Rename to SrsLiveServer.
// SRS RTMP server, initialize and listen, start connection service thread, destroy client.
class SrsServer : public ISrsReloadHandler, public ISrsLiveSourceHandler
, public ISrsResourceManager, public ISrsCoroutineHandler
, public ISrsHourGlass
class SrsServer : public ISrsReloadHandler, public ISrsLiveSourceHandler, public ISrsTcpHandler
, public ISrsResourceManager, public ISrsCoroutineHandler, public ISrsHourGlass
{
private:
// TODO: FIXME: Extract an HttpApiServer.
ISrsHttpServeMux* http_api_mux;
SrsHttpServer* http_server;
// If reusing, HTTP API use the same port of HTTP server.
bool reuse_api_over_server_;
// If reusing, WebRTC TCP use the same port of HTTP server.
bool reuse_rtc_over_server_;
private:
SrsHttpHeartbeat* http_heartbeat;
SrsIngester* ingester;
@ -220,14 +110,34 @@ private:
// for the server never delete the file; when system startup, the pid in pid file
// maybe valid but the process is not SRS, the init.d script will never start server.
int pid_fd;
// All listners, listener manager.
std::vector<SrsListener*> listeners;
private:
// If reusing, HTTP API use the same port of HTTP server.
bool reuse_api_over_server_;
// If reusing, WebRTC TCP use the same port of HTTP server.
bool reuse_rtc_over_server_;
// RTMP stream listeners, over TCP.
SrsMultipleTcpListeners* rtmp_listener_;
// HTTP API listener, over TCP. Please note that it might reuse with stream listener.
SrsTcpListener* api_listener_;
// HTTPS API listener, over TCP. Please note that it might reuse with stream listener.
SrsTcpListener* apis_listener_;
// HTTP server listener, over TCP. Please note that request of both HTTP static and stream are served by this
// listener, and it might be reused by HTTP API and WebRTC TCP.
SrsTcpListener* http_listener_;
// HTTPS server listener, over TCP. Please note that request of both HTTP static and stream are served by this
// listener, and it might be reused by HTTP API and WebRTC TCP.
SrsTcpListener* https_listener_;
// WebRTC over TCP listener. Please note that there is always a UDP listener by RTC server.
SrsTcpListener* webrtc_listener_;
// Stream Caster for push over HTTP-FLV.
SrsHttpFlvListener* stream_caster_flv_listener_;
// Stream Caster for push over MPEGTS-UDP
SrsUdpCasterListener* stream_caster_mpegts_;
private:
// Signal manager which convert gignal to io message.
SrsSignalManager* signal_manager;
// To query the latest available version of SRS.
SrsLatestVersion* latest_version_;
// Handle in server cycle.
ISrsServerCycle* handler;
// User send the signal, convert to variable.
bool signal_reload;
bool signal_persistence_config;
@ -254,7 +164,7 @@ private:
public:
// Initialize server with callback handler ch.
// @remark user must free the handler.
virtual srs_error_t initialize(ISrsServerCycle* ch);
virtual srs_error_t initialize();
virtual srs_error_t initialize_st();
virtual srs_error_t initialize_signal();
virtual srs_error_t listen();
@ -293,29 +203,18 @@ private:
virtual srs_error_t setup_ticks();
virtual srs_error_t notify(int event, srs_utime_t interval, srs_utime_t tick);
private:
// listen at specified protocol.
virtual srs_error_t listen_rtmp();
virtual srs_error_t listen_http_api();
virtual srs_error_t listen_https_api();
virtual srs_error_t listen_http_stream();
virtual srs_error_t listen_https_stream();
virtual srs_error_t listen_stream_caster();
// Close the listeners for specified type,
// Remove the listen object from manager.
virtual void close_listeners(SrsListenerType type);
// Resample the server kbs.
virtual void resample_kbps();
// For internal only
public:
// When listener got a fd, notice server to accept it.
// @param type, the client type, used to create concrete connection,
// for instance RTMP connection to serve client.
// @param stfd, the client fd in st boxed, the underlayer fd.
virtual srs_error_t accept_client(SrsListenerType type, srs_netfd_t stfd);
// TODO: FIXME: Fetch from hybrid server manager.
virtual ISrsHttpServeMux* api_server();
// Interface ISrsTcpHandler
public:
virtual srs_error_t on_tcp_client(ISrsListener* listener, srs_netfd_t stfd);
private:
virtual srs_error_t fd_to_resource(SrsListenerType type, srs_netfd_t& stfd, ISrsResource** pr);
virtual srs_error_t do_on_tcp_client(ISrsListener* listener, srs_netfd_t& stfd);
virtual srs_error_t on_before_connection(srs_netfd_t& stfd, const std::string& ip, int port);
// Interface ISrsResourceManager
public:
// A callback for connection to remove itself.