From 3ba9bc0810191a8d285572729354099c5f31d334 Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Wed, 17 Sep 2025 15:38:49 +0000 Subject: [PATCH 1/9] Added basic HTTP test for proxy --- go.mod | 7 ++- proxy/proxy_test.go | 109 ++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 110 insertions(+), 6 deletions(-) diff --git a/go.mod b/go.mod index 638ddb7..4d634e8 100644 --- a/go.mod +++ b/go.mod @@ -2,12 +2,16 @@ module github.com/coder/boundary go 1.24 -require github.com/coder/serpent v0.10.0 +require ( + github.com/coder/serpent v0.10.0 + github.com/stretchr/testify v1.8.4 +) require ( cdr.dev/slog v1.6.2-0.20240126064726-20367d4aede6 // indirect github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect github.com/coder/pretty v0.0.0-20230908205945-e89ba86370e0 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/hashicorp/errwrap v1.1.0 // indirect github.com/hashicorp/go-multierror v1.1.1 // indirect github.com/kr/text v0.2.0 // indirect @@ -18,6 +22,7 @@ require ( github.com/muesli/termenv v0.15.2 // indirect github.com/pion/transport/v2 v2.0.0 // indirect github.com/pion/udp v0.1.4 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rivo/uniseg v0.4.4 // indirect github.com/spf13/pflag v1.0.5 // indirect go.opentelemetry.io/otel v1.19.0 // indirect diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go index dae1ad6..d688913 100644 --- a/proxy/proxy_test.go +++ b/proxy/proxy_test.go @@ -1,9 +1,108 @@ package proxy -import "testing" +import ( + "context" + "crypto/tls" + "io" + "log/slog" + "net/http" + "os" + "testing" + "time" -// Stub test file - tests removed -func TestStub(t *testing.T) { - // This is a stub test - t.Skip("stub test file") + "github.com/stretchr/testify/require" + + "github.com/coder/boundary/audit" + "github.com/coder/boundary/rules" +) + +// mockAuditor is a simple mock auditor for testing +type mockAuditor struct{} + +func (m *mockAuditor) AuditRequest(req audit.Request) { + // No-op for testing +} + +// TestProxyServerBasicHTTP tests basic HTTP request handling +func TestProxyServerBasicHTTP(t *testing.T) { + // Create test logger + logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{ + Level: slog.LevelDebug, + })) + + // Create test rules (allow all for testing) + testRules, err := rules.ParseAllowSpecs([]string{"*"}) + if err != nil { + t.Fatalf("Failed to parse test rules: %v", err) + } + + // Create rule engine + ruleEngine := rules.NewRuleEngine(testRules, logger) + + // Create mock auditor + auditor := &mockAuditor{} + + // Create TLS config (minimal for testing) + tlsConfig := &tls.Config{ + MinVersion: tls.VersionTLS12, + } + + // Create proxy server + server := NewProxyServer(Config{ + HTTPPort: 8080, + RuleEngine: ruleEngine, + Auditor: auditor, + Logger: logger, + TLSConfig: tlsConfig, + }) + + // Create context with timeout + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + + // Start server in goroutine + serverDone := make(chan error, 1) + go func() { + serverDone <- server.Start(ctx) + }() + + // Give server time to start + time.Sleep(100 * time.Millisecond) + + // Test basic HTTP request + t.Run("BasicHTTPRequest", func(t *testing.T) { + // Create HTTP client + client := &http.Client{ + Transport: &http.Transport{ + TLSClientConfig: &tls.Config{ + InsecureSkipVerify: true, // Skip cert verification for testing + }, + }, + Timeout: 5 * time.Second, + } + + // Make request to proxy + req, err := http.NewRequest("GET", "http://localhost:8080/todos/1", nil) + if err != nil { + t.Fatalf("Failed to create request: %v", err) + } + // Override the Host header + req.Host = "jsonplaceholder.typicode.com" + + // Make the request + resp, err := client.Do(req) + require.NoError(t, err) + + body, err := io.ReadAll(resp.Body) + require.NoError(t, err) + resp.Body.Close() + + expectedResponse := `{ + "userId": 1, + "id": 1, + "title": "delectus aut autem", + "completed": false +}` + require.Equal(t, expectedResponse, string(body)) + }) } From 04efcbc0ec2225ba9c10d5ded182c28385823677 Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Wed, 17 Sep 2025 20:37:47 +0000 Subject: [PATCH 2/9] Added basic HTTPS test for proxy --- proxy/proxy_test.go | 106 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 106 insertions(+) diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go index d688913..946d149 100644 --- a/proxy/proxy_test.go +++ b/proxy/proxy_test.go @@ -4,12 +4,16 @@ import ( "context" "crypto/tls" "io" + "log" "log/slog" "net/http" "os" + "os/user" + "strconv" "testing" "time" + boundary_tls "github.com/coder/boundary/tls" "github.com/stretchr/testify/require" "github.com/coder/boundary/audit" @@ -106,3 +110,105 @@ func TestProxyServerBasicHTTP(t *testing.T) { require.Equal(t, expectedResponse, string(body)) }) } + +// TestProxyServerBasicHTTPS tests basic HTTPS request handling +func TestProxyServerBasicHTTPS(t *testing.T) { + // Create test logger + logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{ + Level: slog.LevelDebug, + })) + + // Create test rules (allow all for testing) + testRules, err := rules.ParseAllowSpecs([]string{"*"}) + if err != nil { + t.Fatalf("Failed to parse test rules: %v", err) + } + + // Create rule engine + ruleEngine := rules.NewRuleEngine(testRules, logger) + + // Create mock auditor + auditor := &mockAuditor{} + + // Create TLS config (minimal for testing) + tlsConfig := &tls.Config{ + MinVersion: tls.VersionTLS12, + } + + currentUser, err := user.Current() + if err != nil { + log.Fatal(err) + } + + uid, _ := strconv.Atoi(currentUser.Uid) + gid, _ := strconv.Atoi(currentUser.Gid) + + // Create TLS certificate manager + certManager, err := boundary_tls.NewCertificateManager(boundary_tls.Config{ + Logger: logger, + ConfigDir: "/tmp/boundary", + Uid: uid, + Gid: gid, + }) + require.NoError(t, err) + + // Setup TLS to get cert path for jailer + tlsConfig, caCertPath, configDir, err := certManager.SetupTLSAndWriteCACert() + require.NoError(t, err) + _, _ = caCertPath, configDir + + // Create proxy server + server := NewProxyServer(Config{ + HTTPPort: 8080, + RuleEngine: ruleEngine, + Auditor: auditor, + Logger: logger, + TLSConfig: tlsConfig, + }) + + // Create context with timeout + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + + // Start server in goroutine + serverDone := make(chan error, 1) + go func() { + serverDone <- server.Start(ctx) + }() + + // Give server time to start + time.Sleep(100 * time.Millisecond) + + // Test basic HTTPS request + t.Run("BasicHTTPSRequest", func(t *testing.T) { + // Create HTTP client + client := &http.Client{ + Transport: &http.Transport{ + TLSClientConfig: &tls.Config{ + InsecureSkipVerify: true, // Skip cert verification for testing + }, + }, + Timeout: 5 * time.Second, + } + + // Make request to proxy + req, err := http.NewRequest("GET", "https://localhost:8080/api/v2", nil) + if err != nil { + t.Fatalf("Failed to create request: %v", err) + } + // Override the Host header + req.Host = "dev.coder.com" + + // Make the request + resp, err := client.Do(req) + require.NoError(t, err) + + body, err := io.ReadAll(resp.Body) + require.NoError(t, err) + resp.Body.Close() + + expectedResponse := `{"message":"👋"} +` + require.Equal(t, expectedResponse, string(body)) + }) +} From 6629cd3a182a22de3def43bf7f69c608f2e19103 Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Wed, 17 Sep 2025 20:38:58 +0000 Subject: [PATCH 3/9] fix: linter --- proxy/proxy_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go index 946d149..5683cf0 100644 --- a/proxy/proxy_test.go +++ b/proxy/proxy_test.go @@ -99,7 +99,7 @@ func TestProxyServerBasicHTTP(t *testing.T) { body, err := io.ReadAll(resp.Body) require.NoError(t, err) - resp.Body.Close() + require.NoError(t, resp.Body.Close()) expectedResponse := `{ "userId": 1, @@ -205,7 +205,7 @@ func TestProxyServerBasicHTTPS(t *testing.T) { body, err := io.ReadAll(resp.Body) require.NoError(t, err) - resp.Body.Close() + require.NoError(t, resp.Body.Close()) expectedResponse := `{"message":"👋"} ` From b2a65c836ac12ed53bc37416b8352c1776f8f067 Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Thu, 18 Sep 2025 13:20:39 +0000 Subject: [PATCH 4/9] refactor: server --- proxy/proxy.go | 39 +++++++++++++-------------------------- proxy/proxy_test.go | 12 ++++++++++++ 2 files changed, 25 insertions(+), 26 deletions(-) diff --git a/proxy/proxy.go b/proxy/proxy.go index 6328a38..e85c316 100644 --- a/proxy/proxy.go +++ b/proxy/proxy.go @@ -12,7 +12,6 @@ import ( "net/url" "strings" "sync" - "time" "github.com/coder/boundary/audit" "github.com/coder/boundary/rules" @@ -26,7 +25,7 @@ type Server struct { tlsConfig *tls.Config httpPort int - httpServer *http.Server + listener net.Listener } // Config holds configuration for the proxy server @@ -51,27 +50,22 @@ func NewProxyServer(config Config) *Server { // Start starts the HTTP proxy server with TLS termination capability func (p *Server) Start(ctx context.Context) error { - // Create HTTP server with TLS termination capability - p.httpServer = &http.Server{ - Addr: fmt.Sprintf(":%d", p.httpPort), - Handler: http.HandlerFunc(p.handleHTTPWithTLSTermination), - } - // Start HTTP server with custom listener for TLS detection go func() { p.logger.Info("Starting HTTP proxy with TLS termination", "port", p.httpPort) - listener, err := net.Listen("tcp", fmt.Sprintf(":%d", p.httpPort)) + var err error + p.listener, err = net.Listen("tcp", fmt.Sprintf(":%d", p.httpPort)) if err != nil { p.logger.Error("Failed to create HTTP listener", "error", err) return } for { - conn, err := listener.Accept() + conn, err := p.listener.Accept() if err != nil { select { case <-ctx.Done(): - err = listener.Close() + err = p.listener.Close() if err != nil { p.logger.Error("Failed to close listener", "error", err) } @@ -94,17 +88,17 @@ func (p *Server) Start(ctx context.Context) error { // Stops proxy server func (p *Server) Stop() error { - ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) - defer cancel() - - var httpErr error - if p.httpServer != nil { - httpErr = p.httpServer.Shutdown(ctx) + if p.listener == nil { + return nil } - if httpErr != nil { - return httpErr + err := p.listener.Close() + if err != nil { + p.logger.Error("Failed to close listener", "error", err) } + + fmt.Printf("STOP is finished\n") + return nil } @@ -479,13 +473,6 @@ func (p *Server) handleConnectionWithTLSDetection(conn net.Conn) { } } -// handleHTTPWithTLSTermination is the main handler (currently just delegates to regular HTTP) -func (p *Server) handleHTTPWithTLSTermination(w http.ResponseWriter, r *http.Request) { - // This handler is not used when we do custom connection handling - // All traffic goes through handleConnectionWithTLSDetection - p.handleHTTP(w, r) -} - // connectionWrapper lets us "unread" the peeked byte type connectionWrapper struct { net.Conn diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go index 5683cf0..c0f4cf2 100644 --- a/proxy/proxy_test.go +++ b/proxy/proxy_test.go @@ -109,6 +109,12 @@ func TestProxyServerBasicHTTP(t *testing.T) { }` require.Equal(t, expectedResponse, string(body)) }) + + err = server.Stop() + require.NoError(t, err) + cancel() + err = <-serverDone + require.NoError(t, err) } // TestProxyServerBasicHTTPS tests basic HTTPS request handling @@ -211,4 +217,10 @@ func TestProxyServerBasicHTTPS(t *testing.T) { ` require.Equal(t, expectedResponse, string(body)) }) + + err = server.Stop() + require.NoError(t, err) + cancel() + err = <-serverDone + require.NoError(t, err) } From 80604e34bf28bf5895c266110327d09a404205a9 Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Thu, 18 Sep 2025 13:22:47 +0000 Subject: [PATCH 5/9] fix: linter --- proxy/proxy_test.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go index c0f4cf2..f5dd753 100644 --- a/proxy/proxy_test.go +++ b/proxy/proxy_test.go @@ -136,11 +136,6 @@ func TestProxyServerBasicHTTPS(t *testing.T) { // Create mock auditor auditor := &mockAuditor{} - // Create TLS config (minimal for testing) - tlsConfig := &tls.Config{ - MinVersion: tls.VersionTLS12, - } - currentUser, err := user.Current() if err != nil { log.Fatal(err) From b9a418b5a20e0298e354010f8a36fe751bc78bf7 Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Thu, 18 Sep 2025 14:44:09 +0000 Subject: [PATCH 6/9] refactor: start/stop methods --- proxy/proxy.go | 48 +++++++++++++++++++++++++++------------------ proxy/proxy_test.go | 19 ++++-------------- 2 files changed, 33 insertions(+), 34 deletions(-) diff --git a/proxy/proxy.go b/proxy/proxy.go index e85c316..71ff1f3 100644 --- a/proxy/proxy.go +++ b/proxy/proxy.go @@ -2,8 +2,8 @@ package proxy import ( "bufio" - "context" "crypto/tls" + "errors" "fmt" "io" "log/slog" @@ -12,6 +12,7 @@ import ( "net/url" "strings" "sync" + "sync/atomic" "github.com/coder/boundary/audit" "github.com/coder/boundary/rules" @@ -24,6 +25,7 @@ type Server struct { logger *slog.Logger tlsConfig *tls.Config httpPort int + started atomic.Bool listener net.Listener } @@ -49,7 +51,12 @@ func NewProxyServer(config Config) *Server { } // Start starts the HTTP proxy server with TLS termination capability -func (p *Server) Start(ctx context.Context) error { +func (p *Server) Start() error { + if p.isStarted() { + return nil + } + p.started.Store(true) + // Start HTTP server with custom listener for TLS detection go func() { p.logger.Info("Starting HTTP proxy with TLS termination", "port", p.httpPort) @@ -62,18 +69,12 @@ func (p *Server) Start(ctx context.Context) error { for { conn, err := p.listener.Accept() + if err != nil && errors.Is(err, net.ErrClosed) && p.isStopped() { + return + } if err != nil { - select { - case <-ctx.Done(): - err = p.listener.Close() - if err != nil { - p.logger.Error("Failed to close listener", "error", err) - } - return - default: - p.logger.Error("Failed to accept connection", "error", err) - continue - } + p.logger.Error("Failed to accept connection", "error", err) + continue } // Handle connection with TLS detection @@ -81,27 +82,36 @@ func (p *Server) Start(ctx context.Context) error { } }() - // Wait for context cancellation - <-ctx.Done() - return p.Stop() + return nil } // Stops proxy server func (p *Server) Stop() error { - if p.listener == nil { + if p.isStopped() { return nil } + p.started.Store(false) + + if p.listener == nil { + return errors.New("listener is nil; server was not started") + } err := p.listener.Close() if err != nil { p.logger.Error("Failed to close listener", "error", err) } - fmt.Printf("STOP is finished\n") - return nil } +func (p *Server) isStarted() bool { + return p.started.Load() +} + +func (p *Server) isStopped() bool { + return !p.started.Load() +} + // handleHTTP handles regular HTTP requests and CONNECT tunneling func (p *Server) handleHTTP(w http.ResponseWriter, r *http.Request) { p.logger.Debug("handleHTTP called", "method", r.Method, "url", r.URL.String(), "host", r.Host) diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go index f5dd753..c9901eb 100644 --- a/proxy/proxy_test.go +++ b/proxy/proxy_test.go @@ -1,7 +1,6 @@ package proxy import ( - "context" "crypto/tls" "io" "log" @@ -31,7 +30,7 @@ func (m *mockAuditor) AuditRequest(req audit.Request) { func TestProxyServerBasicHTTP(t *testing.T) { // Create test logger logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{ - Level: slog.LevelDebug, + Level: slog.LevelError, })) // Create test rules (allow all for testing) @@ -60,14 +59,10 @@ func TestProxyServerBasicHTTP(t *testing.T) { TLSConfig: tlsConfig, }) - // Create context with timeout - ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) - defer cancel() - // Start server in goroutine serverDone := make(chan error, 1) go func() { - serverDone <- server.Start(ctx) + serverDone <- server.Start() }() // Give server time to start @@ -112,7 +107,6 @@ func TestProxyServerBasicHTTP(t *testing.T) { err = server.Stop() require.NoError(t, err) - cancel() err = <-serverDone require.NoError(t, err) } @@ -121,7 +115,7 @@ func TestProxyServerBasicHTTP(t *testing.T) { func TestProxyServerBasicHTTPS(t *testing.T) { // Create test logger logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{ - Level: slog.LevelDebug, + Level: slog.LevelError, })) // Create test rules (allow all for testing) @@ -167,14 +161,10 @@ func TestProxyServerBasicHTTPS(t *testing.T) { TLSConfig: tlsConfig, }) - // Create context with timeout - ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) - defer cancel() - // Start server in goroutine serverDone := make(chan error, 1) go func() { - serverDone <- server.Start(ctx) + serverDone <- server.Start() }() // Give server time to start @@ -215,7 +205,6 @@ func TestProxyServerBasicHTTPS(t *testing.T) { err = server.Stop() require.NoError(t, err) - cancel() err = <-serverDone require.NoError(t, err) } From 926f923f67949fc7276c4966150a25fa1e4c6f0b Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Thu, 18 Sep 2025 14:51:12 +0000 Subject: [PATCH 7/9] refactor --- proxy/proxy.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/proxy/proxy.go b/proxy/proxy.go index 71ff1f3..f806f55 100644 --- a/proxy/proxy.go +++ b/proxy/proxy.go @@ -55,7 +55,6 @@ func (p *Server) Start() error { if p.isStarted() { return nil } - p.started.Store(true) // Start HTTP server with custom listener for TLS detection go func() { @@ -82,6 +81,8 @@ func (p *Server) Start() error { } }() + p.started.Store(true) + return nil } @@ -93,12 +94,14 @@ func (p *Server) Stop() error { p.started.Store(false) if p.listener == nil { - return errors.New("listener is nil; server was not started") + p.logger.Error("unexpected nil listener") + return errors.New("unexpected nil listener") } err := p.listener.Close() if err != nil { p.logger.Error("Failed to close listener", "error", err) + return err } return nil From 03b2938bcaf3453d6bfa851e8fded48cb5de271f Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Thu, 18 Sep 2025 14:56:41 +0000 Subject: [PATCH 8/9] refactor --- boundary.go | 13 ++++++------- proxy/proxy_test.go | 20 ++++++-------------- 2 files changed, 12 insertions(+), 21 deletions(-) diff --git a/boundary.go b/boundary.go index 9599820..d3e98a6 100644 --- a/boundary.go +++ b/boundary.go @@ -62,12 +62,11 @@ func (b *Boundary) Start() error { } // Start proxy server in background - go func() { - err := b.proxyServer.Start(b.ctx) - if err != nil { - b.logger.Error("Proxy server error", "error", err) - } - }() + err = b.proxyServer.Start() + if err != nil { + b.logger.Error("Proxy server error", "error", err) + return err + } // Give proxy time to start time.Sleep(100 * time.Millisecond) @@ -90,4 +89,4 @@ func (b *Boundary) Close() error { // Close jailer return b.jailer.Close() -} \ No newline at end of file +} diff --git a/proxy/proxy_test.go b/proxy/proxy_test.go index c9901eb..a70c9e7 100644 --- a/proxy/proxy_test.go +++ b/proxy/proxy_test.go @@ -59,11 +59,9 @@ func TestProxyServerBasicHTTP(t *testing.T) { TLSConfig: tlsConfig, }) - // Start server in goroutine - serverDone := make(chan error, 1) - go func() { - serverDone <- server.Start() - }() + // Start server + err = server.Start() + require.NoError(t, err) // Give server time to start time.Sleep(100 * time.Millisecond) @@ -107,8 +105,6 @@ func TestProxyServerBasicHTTP(t *testing.T) { err = server.Stop() require.NoError(t, err) - err = <-serverDone - require.NoError(t, err) } // TestProxyServerBasicHTTPS tests basic HTTPS request handling @@ -161,11 +157,9 @@ func TestProxyServerBasicHTTPS(t *testing.T) { TLSConfig: tlsConfig, }) - // Start server in goroutine - serverDone := make(chan error, 1) - go func() { - serverDone <- server.Start() - }() + // Start server + err = server.Start() + require.NoError(t, err) // Give server time to start time.Sleep(100 * time.Millisecond) @@ -205,6 +199,4 @@ func TestProxyServerBasicHTTPS(t *testing.T) { err = server.Stop() require.NoError(t, err) - err = <-serverDone - require.NoError(t, err) } From fa02d2483793d0adb1b8bf2757c123cd11f80ae4 Mon Sep 17 00:00:00 2001 From: YEVHENII SHCHERBINA Date: Thu, 18 Sep 2025 17:20:09 +0000 Subject: [PATCH 9/9] refactor --- proxy/proxy.go | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/proxy/proxy.go b/proxy/proxy.go index f806f55..e2aa537 100644 --- a/proxy/proxy.go +++ b/proxy/proxy.go @@ -56,16 +56,18 @@ func (p *Server) Start() error { return nil } + p.logger.Info("Starting HTTP proxy with TLS termination", "port", p.httpPort) + var err error + p.listener, err = net.Listen("tcp", fmt.Sprintf(":%d", p.httpPort)) + if err != nil { + p.logger.Error("Failed to create HTTP listener", "error", err) + return err + } + + p.started.Store(true) + // Start HTTP server with custom listener for TLS detection go func() { - p.logger.Info("Starting HTTP proxy with TLS termination", "port", p.httpPort) - var err error - p.listener, err = net.Listen("tcp", fmt.Sprintf(":%d", p.httpPort)) - if err != nil { - p.logger.Error("Failed to create HTTP listener", "error", err) - return - } - for { conn, err := p.listener.Accept() if err != nil && errors.Is(err, net.ErrClosed) && p.isStopped() { @@ -81,8 +83,6 @@ func (p *Server) Start() error { } }() - p.started.Store(true) - return nil }