mediasoup 3.19.21 → 3.20.0

package/worker/include/Worker.hpp

@@ -4,10 +4,10 @@
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
 #include "FBS/worker.h"
+#include "handles/SignalHandle.hpp"
 #include "RTC/Router.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/WebRtcServer.hpp"
-#include "handles/SignalHandle.hpp"
+#include "SharedInterface.hpp"
 #include <flatbuffers/flatbuffer_builder.h>
 #include <absl/container/flat_hash_map.h>
 #include <string>
@@ -17,7 +17,7 @@ class Worker : public Channel::ChannelSocket::Listener,
                public RTC::Router::Listener
 {
 public:
-	explicit Worker(Channel::ChannelSocket* channel);
+	explicit Worker(Channel::ChannelSocket* channel, SharedInterface* shared);
 	~Worker() override;
 
 private:
@@ -26,8 +26,8 @@ private:
 	flatbuffers::Offset<FBS::Worker::ResourceUsageResponse> FillBufferResourceUsage(
 	  flatbuffers::FlatBufferBuilder& builder) const;
 	void SetNewRouterId(std::string& routerId) const;
-	RTC::WebRtcServer* GetWebRtcServer(const std::string& webRtcServerId) const;
-	RTC::Router* GetRouter(const std::string& routerId) const;
+	RTC::WebRtcServer* AssertAndGetWebRtcServerById(const std::string& webRtcServerId) const;
+	RTC::Router* AssertAndGetRouterById(const std::string& routerId) const;
 	void CheckNoWebRtcServer(const std::string& webRtcServerId) const;
 	void CheckNoRouter(const std::string& routerId) const;
 
@@ -53,7 +53,7 @@ private:
 	Channel::ChannelSocket* channel{ nullptr };
 	// Allocated by this.
 	SignalHandle* signalHandle{ nullptr };
-	RTC::Shared* shared{ nullptr };
+	SharedInterface* shared{ nullptr };
 	absl::flat_hash_map<std::string, RTC::WebRtcServer*> mapWebRtcServers;
 	absl::flat_hash_map<std::string, RTC::Router*> mapRouters;
 	// Others.

package/worker/include/common.hpp

@@ -1,28 +1,28 @@
 #ifndef MS_COMMON_HPP
 #define MS_COMMON_HPP
 
-#include <algorithm> // IWYU pragma: export  std::transform(), std::find(), std::min(), std::max(), std::copy(), std::clamp()
-#include <cinttypes> // IWYU pragma: export  PRIu64, etc
-#include <cstddef>   // IWYU pragma: export  size_t
-#include <cstdint>   // IWYU pragma: export  uint8_t, etc
-#include <functional> // IWYU pragma: export  std::function
-#include <memory>     // IWYU pragma: export  std::addressof(), std::unique_ptr(), etc
-#include <optional>   // IWYU pragma: export
-#include <utility>    // std::pair, std::move(), std::piecewise_construct
+#include <algorithm> // std::transform(), std::find(), std::min(), std::max(), std::copy(), std::clamp(), std::ranges
+#include <cinttypes>  // PRIu64, etc
+#include <cstddef>    // size_t
+#include <cstdint>    // uint8_t, etc
+#include <functional> // std::function
+#include <memory>     // std::addressof(), std::unique_ptr(), etc
+#include <optional>
+#include <utility> // std::pair, std::move(), std::piecewise_construct
 #ifdef _WIN32
 #include <winsock2.h>
 // Avoid uv/win.h: error C2628 'intptr_t' followed by 'int' is illegal.
 #if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED)
-#include <BaseTsd.h> // IWYU pragma: export
+#include <BaseTsd.h>
 typedef SSIZE_T ssize_t;
 #define SSIZE_MAX INTPTR_MAX
 #define _SSIZE_T_
 #define _SSIZE_T_DEFINED
 #endif
 #else
-#include <arpa/inet.h>  // IWYU pragma: export // htonl(), htons(), ntohl(), ntohs()
-#include <netinet/in.h> // IWYU pragma: export // sockaddr_in, sockaddr_in6
-#include <sys/socket.h> // IWYU pragma: export // struct sockaddr, struct sockaddr_storage, AF_INET, AF_INET6
+#include <arpa/inet.h>  // htonl(), htons(), ntohl(), ntohs()
+#include <netinet/in.h> // sockaddr_in, sockaddr_in6
+#include <sys/socket.h> // struct sockaddr, struct sockaddr_storage, AF_INET, AF_INET6
 #endif
 
 // This is a macro to silence false warnings in GCC in switch() blocks with FBS

package/worker/include/handles/BackoffTimerHandle.hpp

@@ -2,68 +2,22 @@
 #define MS_BACKOFF_TIMER_HANDLE_HPP
 
 #include "common.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include "handles/TimerHandle.hpp"
-#include <limits> // std::numeric_limits()
+#include "handles/TimerHandleInterface.hpp"
 
-class BackoffTimerHandle : public TimerHandle::Listener
-{
-public:
-	class Listener
-	{
-	public:
-		virtual ~Listener() = default;
-
-	public:
-		/**
-		 * Invoked on timeout expiration. The parent can modify the base
-		 * timeout given as reference and affect the next timeout duration.
-		 *
-		 * @remarks
-		 * - If the caller deletes this BackoffTimer instance within the callback
-		 *   it must signal it be setting `stop` to true.
-		 */
-		virtual void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) = 0;
-	};
+// Forward declaration.
+class Shared;
 
-public:
-	enum class BackoffAlgorithm : uint8_t
-	{
-		// The base duration will be used for any restart.
-		FIXED,
-		// An exponential backoff is used for restarts, with a 2x multiplier,
-		// meaning that every restart will use a duration that is twice as long as
-		// the previous.
-		EXPONENTIAL,
-	};
+class BackoffTimerHandle : public BackoffTimerHandleInterface, public TimerHandleInterface::Listener
+{
+	// Only Shared class can invoke the constructor.
+	friend class Shared;
 
-public:
-	static constexpr uint64_t MaxTimeoutMs{ std::numeric_limits<uint64_t>::max() / 2 };
+private:
+	explicit BackoffTimerHandle(BackoffTimerHandleOptions options);
 
 public:
-	explicit BackoffTimerHandle(
-	  /**
-	   * Listener on which OnTimer() callback will be invoked.
-	   */
-	  Listener* listener,
-	  /**
-	   * Base timeout duration (ms).
-	   */
-	  uint64_t baseTimeoutMs,
-	  /**
-	   * Backoff algorithm.
-	   */
-	  BackoffAlgorithm backoffAlgorithm,
-	  /**
-	   * Maximum duration of the backoff timeout (ms). If no value is given, no
-	   * limit is set.
-	   */
-	  std::optional<uint64_t> maxBackoffTimeoutMs,
-	  /**
-	   * Maximum number of restarts. If no value is given, it will restart
-	   * forever until stopped.
-	   */
-	  std::optional<size_t> maxRestarts);
-
 	BackoffTimerHandle& operator=(const BackoffTimerHandle&) = delete;
 
 	BackoffTimerHandle(const BackoffTimerHandle&) = delete;
@@ -75,35 +29,41 @@ public:
 	 * Start the BackoffTimer (if it's stopped) or restart it (if already
 	 * running). It will reset the timeout count.
 	 */
-	void Start();
+	void Start() override;
 
 	/**
 	 * Stop the BackoffTimer. It will reset the timeout count.
 	 */
-	void Stop();
+	void Stop() override;
 
 	/**
 	 * Set the base timeout duration. It will be applied after the next timeout
 	 * and effective duration can be larger if backoff algorithm is exponential.
 	 */
-	void SetBaseTimeoutMs(uint64_t baseTimeoutMs);
+	void SetBaseTimeoutMs(uint64_t baseTimeoutMs) override;
 
 	/**
 	 * Whether the BackoffTimer is running. Useful to check if this BackoffTimer
 	 * will timeout again within the OnTimer() callback.
 	 */
-	bool IsRunning() const
+	bool IsRunning() const override
 	{
 		return this->running;
 	}
 
+	const std::string GetLabel() const override
+	{
+		return this->label;
+	}
+
 	/**
 	 * Maximum number of restarts.
 	 *
 	 * @remarks
-	 * - If `maxRestarts` was not given in the constructor, this method returns 0.
+	 * - If `maxRestarts` was not given in the constructor, this method returns
+	 *   `std::nullopt`.
 	 */
-	std::optional<size_t> GetMaxRestarts() const
+	std::optional<size_t> GetMaxRestarts() const override
 	{
 		return this->maxRestarts;
 	}
@@ -111,7 +71,7 @@ public:
 	/**
 	 * Number of times the timer has expired.
 	 */
-	size_t GetExpirationCount() const
+	size_t GetExpirationCount() const override
 	{
 		return this->expirationCount;
 	}
@@ -119,14 +79,15 @@ public:
 private:
 	uint64_t ComputeNextTimeoutMs() const;
 
-	/* Pure virtual methods inherited from TimerHandle::Listener. */
+	/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
 public:
-	void OnTimer(TimerHandle* timer) override;
+	void OnTimer(TimerHandleInterface* timer) override;
 
 private:
 	// Passed by argument.
-	Listener* listener{ nullptr };
-	uint64_t baseTimeoutMs{ 0 };
+	BackoffTimerHandleInterface::Listener* listener{ nullptr };
+	const std::string label;
+	uint64_t baseTimeoutMs;
 	BackoffAlgorithm backoffAlgorithm;
 	std::optional<uint64_t> maxBackoffTimeoutMs;
 	std::optional<size_t> maxRestarts;

package/worker/include/handles/BackoffTimerHandleInterface.hpp

@@ -0,0 +1,123 @@
+#ifndef MS_BACKOFF_TIMER_HANDLE_INTERFACE_HPP
+#define MS_BACKOFF_TIMER_HANDLE_INTERFACE_HPP
+
+#include "common.hpp"
+#include <limits> // std::numeric_limits()
+#include <string>
+
+class BackoffTimerHandleInterface
+{
+public:
+	class Listener
+	{
+	public:
+		virtual ~Listener() = default;
+
+	public:
+		/**
+		 * Invoked on timeout expiration. The parent can modify the base
+		 * timeout given as reference and affect the next timeout duration.
+		 *
+		 * @remarks
+		 * - If the caller deletes this BackoffTimer instance within the callback
+		 *   it must signal it be setting `stop` to true.
+		 */
+		virtual void OnBackoffTimer(
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) = 0;
+	};
+
+public:
+	enum class BackoffAlgorithm : uint8_t
+	{
+		// The base duration will be used for any restart.
+		FIXED,
+		// An exponential backoff is used for restarts, with a 2x multiplier,
+		// meaning that every restart will use a duration that is twice as long as
+		// the previous.
+		EXPONENTIAL,
+	};
+
+public:
+	struct BackoffTimerHandleOptions
+	{
+		/**
+		 * Listener on which `OnBackoffTimer()` callback will be invoked.
+		 */
+		BackoffTimerHandleInterface::Listener* listener{ nullptr };
+		/**
+		 * Label.
+		 */
+		std::string label;
+		/**
+		 * Base timeout duration (ms).
+		 */
+		uint64_t baseTimeoutMs;
+		/**
+		 * Backoff algorithm.
+		 */
+		BackoffAlgorithm backoffAlgorithm;
+		/**
+		 * Maximum duration of the backoff timeout (ms). If no value is given, no
+		 * limit is set.
+		 */
+		std::optional<uint64_t> maxBackoffTimeoutMs;
+		/**
+		 * Maximum number of restarts. If no value is given, it will restart
+		 * forever until stopped.
+		 */
+		std::optional<size_t> maxRestarts;
+	};
+
+public:
+	static constexpr uint64_t MaxTimeoutMs{ std::numeric_limits<uint64_t>::max() / 2 };
+
+public:
+	BackoffTimerHandleInterface() = default;
+
+	BackoffTimerHandleInterface& operator=(const BackoffTimerHandleInterface&) = delete;
+
+	BackoffTimerHandleInterface(const BackoffTimerHandleInterface&) = delete;
+
+	virtual ~BackoffTimerHandleInterface() = default;
+
+public:
+	/**
+	 * Start the BackoffTimer (if it's stopped) or restart it (if already
+	 * running). It will reset the timeout count.
+	 */
+	virtual void Start() = 0;
+
+	/**
+	 * Stop the BackoffTimer. It will reset the timeout count.
+	 */
+	virtual void Stop() = 0;
+
+	/**
+	 * Set the base timeout duration. It will be applied after the next timeout
+	 * and effective duration can be larger if backoff algorithm is exponential.
+	 */
+	virtual void SetBaseTimeoutMs(uint64_t baseTimeoutMs) = 0;
+
+	/**
+	 * Whether the BackoffTimer is running. Useful to check if this BackoffTimer
+	 * will timeout again within the OnTimer() callback.
+	 */
+	virtual bool IsRunning() const = 0;
+
+	virtual const std::string GetLabel() const = 0;
+
+	/**
+	 * Maximum number of restarts.
+	 *
+	 * @remarks
+	 * - If `maxRestarts` was not given in the constructor, this method returns 0.
+	 */
+	virtual std::optional<size_t> GetMaxRestarts() const = 0;
+
+	/**
+	 * Number of times the timer has expired.
+	 */
+	virtual size_t GetExpirationCount() const = 0;
+};
+
+#endif

package/worker/include/handles/TimerHandle.hpp

@@ -2,40 +2,49 @@
 #define MS_TIMER_HANDLE_HPP
 
 #include "common.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include <uv.h>
 
-class TimerHandle
+// Forward declaration.
+class Shared;
+class BackoffTimerHandle;
+
+class TimerHandle : public TimerHandleInterface
 {
-public:
-	class Listener
-	{
-	public:
-		virtual ~Listener() = default;
+	// Only Shared and BackoffTimerHandle classes can invoke the constructor.
+	friend class Shared;
+	friend class BackoffTimerHandle;
 
-	public:
-		virtual void OnTimer(TimerHandle* timer) = 0;
-	};
+private:
+	explicit TimerHandle(TimerHandleInterface::Listener* listener);
 
 public:
-	explicit TimerHandle(Listener* listener);
 	TimerHandle& operator=(const TimerHandle&) = delete;
-	TimerHandle(const TimerHandle&)            = delete;
-	~TimerHandle();
+
+	TimerHandle(const TimerHandle&) = delete;
+
+	~TimerHandle() override;
 
 public:
-	void Start(uint64_t timeout, uint64_t repeat = 0);
-	void Stop();
-	void Restart();
-	void Restart(uint64_t timeout, uint64_t repeat = 0);
-	uint64_t GetTimeout() const
+	void Start(uint64_t timeout, uint64_t repeat = 0) override;
+
+	void Stop() override;
+
+	void Restart() override;
+
+	void Restart(uint64_t timeout, uint64_t repeat = 0) override;
+
+	uint64_t GetTimeout() const override
 	{
 		return this->timeout;
 	}
-	uint64_t GetRepeat() const
+
+	uint64_t GetRepeat() const override
 	{
 		return this->repeat;
 	}
-	bool IsActive() const
+
+	bool IsActive() const override
 	{
 		return uv_is_active(reinterpret_cast<uv_handle_t*>(this->uvHandle)) != 0;
 	}
@@ -49,7 +58,7 @@ public:
 
 private:
 	// Passed by argument.
-	Listener* listener{ nullptr };
+	TimerHandleInterface::Listener* listener{ nullptr };
 	// Allocated by this.
 	uv_timer_t* uvHandle{ nullptr };
 	// Others.

package/worker/include/handles/TimerHandleInterface.hpp

@@ -0,0 +1,43 @@
+#ifndef MS_TIMER_HANDLE_INTERFACE_HPP
+#define MS_TIMER_HANDLE_INTERFACE_HPP
+
+#include "common.hpp"
+
+class TimerHandleInterface
+{
+public:
+	class Listener
+	{
+	public:
+		virtual ~Listener() = default;
+
+	public:
+		virtual void OnTimer(TimerHandleInterface* timer) = 0;
+	};
+
+public:
+	TimerHandleInterface() = default;
+
+	TimerHandleInterface& operator=(const TimerHandleInterface&) = delete;
+
+	TimerHandleInterface(const TimerHandleInterface&) = delete;
+
+	virtual ~TimerHandleInterface() = default;
+
+public:
+	virtual void Start(uint64_t timeout, uint64_t repeat = 0) = 0;
+
+	virtual void Stop() = 0;
+
+	virtual void Restart() = 0;
+
+	virtual void Restart(uint64_t timeout, uint64_t repeat = 0) = 0;
+
+	virtual uint64_t GetTimeout() const = 0;
+
+	virtual uint64_t GetRepeat() const = 0;
+
+	virtual bool IsActive() const = 0;
+};
+
+#endif