R3944Realms/srs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

OpenClaw: Rename proxy environment interface

Browse Source 
Rename the proxy environment type and generated fake to clarify that the configuration surface belongs to the proxy server.

Update proxy bootstrap, load balancers, protocol servers, debug, signal handling, tests, and codebase memory to use ProxyEnvironment.
This commit is contained in:
winlin 2026-04-26 11:56:28 -04:00
parent 55fc52a0f6
commit fe86846e3b
17 changed files with 177 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.openclaw/memory/srs-codebase-map.md
View File

@ -223,7 +223,7 @@ The next-generation server (`cmd/` + `internal/`) is written in Go and maintaine
`internal/logger` — Structured logging with context IDs. Four log levels: Verbose (discarded), Debug (stdout), Warn (stderr), Error (stderr). Emits JSON via `log/slog` with `pid` and `cid` attributes. Each connection/request gets a unique 7-char hex context ID for log correlation, stored in `context.Context`. `internal/logger` — Structured logging with context IDs. Four log levels: Verbose (discarded), Debug (stdout), Warn (stderr), Error (stderr). Emits JSON via `log/slog` with `pid` and `cid` attributes. Each connection/request gets a unique 7-char hex context ID for log correlation, stored in `context.Context`.
`internal/env` — Environment-based configuration. All settings via env vars (or `.env` file parsed by an in-tree custom parser — no third-party dep; supports comments, `export` prefix, quoted values, escape sequences, and inline comments). Exposes an `Environment` interface (with a counterfeiter-generated fake in `envfakes/` for downstream tests) with methods for each config value. Default ports: RTMP=11935, HTTP API=11985, HTTP Stream=18080, WebRTC=18000, SRT=20080, System API=12025. Timeouts: grace=20s, force=30s. Supports Redis config and default backend config for debugging. `internal/env` — Environment-based configuration. All settings via env vars (or `.env` file parsed by an in-tree custom parser — no third-party dep; supports comments, `export` prefix, quoted values, escape sequences, and inline comments). Exposes a `ProxyEnvironment` interface (with a counterfeiter-generated fake in `envfakes/` for downstream tests) with methods for each config value. Default ports: RTMP=11935, HTTP API=11985, HTTP Stream=18080, WebRTC=18000, SRT=20080, System API=12025. Timeouts: grace=20s, force=30s. Supports Redis config and default backend config for debugging.
`internal/version` — Version constants. Signature `SRSX`, version tracks the SRS project version (currently 7.0.x). Used in HTTP API responses and startup logging. `internal/version` — Version constants. Signature `SRSX`, version tracks the SRS project version (currently 7.0.x). Used in HTTP API responses and startup logging.

6
internal/bootstrap/proxy.go
View File

@ -50,7 +50,7 @@ func (b *proxyBootstrap) Start(ctx context.Context) error {
// It blocks until the context is cancelled. // It blocks until the context is cancelled.
func (b *proxyBootstrap) run(ctx context.Context) error { func (b *proxyBootstrap) run(ctx context.Context) error {
// Setup the environment variables. // Setup the environment variables.
environment, err := env.NewEnvironment(ctx) environment, err := env.NewProxyEnvironment(ctx)
if err != nil { if err != nil {
return errors.Wrapf(err, "create environment") return errors.Wrapf(err, "create environment")
} }
@ -81,7 +81,7 @@ func (b *proxyBootstrap) run(ctx context.Context) error {
} }
// initializeLoadBalancer sets up the load balancer based on configuration. // initializeLoadBalancer sets up the load balancer based on configuration.
func (b *proxyBootstrap) initializeLoadBalancer(ctx context.Context, environment env.Environment) error { func (b *proxyBootstrap) initializeLoadBalancer(ctx context.Context, environment env.ProxyEnvironment) error {
switch environment.LoadBalancerType() { switch environment.LoadBalancerType() {
case "redis": case "redis":
lb.SrsLoadBalancer = lb.NewRedisLoadBalancer(environment) lb.SrsLoadBalancer = lb.NewRedisLoadBalancer(environment)
@ -97,7 +97,7 @@ func (b *proxyBootstrap) initializeLoadBalancer(ctx context.Context, environment
} }
// startServers initializes and starts all protocol servers. // startServers initializes and starts all protocol servers.
func (b *proxyBootstrap) startServers(ctx context.Context, environment env.Environment, gracefulQuitTimeout time.Duration) error { func (b *proxyBootstrap) startServers(ctx context.Context, environment env.ProxyEnvironment, gracefulQuitTimeout time.Duration) error {
// Start the RTMP server. // Start the RTMP server.
srsRTMPServer := protocol.NewSRSRTMPServer(environment) srsRTMPServer := protocol.NewSRSRTMPServer(environment)
if err := srsRTMPServer.Run(ctx); err != nil { if err := srsRTMPServer.Run(ctx); err != nil {

2
internal/debug/pprof.go
View File

@ -11,7 +11,7 @@ import (
"srsx/internal/logger" "srsx/internal/logger"
) )
func HandleGoPprof(ctx context.Context, environment env.Environment) { func HandleGoPprof(ctx context.Context, environment env.ProxyEnvironment) {
if addr := environment.GoPprof(); addr != "" { if addr := environment.GoPprof(); addr != "" {
go func() { go func() {
logger.Df(ctx, "Start Go pprof at %v", addr) logger.Df(ctx, "Start Go pprof at %v", addr)

56
internal/env/env.go vendored
View File

@ -25,8 +25,8 @@ var (
} }
) )
// Environment provides access to environment variables. // ProxyEnvironment provides access to proxy environment variables.
type Environment interface { type ProxyEnvironment interface {
// Go pprof profiling // Go pprof profiling
GoPprof() string GoPprof() string
// Graceful quit timeout // Graceful quit timeout
@ -73,102 +73,102 @@ type Environment interface {
DefaultBackendSRT() string DefaultBackendSRT() string
} }
type environment struct{} type proxyEnvironment struct{}
// NewEnvironment creates a new Environment instance, loading and building default environment variables. // NewProxyEnvironment creates a new ProxyEnvironment instance, loading and building default environment variables.
func NewEnvironment(ctx context.Context) (Environment, error) { func NewProxyEnvironment(ctx context.Context) (ProxyEnvironment, error) {
if err := loadEnvFile(ctx); err != nil { if err := loadEnvFile(ctx); err != nil {
return nil, err return nil, err
} }
buildDefaultEnvironmentVariables(ctx) buildDefaultEnvironmentVariables(ctx)
return &environment{}, nil return &proxyEnvironment{}, nil
} }
func (e *environment) GoPprof() string { func (e *proxyEnvironment) GoPprof() string {
return getEnv("GO_PPROF") return getEnv("GO_PPROF")
} }
func (e *environment) GraceQuitTimeout() string { func (e *proxyEnvironment) GraceQuitTimeout() string {
return getEnv("PROXY_GRACE_QUIT_TIMEOUT") return getEnv("PROXY_GRACE_QUIT_TIMEOUT")
} }
func (e *environment) ForceQuitTimeout() string { func (e *proxyEnvironment) ForceQuitTimeout() string {
return getEnv("PROXY_FORCE_QUIT_TIMEOUT") return getEnv("PROXY_FORCE_QUIT_TIMEOUT")
} }
func (e *environment) HttpAPI() string { func (e *proxyEnvironment) HttpAPI() string {
return getEnv("PROXY_HTTP_API") return getEnv("PROXY_HTTP_API")
} }
func (e *environment) HttpServer() string { func (e *proxyEnvironment) HttpServer() string {
return getEnv("PROXY_HTTP_SERVER") return getEnv("PROXY_HTTP_SERVER")
} }
func (e *environment) RtmpServer() string { func (e *proxyEnvironment) RtmpServer() string {
return getEnv("PROXY_RTMP_SERVER") return getEnv("PROXY_RTMP_SERVER")
} }
func (e *environment) WebRTCServer() string { func (e *proxyEnvironment) WebRTCServer() string {
return getEnv("PROXY_WEBRTC_SERVER") return getEnv("PROXY_WEBRTC_SERVER")
} }
func (e *environment) SRTServer() string { func (e *proxyEnvironment) SRTServer() string {
return getEnv("PROXY_SRT_SERVER") return getEnv("PROXY_SRT_SERVER")
} }
func (e *environment) SystemAPI() string { func (e *proxyEnvironment) SystemAPI() string {
return getEnv("PROXY_SYSTEM_API") return getEnv("PROXY_SYSTEM_API")
} }
func (e *environment) StaticFiles() string { func (e *proxyEnvironment) StaticFiles() string {
return getEnv("PROXY_STATIC_FILES") return getEnv("PROXY_STATIC_FILES")
} }
func (e *environment) LoadBalancerType() string { func (e *proxyEnvironment) LoadBalancerType() string {
return getEnv("PROXY_LOAD_BALANCER_TYPE") return getEnv("PROXY_LOAD_BALANCER_TYPE")
} }
func (e *environment) RedisHost() string { func (e *proxyEnvironment) RedisHost() string {
return getEnv("PROXY_REDIS_HOST") return getEnv("PROXY_REDIS_HOST")
} }
func (e *environment) RedisPort() string { func (e *proxyEnvironment) RedisPort() string {
return getEnv("PROXY_REDIS_PORT") return getEnv("PROXY_REDIS_PORT")
} }
func (e *environment) RedisPassword() string { func (e *proxyEnvironment) RedisPassword() string {
return getEnv("PROXY_REDIS_PASSWORD") return getEnv("PROXY_REDIS_PASSWORD")
} }
func (e *environment) RedisDB() string { func (e *proxyEnvironment) RedisDB() string {
return getEnv("PROXY_REDIS_DB") return getEnv("PROXY_REDIS_DB")
} }
func (e *environment) DefaultBackendEnabled() string { func (e *proxyEnvironment) DefaultBackendEnabled() string {
return getEnv("PROXY_DEFAULT_BACKEND_ENABLED") return getEnv("PROXY_DEFAULT_BACKEND_ENABLED")
} }
func (e *environment) DefaultBackendIP() string { func (e *proxyEnvironment) DefaultBackendIP() string {
return getEnv("PROXY_DEFAULT_BACKEND_IP") return getEnv("PROXY_DEFAULT_BACKEND_IP")
} }
func (e *environment) DefaultBackendRTMP() string { func (e *proxyEnvironment) DefaultBackendRTMP() string {
return getEnv("PROXY_DEFAULT_BACKEND_RTMP") return getEnv("PROXY_DEFAULT_BACKEND_RTMP")
} }
func (e *environment) DefaultBackendHttp() string { func (e *proxyEnvironment) DefaultBackendHttp() string {
return getEnv("PROXY_DEFAULT_BACKEND_HTTP") return getEnv("PROXY_DEFAULT_BACKEND_HTTP")
} }
func (e *environment) DefaultBackendAPI() string { func (e *proxyEnvironment) DefaultBackendAPI() string {
return getEnv("PROXY_DEFAULT_BACKEND_API") return getEnv("PROXY_DEFAULT_BACKEND_API")
} }
func (e *environment) DefaultBackendRTC() string { func (e *proxyEnvironment) DefaultBackendRTC() string {
return getEnv("PROXY_DEFAULT_BACKEND_RTC") return getEnv("PROXY_DEFAULT_BACKEND_RTC")
} }
func (e *environment) DefaultBackendSRT() string { func (e *proxyEnvironment) DefaultBackendSRT() string {
return getEnv("PROXY_DEFAULT_BACKEND_SRT") return getEnv("PROXY_DEFAULT_BACKEND_SRT")
} }

16
internal/env/env_test.go vendored
View File

@ -303,7 +303,7 @@ func TestSetEnvDefault_PreservesExisting(t *testing.T) {
} }
} }
func TestNewEnvironment_AppliesDefaultsAndAccessors(t *testing.T) { func TestNewProxyEnvironment_AppliesDefaultsAndAccessors(t *testing.T) {
withFakeEnv(t) withFakeEnv(t)
// No .env file present. // No .env file present.
withFakeOpen(t, "", os.ErrNotExist) withFakeOpen(t, "", os.ErrNotExist)
@ -312,9 +312,9 @@ func TestNewEnvironment_AppliesDefaultsAndAccessors(t *testing.T) {
// pre-set it so the accessor has a value to return. // pre-set it so the accessor has a value to return.
setEnv("PROXY_DEFAULT_BACKEND_HTTP", "8080") setEnv("PROXY_DEFAULT_BACKEND_HTTP", "8080")
env, err := NewEnvironment(context.Background()) env, err := NewProxyEnvironment(context.Background())
if err != nil { if err != nil {
t.Fatalf("NewEnvironment: %v", err) t.Fatalf("NewProxyEnvironment: %v", err)
} }
cases := []struct { cases := []struct {
@ -352,26 +352,26 @@ func TestNewEnvironment_AppliesDefaultsAndAccessors(t *testing.T) {
} }
} }
func TestNewEnvironment_PreservesPreSetValues(t *testing.T) { func TestNewProxyEnvironment_PreservesPreSetValues(t *testing.T) {
withFakeEnv(t) withFakeEnv(t)
withFakeOpen(t, "", os.ErrNotExist) withFakeOpen(t, "", os.ErrNotExist)
setEnv("PROXY_HTTP_API", "9999") setEnv("PROXY_HTTP_API", "9999")
env, err := NewEnvironment(context.Background()) env, err := NewProxyEnvironment(context.Background())
if err != nil { if err != nil {
t.Fatalf("NewEnvironment: %v", err) t.Fatalf("NewProxyEnvironment: %v", err)
} }
if got := env.HttpAPI(); got != "9999" { if got := env.HttpAPI(); got != "9999" {
t.Errorf("HttpAPI() = %q, want %q", got, "9999") t.Errorf("HttpAPI() = %q, want %q", got, "9999")
} }
} }
func TestNewEnvironment_LoadEnvFailurePropagates(t *testing.T) { func TestNewProxyEnvironment_LoadEnvFailurePropagates(t *testing.T) {
withFakeEnv(t) withFakeEnv(t)
sentinel := errors.New("open failed") sentinel := errors.New("open failed")
withFakeOpen(t, "", sentinel) withFakeOpen(t, "", sentinel)
_, err := NewEnvironment(context.Background()) _, err := NewProxyEnvironment(context.Background())
if srserrors.Cause(err) != sentinel { if srserrors.Cause(err) != sentinel {
t.Errorf("expected wrapped sentinel, got: %v", err) t.Errorf("expected wrapped sentinel, got: %v", err)
} }

228
internal/env/envfakes/fake_environment.go → internal/env/envfakes/fake_proxy_environment.go vendored
View File

@ -6,7 +6,7 @@ import (
"sync" "sync"
) )
type FakeEnvironment struct { type FakeProxyEnvironment struct {
DefaultBackendAPIStub func() string DefaultBackendAPIStub func() string
defaultBackendAPIMutex sync.RWMutex defaultBackendAPIMutex sync.RWMutex
defaultBackendAPIArgsForCall []struct { defaultBackendAPIArgsForCall []struct {
@ -231,7 +231,7 @@ type FakeEnvironment struct {
invocationsMutex sync.RWMutex invocationsMutex sync.RWMutex
} }
func (fake *FakeEnvironment) DefaultBackendAPI() string { func (fake *FakeProxyEnvironment) DefaultBackendAPI() string {
fake.defaultBackendAPIMutex.Lock() fake.defaultBackendAPIMutex.Lock()
ret, specificReturn := fake.defaultBackendAPIReturnsOnCall[len(fake.defaultBackendAPIArgsForCall)] ret, specificReturn := fake.defaultBackendAPIReturnsOnCall[len(fake.defaultBackendAPIArgsForCall)]
fake.defaultBackendAPIArgsForCall = append(fake.defaultBackendAPIArgsForCall, struct { fake.defaultBackendAPIArgsForCall = append(fake.defaultBackendAPIArgsForCall, struct {
@ -249,19 +249,19 @@ func (fake *FakeEnvironment) DefaultBackendAPI() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) DefaultBackendAPICallCount() int { func (fake *FakeProxyEnvironment) DefaultBackendAPICallCount() int {
fake.defaultBackendAPIMutex.RLock() fake.defaultBackendAPIMutex.RLock()
defer fake.defaultBackendAPIMutex.RUnlock() defer fake.defaultBackendAPIMutex.RUnlock()
return len(fake.defaultBackendAPIArgsForCall) return len(fake.defaultBackendAPIArgsForCall)
} }
func (fake *FakeEnvironment) DefaultBackendAPICalls(stub func() string) { func (fake *FakeProxyEnvironment) DefaultBackendAPICalls(stub func() string) {
fake.defaultBackendAPIMutex.Lock() fake.defaultBackendAPIMutex.Lock()
defer fake.defaultBackendAPIMutex.Unlock() defer fake.defaultBackendAPIMutex.Unlock()
fake.DefaultBackendAPIStub = stub fake.DefaultBackendAPIStub = stub
} }
func (fake *FakeEnvironment) DefaultBackendAPIReturns(result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendAPIReturns(result1 string) {
fake.defaultBackendAPIMutex.Lock() fake.defaultBackendAPIMutex.Lock()
defer fake.defaultBackendAPIMutex.Unlock() defer fake.defaultBackendAPIMutex.Unlock()
fake.DefaultBackendAPIStub = nil fake.DefaultBackendAPIStub = nil
@ -270,7 +270,7 @@ func (fake *FakeEnvironment) DefaultBackendAPIReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendAPIReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendAPIReturnsOnCall(i int, result1 string) {
fake.defaultBackendAPIMutex.Lock() fake.defaultBackendAPIMutex.Lock()
defer fake.defaultBackendAPIMutex.Unlock() defer fake.defaultBackendAPIMutex.Unlock()
fake.DefaultBackendAPIStub = nil fake.DefaultBackendAPIStub = nil
@ -284,7 +284,7 @@ func (fake *FakeEnvironment) DefaultBackendAPIReturnsOnCall(i int, result1 strin
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendEnabled() string { func (fake *FakeProxyEnvironment) DefaultBackendEnabled() string {
fake.defaultBackendEnabledMutex.Lock() fake.defaultBackendEnabledMutex.Lock()
ret, specificReturn := fake.defaultBackendEnabledReturnsOnCall[len(fake.defaultBackendEnabledArgsForCall)] ret, specificReturn := fake.defaultBackendEnabledReturnsOnCall[len(fake.defaultBackendEnabledArgsForCall)]
fake.defaultBackendEnabledArgsForCall = append(fake.defaultBackendEnabledArgsForCall, struct { fake.defaultBackendEnabledArgsForCall = append(fake.defaultBackendEnabledArgsForCall, struct {
@ -302,19 +302,19 @@ func (fake *FakeEnvironment) DefaultBackendEnabled() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) DefaultBackendEnabledCallCount() int { func (fake *FakeProxyEnvironment) DefaultBackendEnabledCallCount() int {
fake.defaultBackendEnabledMutex.RLock() fake.defaultBackendEnabledMutex.RLock()
defer fake.defaultBackendEnabledMutex.RUnlock() defer fake.defaultBackendEnabledMutex.RUnlock()
return len(fake.defaultBackendEnabledArgsForCall) return len(fake.defaultBackendEnabledArgsForCall)
} }
func (fake *FakeEnvironment) DefaultBackendEnabledCalls(stub func() string) { func (fake *FakeProxyEnvironment) DefaultBackendEnabledCalls(stub func() string) {
fake.defaultBackendEnabledMutex.Lock() fake.defaultBackendEnabledMutex.Lock()
defer fake.defaultBackendEnabledMutex.Unlock() defer fake.defaultBackendEnabledMutex.Unlock()
fake.DefaultBackendEnabledStub = stub fake.DefaultBackendEnabledStub = stub
} }
func (fake *FakeEnvironment) DefaultBackendEnabledReturns(result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendEnabledReturns(result1 string) {
fake.defaultBackendEnabledMutex.Lock() fake.defaultBackendEnabledMutex.Lock()
defer fake.defaultBackendEnabledMutex.Unlock() defer fake.defaultBackendEnabledMutex.Unlock()
fake.DefaultBackendEnabledStub = nil fake.DefaultBackendEnabledStub = nil
@ -323,7 +323,7 @@ func (fake *FakeEnvironment) DefaultBackendEnabledReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendEnabledReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendEnabledReturnsOnCall(i int, result1 string) {
fake.defaultBackendEnabledMutex.Lock() fake.defaultBackendEnabledMutex.Lock()
defer fake.defaultBackendEnabledMutex.Unlock() defer fake.defaultBackendEnabledMutex.Unlock()
fake.DefaultBackendEnabledStub = nil fake.DefaultBackendEnabledStub = nil
@ -337,7 +337,7 @@ func (fake *FakeEnvironment) DefaultBackendEnabledReturnsOnCall(i int, result1 s
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendHttp() string { func (fake *FakeProxyEnvironment) DefaultBackendHttp() string {
fake.defaultBackendHttpMutex.Lock() fake.defaultBackendHttpMutex.Lock()
ret, specificReturn := fake.defaultBackendHttpReturnsOnCall[len(fake.defaultBackendHttpArgsForCall)] ret, specificReturn := fake.defaultBackendHttpReturnsOnCall[len(fake.defaultBackendHttpArgsForCall)]
fake.defaultBackendHttpArgsForCall = append(fake.defaultBackendHttpArgsForCall, struct { fake.defaultBackendHttpArgsForCall = append(fake.defaultBackendHttpArgsForCall, struct {
@ -355,19 +355,19 @@ func (fake *FakeEnvironment) DefaultBackendHttp() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) DefaultBackendHttpCallCount() int { func (fake *FakeProxyEnvironment) DefaultBackendHttpCallCount() int {
fake.defaultBackendHttpMutex.RLock() fake.defaultBackendHttpMutex.RLock()
defer fake.defaultBackendHttpMutex.RUnlock() defer fake.defaultBackendHttpMutex.RUnlock()
return len(fake.defaultBackendHttpArgsForCall) return len(fake.defaultBackendHttpArgsForCall)
} }
func (fake *FakeEnvironment) DefaultBackendHttpCalls(stub func() string) { func (fake *FakeProxyEnvironment) DefaultBackendHttpCalls(stub func() string) {
fake.defaultBackendHttpMutex.Lock() fake.defaultBackendHttpMutex.Lock()
defer fake.defaultBackendHttpMutex.Unlock() defer fake.defaultBackendHttpMutex.Unlock()
fake.DefaultBackendHttpStub = stub fake.DefaultBackendHttpStub = stub
} }
func (fake *FakeEnvironment) DefaultBackendHttpReturns(result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendHttpReturns(result1 string) {
fake.defaultBackendHttpMutex.Lock() fake.defaultBackendHttpMutex.Lock()
defer fake.defaultBackendHttpMutex.Unlock() defer fake.defaultBackendHttpMutex.Unlock()
fake.DefaultBackendHttpStub = nil fake.DefaultBackendHttpStub = nil
@ -376,7 +376,7 @@ func (fake *FakeEnvironment) DefaultBackendHttpReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendHttpReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendHttpReturnsOnCall(i int, result1 string) {
fake.defaultBackendHttpMutex.Lock() fake.defaultBackendHttpMutex.Lock()
defer fake.defaultBackendHttpMutex.Unlock() defer fake.defaultBackendHttpMutex.Unlock()
fake.DefaultBackendHttpStub = nil fake.DefaultBackendHttpStub = nil
@ -390,7 +390,7 @@ func (fake *FakeEnvironment) DefaultBackendHttpReturnsOnCall(i int, result1 stri
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendIP() string { func (fake *FakeProxyEnvironment) DefaultBackendIP() string {
fake.defaultBackendIPMutex.Lock() fake.defaultBackendIPMutex.Lock()
ret, specificReturn := fake.defaultBackendIPReturnsOnCall[len(fake.defaultBackendIPArgsForCall)] ret, specificReturn := fake.defaultBackendIPReturnsOnCall[len(fake.defaultBackendIPArgsForCall)]
fake.defaultBackendIPArgsForCall = append(fake.defaultBackendIPArgsForCall, struct { fake.defaultBackendIPArgsForCall = append(fake.defaultBackendIPArgsForCall, struct {
@ -408,19 +408,19 @@ func (fake *FakeEnvironment) DefaultBackendIP() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) DefaultBackendIPCallCount() int { func (fake *FakeProxyEnvironment) DefaultBackendIPCallCount() int {
fake.defaultBackendIPMutex.RLock() fake.defaultBackendIPMutex.RLock()
defer fake.defaultBackendIPMutex.RUnlock() defer fake.defaultBackendIPMutex.RUnlock()
return len(fake.defaultBackendIPArgsForCall) return len(fake.defaultBackendIPArgsForCall)
} }
func (fake *FakeEnvironment) DefaultBackendIPCalls(stub func() string) { func (fake *FakeProxyEnvironment) DefaultBackendIPCalls(stub func() string) {
fake.defaultBackendIPMutex.Lock() fake.defaultBackendIPMutex.Lock()
defer fake.defaultBackendIPMutex.Unlock() defer fake.defaultBackendIPMutex.Unlock()
fake.DefaultBackendIPStub = stub fake.DefaultBackendIPStub = stub
} }
func (fake *FakeEnvironment) DefaultBackendIPReturns(result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendIPReturns(result1 string) {
fake.defaultBackendIPMutex.Lock() fake.defaultBackendIPMutex.Lock()
defer fake.defaultBackendIPMutex.Unlock() defer fake.defaultBackendIPMutex.Unlock()
fake.DefaultBackendIPStub = nil fake.DefaultBackendIPStub = nil
@ -429,7 +429,7 @@ func (fake *FakeEnvironment) DefaultBackendIPReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendIPReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendIPReturnsOnCall(i int, result1 string) {
fake.defaultBackendIPMutex.Lock() fake.defaultBackendIPMutex.Lock()
defer fake.defaultBackendIPMutex.Unlock() defer fake.defaultBackendIPMutex.Unlock()
fake.DefaultBackendIPStub = nil fake.DefaultBackendIPStub = nil
@ -443,7 +443,7 @@ func (fake *FakeEnvironment) DefaultBackendIPReturnsOnCall(i int, result1 string
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendRTC() string { func (fake *FakeProxyEnvironment) DefaultBackendRTC() string {
fake.defaultBackendRTCMutex.Lock() fake.defaultBackendRTCMutex.Lock()
ret, specificReturn := fake.defaultBackendRTCReturnsOnCall[len(fake.defaultBackendRTCArgsForCall)] ret, specificReturn := fake.defaultBackendRTCReturnsOnCall[len(fake.defaultBackendRTCArgsForCall)]
fake.defaultBackendRTCArgsForCall = append(fake.defaultBackendRTCArgsForCall, struct { fake.defaultBackendRTCArgsForCall = append(fake.defaultBackendRTCArgsForCall, struct {
@ -461,19 +461,19 @@ func (fake *FakeEnvironment) DefaultBackendRTC() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) DefaultBackendRTCCallCount() int { func (fake *FakeProxyEnvironment) DefaultBackendRTCCallCount() int {
fake.defaultBackendRTCMutex.RLock() fake.defaultBackendRTCMutex.RLock()
defer fake.defaultBackendRTCMutex.RUnlock() defer fake.defaultBackendRTCMutex.RUnlock()
return len(fake.defaultBackendRTCArgsForCall) return len(fake.defaultBackendRTCArgsForCall)
} }
func (fake *FakeEnvironment) DefaultBackendRTCCalls(stub func() string) { func (fake *FakeProxyEnvironment) DefaultBackendRTCCalls(stub func() string) {
fake.defaultBackendRTCMutex.Lock() fake.defaultBackendRTCMutex.Lock()
defer fake.defaultBackendRTCMutex.Unlock() defer fake.defaultBackendRTCMutex.Unlock()
fake.DefaultBackendRTCStub = stub fake.DefaultBackendRTCStub = stub
} }
func (fake *FakeEnvironment) DefaultBackendRTCReturns(result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendRTCReturns(result1 string) {
fake.defaultBackendRTCMutex.Lock() fake.defaultBackendRTCMutex.Lock()
defer fake.defaultBackendRTCMutex.Unlock() defer fake.defaultBackendRTCMutex.Unlock()
fake.DefaultBackendRTCStub = nil fake.DefaultBackendRTCStub = nil
@ -482,7 +482,7 @@ func (fake *FakeEnvironment) DefaultBackendRTCReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendRTCReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendRTCReturnsOnCall(i int, result1 string) {
fake.defaultBackendRTCMutex.Lock() fake.defaultBackendRTCMutex.Lock()
defer fake.defaultBackendRTCMutex.Unlock() defer fake.defaultBackendRTCMutex.Unlock()
fake.DefaultBackendRTCStub = nil fake.DefaultBackendRTCStub = nil
@ -496,7 +496,7 @@ func (fake *FakeEnvironment) DefaultBackendRTCReturnsOnCall(i int, result1 strin
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendRTMP() string { func (fake *FakeProxyEnvironment) DefaultBackendRTMP() string {
fake.defaultBackendRTMPMutex.Lock() fake.defaultBackendRTMPMutex.Lock()
ret, specificReturn := fake.defaultBackendRTMPReturnsOnCall[len(fake.defaultBackendRTMPArgsForCall)] ret, specificReturn := fake.defaultBackendRTMPReturnsOnCall[len(fake.defaultBackendRTMPArgsForCall)]
fake.defaultBackendRTMPArgsForCall = append(fake.defaultBackendRTMPArgsForCall, struct { fake.defaultBackendRTMPArgsForCall = append(fake.defaultBackendRTMPArgsForCall, struct {
@ -514,19 +514,19 @@ func (fake *FakeEnvironment) DefaultBackendRTMP() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) DefaultBackendRTMPCallCount() int { func (fake *FakeProxyEnvironment) DefaultBackendRTMPCallCount() int {
fake.defaultBackendRTMPMutex.RLock() fake.defaultBackendRTMPMutex.RLock()
defer fake.defaultBackendRTMPMutex.RUnlock() defer fake.defaultBackendRTMPMutex.RUnlock()
return len(fake.defaultBackendRTMPArgsForCall) return len(fake.defaultBackendRTMPArgsForCall)
} }
func (fake *FakeEnvironment) DefaultBackendRTMPCalls(stub func() string) { func (fake *FakeProxyEnvironment) DefaultBackendRTMPCalls(stub func() string) {
fake.defaultBackendRTMPMutex.Lock() fake.defaultBackendRTMPMutex.Lock()
defer fake.defaultBackendRTMPMutex.Unlock() defer fake.defaultBackendRTMPMutex.Unlock()
fake.DefaultBackendRTMPStub = stub fake.DefaultBackendRTMPStub = stub
} }
func (fake *FakeEnvironment) DefaultBackendRTMPReturns(result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendRTMPReturns(result1 string) {
fake.defaultBackendRTMPMutex.Lock() fake.defaultBackendRTMPMutex.Lock()
defer fake.defaultBackendRTMPMutex.Unlock() defer fake.defaultBackendRTMPMutex.Unlock()
fake.DefaultBackendRTMPStub = nil fake.DefaultBackendRTMPStub = nil
@ -535,7 +535,7 @@ func (fake *FakeEnvironment) DefaultBackendRTMPReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendRTMPReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendRTMPReturnsOnCall(i int, result1 string) {
fake.defaultBackendRTMPMutex.Lock() fake.defaultBackendRTMPMutex.Lock()
defer fake.defaultBackendRTMPMutex.Unlock() defer fake.defaultBackendRTMPMutex.Unlock()
fake.DefaultBackendRTMPStub = nil fake.DefaultBackendRTMPStub = nil
@ -549,7 +549,7 @@ func (fake *FakeEnvironment) DefaultBackendRTMPReturnsOnCall(i int, result1 stri
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendSRT() string { func (fake *FakeProxyEnvironment) DefaultBackendSRT() string {
fake.defaultBackendSRTMutex.Lock() fake.defaultBackendSRTMutex.Lock()
ret, specificReturn := fake.defaultBackendSRTReturnsOnCall[len(fake.defaultBackendSRTArgsForCall)] ret, specificReturn := fake.defaultBackendSRTReturnsOnCall[len(fake.defaultBackendSRTArgsForCall)]
fake.defaultBackendSRTArgsForCall = append(fake.defaultBackendSRTArgsForCall, struct { fake.defaultBackendSRTArgsForCall = append(fake.defaultBackendSRTArgsForCall, struct {
@ -567,19 +567,19 @@ func (fake *FakeEnvironment) DefaultBackendSRT() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) DefaultBackendSRTCallCount() int { func (fake *FakeProxyEnvironment) DefaultBackendSRTCallCount() int {
fake.defaultBackendSRTMutex.RLock() fake.defaultBackendSRTMutex.RLock()
defer fake.defaultBackendSRTMutex.RUnlock() defer fake.defaultBackendSRTMutex.RUnlock()
return len(fake.defaultBackendSRTArgsForCall) return len(fake.defaultBackendSRTArgsForCall)
} }
func (fake *FakeEnvironment) DefaultBackendSRTCalls(stub func() string) { func (fake *FakeProxyEnvironment) DefaultBackendSRTCalls(stub func() string) {
fake.defaultBackendSRTMutex.Lock() fake.defaultBackendSRTMutex.Lock()
defer fake.defaultBackendSRTMutex.Unlock() defer fake.defaultBackendSRTMutex.Unlock()
fake.DefaultBackendSRTStub = stub fake.DefaultBackendSRTStub = stub
} }
func (fake *FakeEnvironment) DefaultBackendSRTReturns(result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendSRTReturns(result1 string) {
fake.defaultBackendSRTMutex.Lock() fake.defaultBackendSRTMutex.Lock()
defer fake.defaultBackendSRTMutex.Unlock() defer fake.defaultBackendSRTMutex.Unlock()
fake.DefaultBackendSRTStub = nil fake.DefaultBackendSRTStub = nil
@ -588,7 +588,7 @@ func (fake *FakeEnvironment) DefaultBackendSRTReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) DefaultBackendSRTReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) DefaultBackendSRTReturnsOnCall(i int, result1 string) {
fake.defaultBackendSRTMutex.Lock() fake.defaultBackendSRTMutex.Lock()
defer fake.defaultBackendSRTMutex.Unlock() defer fake.defaultBackendSRTMutex.Unlock()
fake.DefaultBackendSRTStub = nil fake.DefaultBackendSRTStub = nil
@ -602,7 +602,7 @@ func (fake *FakeEnvironment) DefaultBackendSRTReturnsOnCall(i int, result1 strin
}{result1} }{result1}
} }
func (fake *FakeEnvironment) ForceQuitTimeout() string { func (fake *FakeProxyEnvironment) ForceQuitTimeout() string {
fake.forceQuitTimeoutMutex.Lock() fake.forceQuitTimeoutMutex.Lock()
ret, specificReturn := fake.forceQuitTimeoutReturnsOnCall[len(fake.forceQuitTimeoutArgsForCall)] ret, specificReturn := fake.forceQuitTimeoutReturnsOnCall[len(fake.forceQuitTimeoutArgsForCall)]
fake.forceQuitTimeoutArgsForCall = append(fake.forceQuitTimeoutArgsForCall, struct { fake.forceQuitTimeoutArgsForCall = append(fake.forceQuitTimeoutArgsForCall, struct {
@ -620,19 +620,19 @@ func (fake *FakeEnvironment) ForceQuitTimeout() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) ForceQuitTimeoutCallCount() int { func (fake *FakeProxyEnvironment) ForceQuitTimeoutCallCount() int {
fake.forceQuitTimeoutMutex.RLock() fake.forceQuitTimeoutMutex.RLock()
defer fake.forceQuitTimeoutMutex.RUnlock() defer fake.forceQuitTimeoutMutex.RUnlock()
return len(fake.forceQuitTimeoutArgsForCall) return len(fake.forceQuitTimeoutArgsForCall)
} }
func (fake *FakeEnvironment) ForceQuitTimeoutCalls(stub func() string) { func (fake *FakeProxyEnvironment) ForceQuitTimeoutCalls(stub func() string) {
fake.forceQuitTimeoutMutex.Lock() fake.forceQuitTimeoutMutex.Lock()
defer fake.forceQuitTimeoutMutex.Unlock() defer fake.forceQuitTimeoutMutex.Unlock()
fake.ForceQuitTimeoutStub = stub fake.ForceQuitTimeoutStub = stub
} }
func (fake *FakeEnvironment) ForceQuitTimeoutReturns(result1 string) { func (fake *FakeProxyEnvironment) ForceQuitTimeoutReturns(result1 string) {
fake.forceQuitTimeoutMutex.Lock() fake.forceQuitTimeoutMutex.Lock()
defer fake.forceQuitTimeoutMutex.Unlock() defer fake.forceQuitTimeoutMutex.Unlock()
fake.ForceQuitTimeoutStub = nil fake.ForceQuitTimeoutStub = nil
@ -641,7 +641,7 @@ func (fake *FakeEnvironment) ForceQuitTimeoutReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) ForceQuitTimeoutReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) ForceQuitTimeoutReturnsOnCall(i int, result1 string) {
fake.forceQuitTimeoutMutex.Lock() fake.forceQuitTimeoutMutex.Lock()
defer fake.forceQuitTimeoutMutex.Unlock() defer fake.forceQuitTimeoutMutex.Unlock()
fake.ForceQuitTimeoutStub = nil fake.ForceQuitTimeoutStub = nil
@ -655,7 +655,7 @@ func (fake *FakeEnvironment) ForceQuitTimeoutReturnsOnCall(i int, result1 string
}{result1} }{result1}
} }
func (fake *FakeEnvironment) GoPprof() string { func (fake *FakeProxyEnvironment) GoPprof() string {
fake.goPprofMutex.Lock() fake.goPprofMutex.Lock()
ret, specificReturn := fake.goPprofReturnsOnCall[len(fake.goPprofArgsForCall)] ret, specificReturn := fake.goPprofReturnsOnCall[len(fake.goPprofArgsForCall)]
fake.goPprofArgsForCall = append(fake.goPprofArgsForCall, struct { fake.goPprofArgsForCall = append(fake.goPprofArgsForCall, struct {
@ -673,19 +673,19 @@ func (fake *FakeEnvironment) GoPprof() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) GoPprofCallCount() int { func (fake *FakeProxyEnvironment) GoPprofCallCount() int {
fake.goPprofMutex.RLock() fake.goPprofMutex.RLock()
defer fake.goPprofMutex.RUnlock() defer fake.goPprofMutex.RUnlock()
return len(fake.goPprofArgsForCall) return len(fake.goPprofArgsForCall)
} }
func (fake *FakeEnvironment) GoPprofCalls(stub func() string) { func (fake *FakeProxyEnvironment) GoPprofCalls(stub func() string) {
fake.goPprofMutex.Lock() fake.goPprofMutex.Lock()
defer fake.goPprofMutex.Unlock() defer fake.goPprofMutex.Unlock()
fake.GoPprofStub = stub fake.GoPprofStub = stub
} }
func (fake *FakeEnvironment) GoPprofReturns(result1 string) { func (fake *FakeProxyEnvironment) GoPprofReturns(result1 string) {
fake.goPprofMutex.Lock() fake.goPprofMutex.Lock()
defer fake.goPprofMutex.Unlock() defer fake.goPprofMutex.Unlock()
fake.GoPprofStub = nil fake.GoPprofStub = nil
@ -694,7 +694,7 @@ func (fake *FakeEnvironment) GoPprofReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) GoPprofReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) GoPprofReturnsOnCall(i int, result1 string) {
fake.goPprofMutex.Lock() fake.goPprofMutex.Lock()
defer fake.goPprofMutex.Unlock() defer fake.goPprofMutex.Unlock()
fake.GoPprofStub = nil fake.GoPprofStub = nil
@ -708,7 +708,7 @@ func (fake *FakeEnvironment) GoPprofReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) GraceQuitTimeout() string { func (fake *FakeProxyEnvironment) GraceQuitTimeout() string {
fake.graceQuitTimeoutMutex.Lock() fake.graceQuitTimeoutMutex.Lock()
ret, specificReturn := fake.graceQuitTimeoutReturnsOnCall[len(fake.graceQuitTimeoutArgsForCall)] ret, specificReturn := fake.graceQuitTimeoutReturnsOnCall[len(fake.graceQuitTimeoutArgsForCall)]
fake.graceQuitTimeoutArgsForCall = append(fake.graceQuitTimeoutArgsForCall, struct { fake.graceQuitTimeoutArgsForCall = append(fake.graceQuitTimeoutArgsForCall, struct {
@ -726,19 +726,19 @@ func (fake *FakeEnvironment) GraceQuitTimeout() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) GraceQuitTimeoutCallCount() int { func (fake *FakeProxyEnvironment) GraceQuitTimeoutCallCount() int {
fake.graceQuitTimeoutMutex.RLock() fake.graceQuitTimeoutMutex.RLock()
defer fake.graceQuitTimeoutMutex.RUnlock() defer fake.graceQuitTimeoutMutex.RUnlock()
return len(fake.graceQuitTimeoutArgsForCall) return len(fake.graceQuitTimeoutArgsForCall)
} }
func (fake *FakeEnvironment) GraceQuitTimeoutCalls(stub func() string) { func (fake *FakeProxyEnvironment) GraceQuitTimeoutCalls(stub func() string) {
fake.graceQuitTimeoutMutex.Lock() fake.graceQuitTimeoutMutex.Lock()
defer fake.graceQuitTimeoutMutex.Unlock() defer fake.graceQuitTimeoutMutex.Unlock()
fake.GraceQuitTimeoutStub = stub fake.GraceQuitTimeoutStub = stub
} }
func (fake *FakeEnvironment) GraceQuitTimeoutReturns(result1 string) { func (fake *FakeProxyEnvironment) GraceQuitTimeoutReturns(result1 string) {
fake.graceQuitTimeoutMutex.Lock() fake.graceQuitTimeoutMutex.Lock()
defer fake.graceQuitTimeoutMutex.Unlock() defer fake.graceQuitTimeoutMutex.Unlock()
fake.GraceQuitTimeoutStub = nil fake.GraceQuitTimeoutStub = nil
@ -747,7 +747,7 @@ func (fake *FakeEnvironment) GraceQuitTimeoutReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) GraceQuitTimeoutReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) GraceQuitTimeoutReturnsOnCall(i int, result1 string) {
fake.graceQuitTimeoutMutex.Lock() fake.graceQuitTimeoutMutex.Lock()
defer fake.graceQuitTimeoutMutex.Unlock() defer fake.graceQuitTimeoutMutex.Unlock()
fake.GraceQuitTimeoutStub = nil fake.GraceQuitTimeoutStub = nil
@ -761,7 +761,7 @@ func (fake *FakeEnvironment) GraceQuitTimeoutReturnsOnCall(i int, result1 string
}{result1} }{result1}
} }
func (fake *FakeEnvironment) HttpAPI() string { func (fake *FakeProxyEnvironment) HttpAPI() string {
fake.httpAPIMutex.Lock() fake.httpAPIMutex.Lock()
ret, specificReturn := fake.httpAPIReturnsOnCall[len(fake.httpAPIArgsForCall)] ret, specificReturn := fake.httpAPIReturnsOnCall[len(fake.httpAPIArgsForCall)]
fake.httpAPIArgsForCall = append(fake.httpAPIArgsForCall, struct { fake.httpAPIArgsForCall = append(fake.httpAPIArgsForCall, struct {
@ -779,19 +779,19 @@ func (fake *FakeEnvironment) HttpAPI() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) HttpAPICallCount() int { func (fake *FakeProxyEnvironment) HttpAPICallCount() int {
fake.httpAPIMutex.RLock() fake.httpAPIMutex.RLock()
defer fake.httpAPIMutex.RUnlock() defer fake.httpAPIMutex.RUnlock()
return len(fake.httpAPIArgsForCall) return len(fake.httpAPIArgsForCall)
} }
func (fake *FakeEnvironment) HttpAPICalls(stub func() string) { func (fake *FakeProxyEnvironment) HttpAPICalls(stub func() string) {
fake.httpAPIMutex.Lock() fake.httpAPIMutex.Lock()
defer fake.httpAPIMutex.Unlock() defer fake.httpAPIMutex.Unlock()
fake.HttpAPIStub = stub fake.HttpAPIStub = stub
} }
func (fake *FakeEnvironment) HttpAPIReturns(result1 string) { func (fake *FakeProxyEnvironment) HttpAPIReturns(result1 string) {
fake.httpAPIMutex.Lock() fake.httpAPIMutex.Lock()
defer fake.httpAPIMutex.Unlock() defer fake.httpAPIMutex.Unlock()
fake.HttpAPIStub = nil fake.HttpAPIStub = nil
@ -800,7 +800,7 @@ func (fake *FakeEnvironment) HttpAPIReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) HttpAPIReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) HttpAPIReturnsOnCall(i int, result1 string) {
fake.httpAPIMutex.Lock() fake.httpAPIMutex.Lock()
defer fake.httpAPIMutex.Unlock() defer fake.httpAPIMutex.Unlock()
fake.HttpAPIStub = nil fake.HttpAPIStub = nil
@ -814,7 +814,7 @@ func (fake *FakeEnvironment) HttpAPIReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) HttpServer() string { func (fake *FakeProxyEnvironment) HttpServer() string {
fake.httpServerMutex.Lock() fake.httpServerMutex.Lock()
ret, specificReturn := fake.httpServerReturnsOnCall[len(fake.httpServerArgsForCall)] ret, specificReturn := fake.httpServerReturnsOnCall[len(fake.httpServerArgsForCall)]
fake.httpServerArgsForCall = append(fake.httpServerArgsForCall, struct { fake.httpServerArgsForCall = append(fake.httpServerArgsForCall, struct {
@ -832,19 +832,19 @@ func (fake *FakeEnvironment) HttpServer() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) HttpServerCallCount() int { func (fake *FakeProxyEnvironment) HttpServerCallCount() int {
fake.httpServerMutex.RLock() fake.httpServerMutex.RLock()
defer fake.httpServerMutex.RUnlock() defer fake.httpServerMutex.RUnlock()
return len(fake.httpServerArgsForCall) return len(fake.httpServerArgsForCall)
} }
func (fake *FakeEnvironment) HttpServerCalls(stub func() string) { func (fake *FakeProxyEnvironment) HttpServerCalls(stub func() string) {
fake.httpServerMutex.Lock() fake.httpServerMutex.Lock()
defer fake.httpServerMutex.Unlock() defer fake.httpServerMutex.Unlock()
fake.HttpServerStub = stub fake.HttpServerStub = stub
} }
func (fake *FakeEnvironment) HttpServerReturns(result1 string) { func (fake *FakeProxyEnvironment) HttpServerReturns(result1 string) {
fake.httpServerMutex.Lock() fake.httpServerMutex.Lock()
defer fake.httpServerMutex.Unlock() defer fake.httpServerMutex.Unlock()
fake.HttpServerStub = nil fake.HttpServerStub = nil
@ -853,7 +853,7 @@ func (fake *FakeEnvironment) HttpServerReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) HttpServerReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) HttpServerReturnsOnCall(i int, result1 string) {
fake.httpServerMutex.Lock() fake.httpServerMutex.Lock()
defer fake.httpServerMutex.Unlock() defer fake.httpServerMutex.Unlock()
fake.HttpServerStub = nil fake.HttpServerStub = nil
@ -867,7 +867,7 @@ func (fake *FakeEnvironment) HttpServerReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) LoadBalancerType() string { func (fake *FakeProxyEnvironment) LoadBalancerType() string {
fake.loadBalancerTypeMutex.Lock() fake.loadBalancerTypeMutex.Lock()
ret, specificReturn := fake.loadBalancerTypeReturnsOnCall[len(fake.loadBalancerTypeArgsForCall)] ret, specificReturn := fake.loadBalancerTypeReturnsOnCall[len(fake.loadBalancerTypeArgsForCall)]
fake.loadBalancerTypeArgsForCall = append(fake.loadBalancerTypeArgsForCall, struct { fake.loadBalancerTypeArgsForCall = append(fake.loadBalancerTypeArgsForCall, struct {
@ -885,19 +885,19 @@ func (fake *FakeEnvironment) LoadBalancerType() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) LoadBalancerTypeCallCount() int { func (fake *FakeProxyEnvironment) LoadBalancerTypeCallCount() int {
fake.loadBalancerTypeMutex.RLock() fake.loadBalancerTypeMutex.RLock()
defer fake.loadBalancerTypeMutex.RUnlock() defer fake.loadBalancerTypeMutex.RUnlock()
return len(fake.loadBalancerTypeArgsForCall) return len(fake.loadBalancerTypeArgsForCall)
} }
func (fake *FakeEnvironment) LoadBalancerTypeCalls(stub func() string) { func (fake *FakeProxyEnvironment) LoadBalancerTypeCalls(stub func() string) {
fake.loadBalancerTypeMutex.Lock() fake.loadBalancerTypeMutex.Lock()
defer fake.loadBalancerTypeMutex.Unlock() defer fake.loadBalancerTypeMutex.Unlock()
fake.LoadBalancerTypeStub = stub fake.LoadBalancerTypeStub = stub
} }
func (fake *FakeEnvironment) LoadBalancerTypeReturns(result1 string) { func (fake *FakeProxyEnvironment) LoadBalancerTypeReturns(result1 string) {
fake.loadBalancerTypeMutex.Lock() fake.loadBalancerTypeMutex.Lock()
defer fake.loadBalancerTypeMutex.Unlock() defer fake.loadBalancerTypeMutex.Unlock()
fake.LoadBalancerTypeStub = nil fake.LoadBalancerTypeStub = nil
@ -906,7 +906,7 @@ func (fake *FakeEnvironment) LoadBalancerTypeReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) LoadBalancerTypeReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) LoadBalancerTypeReturnsOnCall(i int, result1 string) {
fake.loadBalancerTypeMutex.Lock() fake.loadBalancerTypeMutex.Lock()
defer fake.loadBalancerTypeMutex.Unlock() defer fake.loadBalancerTypeMutex.Unlock()
fake.LoadBalancerTypeStub = nil fake.LoadBalancerTypeStub = nil
@ -920,7 +920,7 @@ func (fake *FakeEnvironment) LoadBalancerTypeReturnsOnCall(i int, result1 string
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisDB() string { func (fake *FakeProxyEnvironment) RedisDB() string {
fake.redisDBMutex.Lock() fake.redisDBMutex.Lock()
ret, specificReturn := fake.redisDBReturnsOnCall[len(fake.redisDBArgsForCall)] ret, specificReturn := fake.redisDBReturnsOnCall[len(fake.redisDBArgsForCall)]
fake.redisDBArgsForCall = append(fake.redisDBArgsForCall, struct { fake.redisDBArgsForCall = append(fake.redisDBArgsForCall, struct {
@ -938,19 +938,19 @@ func (fake *FakeEnvironment) RedisDB() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) RedisDBCallCount() int { func (fake *FakeProxyEnvironment) RedisDBCallCount() int {
fake.redisDBMutex.RLock() fake.redisDBMutex.RLock()
defer fake.redisDBMutex.RUnlock() defer fake.redisDBMutex.RUnlock()
return len(fake.redisDBArgsForCall) return len(fake.redisDBArgsForCall)
} }
func (fake *FakeEnvironment) RedisDBCalls(stub func() string) { func (fake *FakeProxyEnvironment) RedisDBCalls(stub func() string) {
fake.redisDBMutex.Lock() fake.redisDBMutex.Lock()
defer fake.redisDBMutex.Unlock() defer fake.redisDBMutex.Unlock()
fake.RedisDBStub = stub fake.RedisDBStub = stub
} }
func (fake *FakeEnvironment) RedisDBReturns(result1 string) { func (fake *FakeProxyEnvironment) RedisDBReturns(result1 string) {
fake.redisDBMutex.Lock() fake.redisDBMutex.Lock()
defer fake.redisDBMutex.Unlock() defer fake.redisDBMutex.Unlock()
fake.RedisDBStub = nil fake.RedisDBStub = nil
@ -959,7 +959,7 @@ func (fake *FakeEnvironment) RedisDBReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisDBReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) RedisDBReturnsOnCall(i int, result1 string) {
fake.redisDBMutex.Lock() fake.redisDBMutex.Lock()
defer fake.redisDBMutex.Unlock() defer fake.redisDBMutex.Unlock()
fake.RedisDBStub = nil fake.RedisDBStub = nil
@ -973,7 +973,7 @@ func (fake *FakeEnvironment) RedisDBReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisHost() string { func (fake *FakeProxyEnvironment) RedisHost() string {
fake.redisHostMutex.Lock() fake.redisHostMutex.Lock()
ret, specificReturn := fake.redisHostReturnsOnCall[len(fake.redisHostArgsForCall)] ret, specificReturn := fake.redisHostReturnsOnCall[len(fake.redisHostArgsForCall)]
fake.redisHostArgsForCall = append(fake.redisHostArgsForCall, struct { fake.redisHostArgsForCall = append(fake.redisHostArgsForCall, struct {
@ -991,19 +991,19 @@ func (fake *FakeEnvironment) RedisHost() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) RedisHostCallCount() int { func (fake *FakeProxyEnvironment) RedisHostCallCount() int {
fake.redisHostMutex.RLock() fake.redisHostMutex.RLock()
defer fake.redisHostMutex.RUnlock() defer fake.redisHostMutex.RUnlock()
return len(fake.redisHostArgsForCall) return len(fake.redisHostArgsForCall)
} }
func (fake *FakeEnvironment) RedisHostCalls(stub func() string) { func (fake *FakeProxyEnvironment) RedisHostCalls(stub func() string) {
fake.redisHostMutex.Lock() fake.redisHostMutex.Lock()
defer fake.redisHostMutex.Unlock() defer fake.redisHostMutex.Unlock()
fake.RedisHostStub = stub fake.RedisHostStub = stub
} }
func (fake *FakeEnvironment) RedisHostReturns(result1 string) { func (fake *FakeProxyEnvironment) RedisHostReturns(result1 string) {
fake.redisHostMutex.Lock() fake.redisHostMutex.Lock()
defer fake.redisHostMutex.Unlock() defer fake.redisHostMutex.Unlock()
fake.RedisHostStub = nil fake.RedisHostStub = nil
@ -1012,7 +1012,7 @@ func (fake *FakeEnvironment) RedisHostReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisHostReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) RedisHostReturnsOnCall(i int, result1 string) {
fake.redisHostMutex.Lock() fake.redisHostMutex.Lock()
defer fake.redisHostMutex.Unlock() defer fake.redisHostMutex.Unlock()
fake.RedisHostStub = nil fake.RedisHostStub = nil
@ -1026,7 +1026,7 @@ func (fake *FakeEnvironment) RedisHostReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisPassword() string { func (fake *FakeProxyEnvironment) RedisPassword() string {
fake.redisPasswordMutex.Lock() fake.redisPasswordMutex.Lock()
ret, specificReturn := fake.redisPasswordReturnsOnCall[len(fake.redisPasswordArgsForCall)] ret, specificReturn := fake.redisPasswordReturnsOnCall[len(fake.redisPasswordArgsForCall)]
fake.redisPasswordArgsForCall = append(fake.redisPasswordArgsForCall, struct { fake.redisPasswordArgsForCall = append(fake.redisPasswordArgsForCall, struct {
@ -1044,19 +1044,19 @@ func (fake *FakeEnvironment) RedisPassword() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) RedisPasswordCallCount() int { func (fake *FakeProxyEnvironment) RedisPasswordCallCount() int {
fake.redisPasswordMutex.RLock() fake.redisPasswordMutex.RLock()
defer fake.redisPasswordMutex.RUnlock() defer fake.redisPasswordMutex.RUnlock()
return len(fake.redisPasswordArgsForCall) return len(fake.redisPasswordArgsForCall)
} }
func (fake *FakeEnvironment) RedisPasswordCalls(stub func() string) { func (fake *FakeProxyEnvironment) RedisPasswordCalls(stub func() string) {
fake.redisPasswordMutex.Lock() fake.redisPasswordMutex.Lock()
defer fake.redisPasswordMutex.Unlock() defer fake.redisPasswordMutex.Unlock()
fake.RedisPasswordStub = stub fake.RedisPasswordStub = stub
} }
func (fake *FakeEnvironment) RedisPasswordReturns(result1 string) { func (fake *FakeProxyEnvironment) RedisPasswordReturns(result1 string) {
fake.redisPasswordMutex.Lock() fake.redisPasswordMutex.Lock()
defer fake.redisPasswordMutex.Unlock() defer fake.redisPasswordMutex.Unlock()
fake.RedisPasswordStub = nil fake.RedisPasswordStub = nil
@ -1065,7 +1065,7 @@ func (fake *FakeEnvironment) RedisPasswordReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisPasswordReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) RedisPasswordReturnsOnCall(i int, result1 string) {
fake.redisPasswordMutex.Lock() fake.redisPasswordMutex.Lock()
defer fake.redisPasswordMutex.Unlock() defer fake.redisPasswordMutex.Unlock()
fake.RedisPasswordStub = nil fake.RedisPasswordStub = nil
@ -1079,7 +1079,7 @@ func (fake *FakeEnvironment) RedisPasswordReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisPort() string { func (fake *FakeProxyEnvironment) RedisPort() string {
fake.redisPortMutex.Lock() fake.redisPortMutex.Lock()
ret, specificReturn := fake.redisPortReturnsOnCall[len(fake.redisPortArgsForCall)] ret, specificReturn := fake.redisPortReturnsOnCall[len(fake.redisPortArgsForCall)]
fake.redisPortArgsForCall = append(fake.redisPortArgsForCall, struct { fake.redisPortArgsForCall = append(fake.redisPortArgsForCall, struct {
@ -1097,19 +1097,19 @@ func (fake *FakeEnvironment) RedisPort() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) RedisPortCallCount() int { func (fake *FakeProxyEnvironment) RedisPortCallCount() int {
fake.redisPortMutex.RLock() fake.redisPortMutex.RLock()
defer fake.redisPortMutex.RUnlock() defer fake.redisPortMutex.RUnlock()
return len(fake.redisPortArgsForCall) return len(fake.redisPortArgsForCall)
} }
func (fake *FakeEnvironment) RedisPortCalls(stub func() string) { func (fake *FakeProxyEnvironment) RedisPortCalls(stub func() string) {
fake.redisPortMutex.Lock() fake.redisPortMutex.Lock()
defer fake.redisPortMutex.Unlock() defer fake.redisPortMutex.Unlock()
fake.RedisPortStub = stub fake.RedisPortStub = stub
} }
func (fake *FakeEnvironment) RedisPortReturns(result1 string) { func (fake *FakeProxyEnvironment) RedisPortReturns(result1 string) {
fake.redisPortMutex.Lock() fake.redisPortMutex.Lock()
defer fake.redisPortMutex.Unlock() defer fake.redisPortMutex.Unlock()
fake.RedisPortStub = nil fake.RedisPortStub = nil
@ -1118,7 +1118,7 @@ func (fake *FakeEnvironment) RedisPortReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RedisPortReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) RedisPortReturnsOnCall(i int, result1 string) {
fake.redisPortMutex.Lock() fake.redisPortMutex.Lock()
defer fake.redisPortMutex.Unlock() defer fake.redisPortMutex.Unlock()
fake.RedisPortStub = nil fake.RedisPortStub = nil
@ -1132,7 +1132,7 @@ func (fake *FakeEnvironment) RedisPortReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RtmpServer() string { func (fake *FakeProxyEnvironment) RtmpServer() string {
fake.rtmpServerMutex.Lock() fake.rtmpServerMutex.Lock()
ret, specificReturn := fake.rtmpServerReturnsOnCall[len(fake.rtmpServerArgsForCall)] ret, specificReturn := fake.rtmpServerReturnsOnCall[len(fake.rtmpServerArgsForCall)]
fake.rtmpServerArgsForCall = append(fake.rtmpServerArgsForCall, struct { fake.rtmpServerArgsForCall = append(fake.rtmpServerArgsForCall, struct {
@ -1150,19 +1150,19 @@ func (fake *FakeEnvironment) RtmpServer() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) RtmpServerCallCount() int { func (fake *FakeProxyEnvironment) RtmpServerCallCount() int {
fake.rtmpServerMutex.RLock() fake.rtmpServerMutex.RLock()
defer fake.rtmpServerMutex.RUnlock() defer fake.rtmpServerMutex.RUnlock()
return len(fake.rtmpServerArgsForCall) return len(fake.rtmpServerArgsForCall)
} }
func (fake *FakeEnvironment) RtmpServerCalls(stub func() string) { func (fake *FakeProxyEnvironment) RtmpServerCalls(stub func() string) {
fake.rtmpServerMutex.Lock() fake.rtmpServerMutex.Lock()
defer fake.rtmpServerMutex.Unlock() defer fake.rtmpServerMutex.Unlock()
fake.RtmpServerStub = stub fake.RtmpServerStub = stub
} }
func (fake *FakeEnvironment) RtmpServerReturns(result1 string) { func (fake *FakeProxyEnvironment) RtmpServerReturns(result1 string) {
fake.rtmpServerMutex.Lock() fake.rtmpServerMutex.Lock()
defer fake.rtmpServerMutex.Unlock() defer fake.rtmpServerMutex.Unlock()
fake.RtmpServerStub = nil fake.RtmpServerStub = nil
@ -1171,7 +1171,7 @@ func (fake *FakeEnvironment) RtmpServerReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) RtmpServerReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) RtmpServerReturnsOnCall(i int, result1 string) {
fake.rtmpServerMutex.Lock() fake.rtmpServerMutex.Lock()
defer fake.rtmpServerMutex.Unlock() defer fake.rtmpServerMutex.Unlock()
fake.RtmpServerStub = nil fake.RtmpServerStub = nil
@ -1185,7 +1185,7 @@ func (fake *FakeEnvironment) RtmpServerReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) SRTServer() string { func (fake *FakeProxyEnvironment) SRTServer() string {
fake.sRTServerMutex.Lock() fake.sRTServerMutex.Lock()
ret, specificReturn := fake.sRTServerReturnsOnCall[len(fake.sRTServerArgsForCall)] ret, specificReturn := fake.sRTServerReturnsOnCall[len(fake.sRTServerArgsForCall)]
fake.sRTServerArgsForCall = append(fake.sRTServerArgsForCall, struct { fake.sRTServerArgsForCall = append(fake.sRTServerArgsForCall, struct {
@ -1203,19 +1203,19 @@ func (fake *FakeEnvironment) SRTServer() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) SRTServerCallCount() int { func (fake *FakeProxyEnvironment) SRTServerCallCount() int {
fake.sRTServerMutex.RLock() fake.sRTServerMutex.RLock()
defer fake.sRTServerMutex.RUnlock() defer fake.sRTServerMutex.RUnlock()
return len(fake.sRTServerArgsForCall) return len(fake.sRTServerArgsForCall)
} }
func (fake *FakeEnvironment) SRTServerCalls(stub func() string) { func (fake *FakeProxyEnvironment) SRTServerCalls(stub func() string) {
fake.sRTServerMutex.Lock() fake.sRTServerMutex.Lock()
defer fake.sRTServerMutex.Unlock() defer fake.sRTServerMutex.Unlock()
fake.SRTServerStub = stub fake.SRTServerStub = stub
} }
func (fake *FakeEnvironment) SRTServerReturns(result1 string) { func (fake *FakeProxyEnvironment) SRTServerReturns(result1 string) {
fake.sRTServerMutex.Lock() fake.sRTServerMutex.Lock()
defer fake.sRTServerMutex.Unlock() defer fake.sRTServerMutex.Unlock()
fake.SRTServerStub = nil fake.SRTServerStub = nil
@ -1224,7 +1224,7 @@ func (fake *FakeEnvironment) SRTServerReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) SRTServerReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) SRTServerReturnsOnCall(i int, result1 string) {
fake.sRTServerMutex.Lock() fake.sRTServerMutex.Lock()
defer fake.sRTServerMutex.Unlock() defer fake.sRTServerMutex.Unlock()
fake.SRTServerStub = nil fake.SRTServerStub = nil
@ -1238,7 +1238,7 @@ func (fake *FakeEnvironment) SRTServerReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) StaticFiles() string { func (fake *FakeProxyEnvironment) StaticFiles() string {
fake.staticFilesMutex.Lock() fake.staticFilesMutex.Lock()
ret, specificReturn := fake.staticFilesReturnsOnCall[len(fake.staticFilesArgsForCall)] ret, specificReturn := fake.staticFilesReturnsOnCall[len(fake.staticFilesArgsForCall)]
fake.staticFilesArgsForCall = append(fake.staticFilesArgsForCall, struct { fake.staticFilesArgsForCall = append(fake.staticFilesArgsForCall, struct {
@ -1256,19 +1256,19 @@ func (fake *FakeEnvironment) StaticFiles() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) StaticFilesCallCount() int { func (fake *FakeProxyEnvironment) StaticFilesCallCount() int {
fake.staticFilesMutex.RLock() fake.staticFilesMutex.RLock()
defer fake.staticFilesMutex.RUnlock() defer fake.staticFilesMutex.RUnlock()
return len(fake.staticFilesArgsForCall) return len(fake.staticFilesArgsForCall)
} }
func (fake *FakeEnvironment) StaticFilesCalls(stub func() string) { func (fake *FakeProxyEnvironment) StaticFilesCalls(stub func() string) {
fake.staticFilesMutex.Lock() fake.staticFilesMutex.Lock()
defer fake.staticFilesMutex.Unlock() defer fake.staticFilesMutex.Unlock()
fake.StaticFilesStub = stub fake.StaticFilesStub = stub
} }
func (fake *FakeEnvironment) StaticFilesReturns(result1 string) { func (fake *FakeProxyEnvironment) StaticFilesReturns(result1 string) {
fake.staticFilesMutex.Lock() fake.staticFilesMutex.Lock()
defer fake.staticFilesMutex.Unlock() defer fake.staticFilesMutex.Unlock()
fake.StaticFilesStub = nil fake.StaticFilesStub = nil
@ -1277,7 +1277,7 @@ func (fake *FakeEnvironment) StaticFilesReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) StaticFilesReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) StaticFilesReturnsOnCall(i int, result1 string) {
fake.staticFilesMutex.Lock() fake.staticFilesMutex.Lock()
defer fake.staticFilesMutex.Unlock() defer fake.staticFilesMutex.Unlock()
fake.StaticFilesStub = nil fake.StaticFilesStub = nil
@ -1291,7 +1291,7 @@ func (fake *FakeEnvironment) StaticFilesReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) SystemAPI() string { func (fake *FakeProxyEnvironment) SystemAPI() string {
fake.systemAPIMutex.Lock() fake.systemAPIMutex.Lock()
ret, specificReturn := fake.systemAPIReturnsOnCall[len(fake.systemAPIArgsForCall)] ret, specificReturn := fake.systemAPIReturnsOnCall[len(fake.systemAPIArgsForCall)]
fake.systemAPIArgsForCall = append(fake.systemAPIArgsForCall, struct { fake.systemAPIArgsForCall = append(fake.systemAPIArgsForCall, struct {
@ -1309,19 +1309,19 @@ func (fake *FakeEnvironment) SystemAPI() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) SystemAPICallCount() int { func (fake *FakeProxyEnvironment) SystemAPICallCount() int {
fake.systemAPIMutex.RLock() fake.systemAPIMutex.RLock()
defer fake.systemAPIMutex.RUnlock() defer fake.systemAPIMutex.RUnlock()
return len(fake.systemAPIArgsForCall) return len(fake.systemAPIArgsForCall)
} }
func (fake *FakeEnvironment) SystemAPICalls(stub func() string) { func (fake *FakeProxyEnvironment) SystemAPICalls(stub func() string) {
fake.systemAPIMutex.Lock() fake.systemAPIMutex.Lock()
defer fake.systemAPIMutex.Unlock() defer fake.systemAPIMutex.Unlock()
fake.SystemAPIStub = stub fake.SystemAPIStub = stub
} }
func (fake *FakeEnvironment) SystemAPIReturns(result1 string) { func (fake *FakeProxyEnvironment) SystemAPIReturns(result1 string) {
fake.systemAPIMutex.Lock() fake.systemAPIMutex.Lock()
defer fake.systemAPIMutex.Unlock() defer fake.systemAPIMutex.Unlock()
fake.SystemAPIStub = nil fake.SystemAPIStub = nil
@ -1330,7 +1330,7 @@ func (fake *FakeEnvironment) SystemAPIReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) SystemAPIReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) SystemAPIReturnsOnCall(i int, result1 string) {
fake.systemAPIMutex.Lock() fake.systemAPIMutex.Lock()
defer fake.systemAPIMutex.Unlock() defer fake.systemAPIMutex.Unlock()
fake.SystemAPIStub = nil fake.SystemAPIStub = nil
@ -1344,7 +1344,7 @@ func (fake *FakeEnvironment) SystemAPIReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) WebRTCServer() string { func (fake *FakeProxyEnvironment) WebRTCServer() string {
fake.webRTCServerMutex.Lock() fake.webRTCServerMutex.Lock()
ret, specificReturn := fake.webRTCServerReturnsOnCall[len(fake.webRTCServerArgsForCall)] ret, specificReturn := fake.webRTCServerReturnsOnCall[len(fake.webRTCServerArgsForCall)]
fake.webRTCServerArgsForCall = append(fake.webRTCServerArgsForCall, struct { fake.webRTCServerArgsForCall = append(fake.webRTCServerArgsForCall, struct {
@ -1362,19 +1362,19 @@ func (fake *FakeEnvironment) WebRTCServer() string {
return fakeReturns.result1 return fakeReturns.result1
} }
func (fake *FakeEnvironment) WebRTCServerCallCount() int { func (fake *FakeProxyEnvironment) WebRTCServerCallCount() int {
fake.webRTCServerMutex.RLock() fake.webRTCServerMutex.RLock()
defer fake.webRTCServerMutex.RUnlock() defer fake.webRTCServerMutex.RUnlock()
return len(fake.webRTCServerArgsForCall) return len(fake.webRTCServerArgsForCall)
} }
func (fake *FakeEnvironment) WebRTCServerCalls(stub func() string) { func (fake *FakeProxyEnvironment) WebRTCServerCalls(stub func() string) {
fake.webRTCServerMutex.Lock() fake.webRTCServerMutex.Lock()
defer fake.webRTCServerMutex.Unlock() defer fake.webRTCServerMutex.Unlock()
fake.WebRTCServerStub = stub fake.WebRTCServerStub = stub
} }
func (fake *FakeEnvironment) WebRTCServerReturns(result1 string) { func (fake *FakeProxyEnvironment) WebRTCServerReturns(result1 string) {
fake.webRTCServerMutex.Lock() fake.webRTCServerMutex.Lock()
defer fake.webRTCServerMutex.Unlock() defer fake.webRTCServerMutex.Unlock()
fake.WebRTCServerStub = nil fake.WebRTCServerStub = nil
@ -1383,7 +1383,7 @@ func (fake *FakeEnvironment) WebRTCServerReturns(result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) WebRTCServerReturnsOnCall(i int, result1 string) { func (fake *FakeProxyEnvironment) WebRTCServerReturnsOnCall(i int, result1 string) {
fake.webRTCServerMutex.Lock() fake.webRTCServerMutex.Lock()
defer fake.webRTCServerMutex.Unlock() defer fake.webRTCServerMutex.Unlock()
fake.WebRTCServerStub = nil fake.WebRTCServerStub = nil
@ -1397,7 +1397,7 @@ func (fake *FakeEnvironment) WebRTCServerReturnsOnCall(i int, result1 string) {
}{result1} }{result1}
} }
func (fake *FakeEnvironment) Invocations() map[string][][]interface{} { func (fake *FakeProxyEnvironment) Invocations() map[string][][]interface{} {
fake.invocationsMutex.RLock() fake.invocationsMutex.RLock()
defer fake.invocationsMutex.RUnlock() defer fake.invocationsMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{} copiedInvocations := map[string][][]interface{}{}
@ -1407,7 +1407,7 @@ func (fake *FakeEnvironment) Invocations() map[string][][]interface{} {
return copiedInvocations return copiedInvocations
} }
func (fake *FakeEnvironment) recordInvocation(key string, args []interface{}) { func (fake *FakeProxyEnvironment) recordInvocation(key string, args []interface{}) {
fake.invocationsMutex.Lock() fake.invocationsMutex.Lock()
defer fake.invocationsMutex.Unlock() defer fake.invocationsMutex.Unlock()
if fake.invocations == nil { if fake.invocations == nil {
@ -1419,4 +1419,4 @@ func (fake *FakeEnvironment) recordInvocation(key string, args []interface{}) {
fake.invocations[key] = append(fake.invocations[key], args) fake.invocations[key] = append(fake.invocations[key], args)
} }
var _ env.Environment = new(FakeEnvironment) var _ env.ProxyEnvironment = new(FakeProxyEnvironment)

2
internal/env/gen.go vendored
View File

@ -3,4 +3,4 @@
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
package env package env
//go:generate go tool counterfeiter -o envfakes/fake_environment.go . Environment //go:generate go tool counterfeiter -o envfakes/fake_proxy_environment.go . ProxyEnvironment

2
internal/lb/debug.go
View File

@ -13,7 +13,7 @@ import (
) )
// NewDefaultSRSForDebugging initialize the default SRS media server, for debugging only. // NewDefaultSRSForDebugging initialize the default SRS media server, for debugging only.
func NewDefaultSRSForDebugging(environment env.Environment) (*SRSServer, error) { func NewDefaultSRSForDebugging(environment env.ProxyEnvironment) (*SRSServer, error) {
if environment.DefaultBackendEnabled() != "on" { if environment.DefaultBackendEnabled() != "on" {
return nil, nil return nil, nil
} }

4
internal/lb/mem.go
View File

@ -18,7 +18,7 @@ import (
// MemoryLoadBalancer stores state in memory. // MemoryLoadBalancer stores state in memory.
type MemoryLoadBalancer struct { type MemoryLoadBalancer struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// All available SRS servers, key is server ID. // All available SRS servers, key is server ID.
servers sync.Map[string, *SRSServer] servers sync.Map[string, *SRSServer]
// The picked server to service client by specified stream URL, key is stream url. // The picked server to service client by specified stream URL, key is stream url.
@ -34,7 +34,7 @@ type MemoryLoadBalancer struct {
} }
// NewMemoryLoadBalancer creates a new memory-based load balancer. // NewMemoryLoadBalancer creates a new memory-based load balancer.
func NewMemoryLoadBalancer(environment env.Environment) SRSLoadBalancer { func NewMemoryLoadBalancer(environment env.ProxyEnvironment) SRSLoadBalancer {
return &MemoryLoadBalancer{ return &MemoryLoadBalancer{
environment: environment, environment: environment,
servers: sync.NewMap[string, *SRSServer](), servers: sync.NewMap[string, *SRSServer](),

4
internal/lb/redis.go
View File

@ -22,13 +22,13 @@ import (
// RedisLoadBalancer stores state in Redis. // RedisLoadBalancer stores state in Redis.
type RedisLoadBalancer struct { type RedisLoadBalancer struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// The redis client sdk. // The redis client sdk.
rdb *redis.Client rdb *redis.Client
} }
// NewRedisLoadBalancer creates a new Redis-based load balancer. // NewRedisLoadBalancer creates a new Redis-based load balancer.
func NewRedisLoadBalancer(environment env.Environment) SRSLoadBalancer { func NewRedisLoadBalancer(environment env.ProxyEnvironment) SRSLoadBalancer {
return &RedisLoadBalancer{ return &RedisLoadBalancer{
environment: environment, environment: environment,
} }

8
internal/protocol/api.go
View File

@ -24,7 +24,7 @@ import (
// to proxy other HTTP API of SRS like the streams and clients, etc. // to proxy other HTTP API of SRS like the streams and clients, etc.
type srsHTTPAPIServer struct { type srsHTTPAPIServer struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// The underlayer HTTP server. // The underlayer HTTP server.
server *http.Server server *http.Server
// The WebRTC server. // The WebRTC server.
@ -35,7 +35,7 @@ type srsHTTPAPIServer struct {
wg sync.WaitGroup wg sync.WaitGroup
} }
func NewSRSHTTPAPIServer(environment env.Environment, gracefulQuitTimeout time.Duration, rtc *srsWebRTCServer) *srsHTTPAPIServer { func NewSRSHTTPAPIServer(environment env.ProxyEnvironment, gracefulQuitTimeout time.Duration, rtc *srsWebRTCServer) *srsHTTPAPIServer {
v := &srsHTTPAPIServer{ v := &srsHTTPAPIServer{
environment: environment, environment: environment,
gracefulQuitTimeout: gracefulQuitTimeout, gracefulQuitTimeout: gracefulQuitTimeout,
@ -127,7 +127,7 @@ func (v *srsHTTPAPIServer) Run(ctx context.Context) error {
// for Prometheus metrics. // for Prometheus metrics.
type systemAPI struct { type systemAPI struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// The underlayer HTTP server. // The underlayer HTTP server.
server *http.Server server *http.Server
// The gracefully quit timeout, wait server to quit. // The gracefully quit timeout, wait server to quit.
@ -136,7 +136,7 @@ type systemAPI struct {
wg sync.WaitGroup wg sync.WaitGroup
} }
func NewSystemAPI(environment env.Environment, gracefulQuitTimeout time.Duration) *systemAPI { func NewSystemAPI(environment env.ProxyEnvironment, gracefulQuitTimeout time.Duration) *systemAPI {
v := &systemAPI{ v := &systemAPI{
environment: environment, environment: environment,
gracefulQuitTimeout: gracefulQuitTimeout, gracefulQuitTimeout: gracefulQuitTimeout,

4
internal/protocol/http.go
View File

@ -28,7 +28,7 @@ import (
// the request to the origin server. // the request to the origin server.
type srsHTTPStreamServer struct { type srsHTTPStreamServer struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// The underlayer HTTP server. // The underlayer HTTP server.
server *http.Server server *http.Server
// The gracefully quit timeout, wait server to quit. // The gracefully quit timeout, wait server to quit.
@ -37,7 +37,7 @@ type srsHTTPStreamServer struct {
wg stdSync.WaitGroup wg stdSync.WaitGroup
} }
func NewSRSHTTPStreamServer(environment env.Environment, gracefulQuitTimeout time.Duration) *srsHTTPStreamServer { func NewSRSHTTPStreamServer(environment env.ProxyEnvironment, gracefulQuitTimeout time.Duration) *srsHTTPStreamServer {
v := &srsHTTPStreamServer{ v := &srsHTTPStreamServer{
environment: environment, environment: environment,
gracefulQuitTimeout: gracefulQuitTimeout, gracefulQuitTimeout: gracefulQuitTimeout,

4
internal/protocol/rtc.go
View File

@ -28,7 +28,7 @@ import (
// SDP answer. // SDP answer.
type srsWebRTCServer struct { type srsWebRTCServer struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// The UDP listener for WebRTC server. // The UDP listener for WebRTC server.
listener *net.UDPConn listener *net.UDPConn
@ -44,7 +44,7 @@ type srsWebRTCServer struct {
wg stdSync.WaitGroup wg stdSync.WaitGroup
} }
func NewSRSWebRTCServer(environment env.Environment, opts ...func(*srsWebRTCServer)) *srsWebRTCServer { func NewSRSWebRTCServer(environment env.ProxyEnvironment, opts ...func(*srsWebRTCServer)) *srsWebRTCServer {
v := &srsWebRTCServer{ v := &srsWebRTCServer{
environment: environment, environment: environment,
usernames: sync.NewMap[string, *RTCConnection](), usernames: sync.NewMap[string, *RTCConnection](),

4
internal/protocol/rtmp.go
View File

@ -25,14 +25,14 @@ import (
// not cache the stream, but just proxy the stream to backend. // not cache the stream, but just proxy the stream to backend.
type srsRTMPServer struct { type srsRTMPServer struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// The TCP listener for RTMP server. // The TCP listener for RTMP server.
listener *net.TCPListener listener *net.TCPListener
// The wait group for all goroutines. // The wait group for all goroutines.
wg sync.WaitGroup wg sync.WaitGroup
} }
func NewSRSRTMPServer(environment env.Environment, opts ...func(*srsRTMPServer)) *srsRTMPServer { func NewSRSRTMPServer(environment env.ProxyEnvironment, opts ...func(*srsRTMPServer)) *srsRTMPServer {
v := &srsRTMPServer{environment: environment} v := &srsRTMPServer{environment: environment}
for _, opt := range opts { for _, opt := range opts {
opt(v) opt(v)

4
internal/protocol/srt.go
View File

@ -26,7 +26,7 @@ import (
// backend server. // backend server.
type srsSRTServer struct { type srsSRTServer struct {
// The environment interface. // The environment interface.
environment env.Environment environment env.ProxyEnvironment
// The UDP listener for SRT server. // The UDP listener for SRT server.
listener *net.UDPConn listener *net.UDPConn
@ -39,7 +39,7 @@ type srsSRTServer struct {
wg stdSync.WaitGroup wg stdSync.WaitGroup
} }
func NewSRSSRTServer(environment env.Environment, opts ...func(*srsSRTServer)) *srsSRTServer { func NewSRSSRTServer(environment env.ProxyEnvironment, opts ...func(*srsSRTServer)) *srsSRTServer {
v := &srsSRTServer{ v := &srsSRTServer{
environment: environment, environment: environment,
start: time.Now(), start: time.Now(),

2
internal/signal/signal.go
View File

@ -33,7 +33,7 @@ func InstallSignals(ctx context.Context, cancel context.CancelFunc) {
}() }()
} }
func InstallForceQuit(ctx context.Context, environment env.Environment) error { func InstallForceQuit(ctx context.Context, environment env.ProxyEnvironment) error {
var forceTimeout time.Duration var forceTimeout time.Duration
timeoutStr := environment.ForceQuitTimeout() timeoutStr := environment.ForceQuitTimeout()
if t, err := time.ParseDuration(timeoutStr); err != nil { if t, err := time.ParseDuration(timeoutStr); err != nil {

6
internal/signal/signal_test.go
View File

@ -102,7 +102,7 @@ func TestInstallSignals_HandlesRepeatedSignals(t *testing.T) {
} }
func TestInstallForceQuit_InvalidDurationReturnsError(t *testing.T) { func TestInstallForceQuit_InvalidDurationReturnsError(t *testing.T) {
fakeEnv := &envfakes.FakeEnvironment{} fakeEnv := &envfakes.FakeProxyEnvironment{}
fakeEnv.ForceQuitTimeoutReturns("not-a-duration") fakeEnv.ForceQuitTimeoutReturns("not-a-duration")
err := InstallForceQuit(t.Context(), fakeEnv) err := InstallForceQuit(t.Context(), fakeEnv)
@ -121,7 +121,7 @@ func TestInstallForceQuit_ExitsAfterTimeout(t *testing.T) {
called, done, restore := swapExit(t) called, done, restore := swapExit(t)
defer restore() defer restore()
fakeEnv := &envfakes.FakeEnvironment{} fakeEnv := &envfakes.FakeProxyEnvironment{}
fakeEnv.ForceQuitTimeoutReturns("1ms") fakeEnv.ForceQuitTimeoutReturns("1ms")
ctx, cancel := context.WithCancel(t.Context()) ctx, cancel := context.WithCancel(t.Context())
@ -149,7 +149,7 @@ func TestInstallForceQuit_WaitsForCancelBeforeSleeping(t *testing.T) {
called, done, restore := swapExit(t) called, done, restore := swapExit(t)
defer restore() defer restore()
fakeEnv := &envfakes.FakeEnvironment{} fakeEnv := &envfakes.FakeProxyEnvironment{}
fakeEnv.ForceQuitTimeoutReturns("10ms") fakeEnv.ForceQuitTimeoutReturns("10ms")
// Intentionally use a never-canceled context and leak the goroutine: // Intentionally use a never-canceled context and leak the goroutine: