5512814048

Committed 10 Jul 2023 08:40PM UTC coverage: 63.427% (-0.01%) from 63.437%

Build # 5512814048

Build Type

push

github

Committed by

web-flow

Commit Message

chore(deps): bump docker/setup-buildx-action from 2.7.0 to 2.8.0 (#4330)

Bumps [docker/setup-buildx-action](https://github.com/docker/setup-buildx-action) from 2.7.0 to 2.8.0.
- [Release notes](https://github.com/docker/setup-buildx-action/releases)
- [Commits](https://github.com/docker/setup-buildx-action/compare/ecf95283f...16c0bc4a6)

---
updated-dependencies:
- dependency-name: docker/setup-buildx-action
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

13569 of 21393 relevant lines covered (63.43%)

124.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.82

/internal/controlplane/server.go

package controlplane

import (
        "context"
        "net"
        "net/http"
        "net/http/pprof"
        "net/url"
        "time"

        envoy_service_discovery_v3 "github.com/envoyproxy/go-control-plane/envoy/service/discovery/v3"
        "github.com/gorilla/mux"
        "github.com/rs/zerolog"
        "golang.org/x/sync/errgroup"
        "google.golang.org/grpc"
        "google.golang.org/grpc/health/grpc_health_v1"
        "google.golang.org/grpc/metadata"
        "google.golang.org/grpc/reflection"

        "github.com/pomerium/pomerium/config"
        "github.com/pomerium/pomerium/config/envoyconfig"
        "github.com/pomerium/pomerium/config/envoyconfig/filemgr"
        "github.com/pomerium/pomerium/internal/atomicutil"
        "github.com/pomerium/pomerium/internal/controlplane/xdsmgr"
        "github.com/pomerium/pomerium/internal/events"
        "github.com/pomerium/pomerium/internal/httputil/reproxy"
        "github.com/pomerium/pomerium/internal/log"
        "github.com/pomerium/pomerium/internal/telemetry"
        "github.com/pomerium/pomerium/internal/telemetry/requestid"
        "github.com/pomerium/pomerium/internal/urlutil"
        "github.com/pomerium/pomerium/internal/version"
        "github.com/pomerium/pomerium/pkg/envoy/files"
        pom_grpc "github.com/pomerium/pomerium/pkg/grpc"
        "github.com/pomerium/pomerium/pkg/grpcutil"
)

type versionedConfig struct {
        *config.Config
        version int64
}

// A Service can be mounted on the control plane.
type Service interface {
        Mount(r *mux.Router)
}

// A Server is the control-plane gRPC and HTTP servers.
type Server struct {
        GRPCListener    net.Listener
        GRPCServer      *grpc.Server
        HTTPListener    net.Listener
        MetricsListener net.Listener
        MetricsRouter   *mux.Router
        DebugListener   net.Listener
        DebugRouter     *mux.Router
        Builder         *envoyconfig.Builder
        EventsMgr       *events.Manager

        currentConfig *atomicutil.Value[versionedConfig]
        name          string
        xdsmgr        *xdsmgr.Manager
        filemgr       *filemgr.Manager
        metricsMgr    *config.MetricsManager
        reproxy       *reproxy.Handler

        httpRouter      *atomicutil.Value[*mux.Router]
        authenticateSvc Service
        proxySvc        Service

        haveSetCapacity map[string]bool
}

// NewServer creates a new Server. Listener ports are chosen by the OS.
func NewServer(cfg *config.Config, metricsMgr *config.MetricsManager, eventsMgr *events.Manager) (*Server, error) {
        srv := &Server{
                metricsMgr:      metricsMgr,
                EventsMgr:       eventsMgr,
                reproxy:         reproxy.New(),
                haveSetCapacity: map[string]bool{},
                currentConfig: atomicutil.NewValue(versionedConfig{
                        Config: cfg,
                }),
                httpRouter: atomicutil.NewValue(mux.NewRouter()),
        }

        var err error

        // setup gRPC
        srv.GRPCListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.GRPCPort))
        if err != nil {
                return nil, err
        }
        ui, si := grpcutil.AttachMetadataInterceptors(
                metadata.Pairs(
                        grpcutil.MetadataKeyEnvoyVersion, files.FullVersion(),
                        grpcutil.MetadataKeyPomeriumVersion, version.FullVersion(),
                ),
        )
        srv.GRPCServer = grpc.NewServer(
                grpc.StatsHandler(telemetry.NewGRPCServerStatsHandler(cfg.Options.Services)),
                grpc.ChainUnaryInterceptor(requestid.UnaryServerInterceptor(), ui),
                grpc.ChainStreamInterceptor(requestid.StreamServerInterceptor(), si),
        )
        reflection.Register(srv.GRPCServer)
        srv.registerAccessLogHandlers()

        grpc_health_v1.RegisterHealthServer(srv.GRPCServer, pom_grpc.NewHealthCheckServer())

        // setup HTTP
        srv.HTTPListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.HTTPPort))
        if err != nil {
                _ = srv.GRPCListener.Close()
                return nil, err
        }

        srv.MetricsListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.MetricsPort))
        if err != nil {
                _ = srv.GRPCListener.Close()
                _ = srv.HTTPListener.Close()
                return nil, err
        }

        srv.DebugListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.DebugPort))
        if err != nil {
                _ = srv.GRPCListener.Close()
                _ = srv.HTTPListener.Close()
                _ = srv.DebugListener.Close()
                return nil, err
        }

        if err := srv.updateRouter(cfg); err != nil {
                return nil, err
        }
        srv.DebugRouter = mux.NewRouter()
        srv.MetricsRouter = mux.NewRouter()

        // pprof
        srv.DebugRouter.Path("/debug/pprof/cmdline").HandlerFunc(pprof.Cmdline)
        srv.DebugRouter.Path("/debug/pprof/profile").HandlerFunc(pprof.Profile)
        srv.DebugRouter.Path("/debug/pprof/symbol").HandlerFunc(pprof.Symbol)
        srv.DebugRouter.Path("/debug/pprof/trace").HandlerFunc(pprof.Trace)
        srv.DebugRouter.PathPrefix("/debug/pprof/").HandlerFunc(pprof.Index)

        // metrics
        srv.MetricsRouter.Handle("/metrics", srv.metricsMgr)

        srv.filemgr = filemgr.NewManager()
        srv.filemgr.ClearCache()

        srv.Builder = envoyconfig.New(
                srv.GRPCListener.Addr().String(),
                srv.HTTPListener.Addr().String(),
                srv.MetricsListener.Addr().String(),
                srv.filemgr,
                srv.reproxy,
        )

        ctx := log.WithContext(context.Background(), func(c zerolog.Context) zerolog.Context {
                return c.Str("server_name", cfg.Options.Services)
        })

        res, err := srv.buildDiscoveryResources(ctx)
        if err != nil {
                return nil, err
        }

        srv.xdsmgr = xdsmgr.NewManager(res)
        envoy_service_discovery_v3.RegisterAggregatedDiscoveryServiceServer(srv.GRPCServer, srv.xdsmgr)

        return srv, nil
}

// Run runs the control-plane gRPC and HTTP servers.
func (srv *Server) Run(ctx context.Context) error {
        eg, ctx := errgroup.WithContext(ctx)

        handle := srv.EventsMgr.Register(func(evt events.Event) {
                withGRPCBackoff(ctx, func() error {
                        return srv.storeEvent(ctx, evt)
                })
        })
        defer srv.EventsMgr.Unregister(handle)

        // start the gRPC server
        eg.Go(func() error {
                log.Info(ctx).Str("addr", srv.GRPCListener.Addr().String()).Msg("starting control-plane gRPC server")
                return srv.GRPCServer.Serve(srv.GRPCListener)
        })

        // gracefully stop the gRPC server on context cancellation
        eg.Go(func() error {
                <-ctx.Done()

                ctx, cancel := context.WithCancel(ctx)
                ctx, cleanup := context.WithTimeout(ctx, time.Second*5)
                defer cleanup()

                go func() {
                        srv.GRPCServer.GracefulStop()
                        cancel()
                }()

                go func() {
                        <-ctx.Done()
                        srv.GRPCServer.Stop()
                        cancel()
                }()

                <-ctx.Done()

                return nil
        })

        for _, entry := range []struct {
                Name     string
                Listener net.Listener
                Handler  http.Handler
        }{
                {"http", srv.HTTPListener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                        srv.httpRouter.Load().ServeHTTP(w, r)
                })},
                {"debug", srv.DebugListener, srv.DebugRouter},
                {"metrics", srv.MetricsListener, srv.MetricsRouter},
        } {
                entry := entry
                hsrv := (&http.Server{
                        BaseContext: func(li net.Listener) context.Context {
                                return ctx
                        },
                        Handler: entry.Handler,
                })

                // start the HTTP server
                eg.Go(func() error {
                        log.Info(ctx).
                                Str("addr", entry.Listener.Addr().String()).
                                Msgf("starting control-plane %s server", entry.Name)
                        return hsrv.Serve(entry.Listener)
                })

                // gracefully stop the HTTP server on context cancellation
                eg.Go(func() error {
                        <-ctx.Done()

                        ctx, cleanup := context.WithTimeout(ctx, time.Second*5)
                        defer cleanup()

                        return hsrv.Shutdown(ctx)
                })
        }

        return eg.Wait()
}

// OnConfigChange updates the pomerium config options.
func (srv *Server) OnConfigChange(ctx context.Context, cfg *config.Config) error {
        if err := srv.updateRouter(cfg); err != nil {
                return err
        }
        srv.reproxy.Update(ctx, cfg)
        prev := srv.currentConfig.Load()
        srv.currentConfig.Store(versionedConfig{
                Config:  cfg,
                version: prev.version + 1,
        })
        res, err := srv.buildDiscoveryResources(ctx)
        if err != nil {
                return err
        }
        srv.xdsmgr.Update(ctx, res)
        return nil
}

// EnableAuthenticate enables the authenticate service.
func (srv *Server) EnableAuthenticate(svc Service) error {
        srv.authenticateSvc = svc
        return srv.updateRouter(srv.currentConfig.Load().Config)
}

// EnableProxy enables the proxy service.
func (srv *Server) EnableProxy(svc Service) error {
        srv.proxySvc = svc
        return srv.updateRouter(srv.currentConfig.Load().Config)
}

func (srv *Server) updateRouter(cfg *config.Config) error {
        httpRouter := mux.NewRouter()
        srv.addHTTPMiddleware(httpRouter, cfg)
        if err := srv.mountCommonEndpoints(httpRouter, cfg); err != nil {
                return err
        }
        if srv.authenticateSvc != nil {
                seen := make(map[string]struct{})
                // mount auth handler for both internal and external endpoints
                for _, fn := range []func() (*url.URL, error){cfg.Options.GetAuthenticateURL, cfg.Options.GetInternalAuthenticateURL} {
                        authenticateURL, err := fn()
                        if err != nil {
                                return err
                        }
                        authenticateHost := urlutil.StripPort(authenticateURL.Host)
                        if _, ok := seen[authenticateHost]; ok {
                                continue
                        }
                        seen[authenticateHost] = struct{}{}
                        srv.authenticateSvc.Mount(httpRouter.Host(authenticateHost).Subrouter())
                }
        }
        if srv.proxySvc != nil {
                srv.proxySvc.Mount(httpRouter)
        }
        srv.httpRouter.Store(httpRouter)
        return nil
}

1	package controlplane
2
3	import (
4	"context"
5	"net"
6	"net/http"
7	"net/http/pprof"
8	"net/url"
9	"time"
10
11	envoy_service_discovery_v3 "github.com/envoyproxy/go-control-plane/envoy/service/discovery/v3"
12	"github.com/gorilla/mux"
13	"github.com/rs/zerolog"
14	"golang.org/x/sync/errgroup"
15	"google.golang.org/grpc"
16	"google.golang.org/grpc/health/grpc_health_v1"
17	"google.golang.org/grpc/metadata"
18	"google.golang.org/grpc/reflection"
19
20	"github.com/pomerium/pomerium/config"
21	"github.com/pomerium/pomerium/config/envoyconfig"
22	"github.com/pomerium/pomerium/config/envoyconfig/filemgr"
23	"github.com/pomerium/pomerium/internal/atomicutil"
24	"github.com/pomerium/pomerium/internal/controlplane/xdsmgr"
25	"github.com/pomerium/pomerium/internal/events"
26	"github.com/pomerium/pomerium/internal/httputil/reproxy"
27	"github.com/pomerium/pomerium/internal/log"
28	"github.com/pomerium/pomerium/internal/telemetry"
29	"github.com/pomerium/pomerium/internal/telemetry/requestid"
30	"github.com/pomerium/pomerium/internal/urlutil"
31	"github.com/pomerium/pomerium/internal/version"
32	"github.com/pomerium/pomerium/pkg/envoy/files"
33	pom_grpc "github.com/pomerium/pomerium/pkg/grpc"
34	"github.com/pomerium/pomerium/pkg/grpcutil"
35	)
36
37	type versionedConfig struct {
38	*config.Config
39	version int64
40	}
41
42	// A Service can be mounted on the control plane.
43	type Service interface {
44	Mount(r *mux.Router)
45	}
46
47	// A Server is the control-plane gRPC and HTTP servers.
48	type Server struct {
49	GRPCListener net.Listener
50	GRPCServer *grpc.Server
51	HTTPListener net.Listener
52	MetricsListener net.Listener
53	MetricsRouter *mux.Router
54	DebugListener net.Listener
55	DebugRouter *mux.Router
56	Builder *envoyconfig.Builder
57	EventsMgr *events.Manager
58
59	currentConfig *atomicutil.Value[versionedConfig]
60	name string
61	xdsmgr *xdsmgr.Manager
62	filemgr *filemgr.Manager
63	metricsMgr *config.MetricsManager
64	reproxy *reproxy.Handler
65
66	httpRouter atomicutil.Value[mux.Router]
67	authenticateSvc Service
68	proxySvc Service
69
70	haveSetCapacity map[string]bool
71	}
72
73	// NewServer creates a new Server. Listener ports are chosen by the OS.
74	func NewServer(cfg config.Config, metricsMgr config.MetricsManager, eventsMgr events.Manager) (Server, error) {	1✔
75	srv := &Server{	1✔
76	metricsMgr: metricsMgr,	1✔
77	EventsMgr: eventsMgr,	1✔
78	reproxy: reproxy.New(),	1✔
79	haveSetCapacity: map[string]bool{},	1✔
80	currentConfig: atomicutil.NewValue(versionedConfig{	1✔
81	Config: cfg,	1✔
82	}),	1✔
83	httpRouter: atomicutil.NewValue(mux.NewRouter()),	1✔
84	}	1✔
85		1✔
86	var err error	1✔
87		1✔
88	// setup gRPC	1✔
89	srv.GRPCListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.GRPCPort))	1✔
90	if err != nil {	1✔
91	return nil, err	×
92	}	×
93	ui, si := grpcutil.AttachMetadataInterceptors(	1✔
94	metadata.Pairs(	1✔
95	grpcutil.MetadataKeyEnvoyVersion, files.FullVersion(),	1✔
96	grpcutil.MetadataKeyPomeriumVersion, version.FullVersion(),	1✔
97	),	1✔
98	)	1✔
99	srv.GRPCServer = grpc.NewServer(	1✔
100	grpc.StatsHandler(telemetry.NewGRPCServerStatsHandler(cfg.Options.Services)),	1✔
101	grpc.ChainUnaryInterceptor(requestid.UnaryServerInterceptor(), ui),	1✔
102	grpc.ChainStreamInterceptor(requestid.StreamServerInterceptor(), si),	1✔
103	)	1✔
104	reflection.Register(srv.GRPCServer)	1✔
105	srv.registerAccessLogHandlers()	1✔
106		1✔
107	grpc_health_v1.RegisterHealthServer(srv.GRPCServer, pom_grpc.NewHealthCheckServer())	1✔
108		1✔
109	// setup HTTP	1✔
110	srv.HTTPListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.HTTPPort))	1✔
111	if err != nil {	1✔
112	_ = srv.GRPCListener.Close()	×
113	return nil, err	×
114	}	×
115
116	srv.MetricsListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.MetricsPort))	1✔
117	if err != nil {	1✔
118	_ = srv.GRPCListener.Close()	×
119	_ = srv.HTTPListener.Close()	×
120	return nil, err	×
121	}	×
122
123	srv.DebugListener, err = net.Listen("tcp4", net.JoinHostPort("127.0.0.1", cfg.DebugPort))	1✔
124	if err != nil {	1✔
125	_ = srv.GRPCListener.Close()	×
126	_ = srv.HTTPListener.Close()	×
127	_ = srv.DebugListener.Close()	×
128	return nil, err	×
129	}	×
130
131	if err := srv.updateRouter(cfg); err != nil {	1✔
132	return nil, err	×
133	}	×
134	srv.DebugRouter = mux.NewRouter()	1✔
135	srv.MetricsRouter = mux.NewRouter()	1✔
136		1✔
137	// pprof	1✔
138	srv.DebugRouter.Path("/debug/pprof/cmdline").HandlerFunc(pprof.Cmdline)	1✔
139	srv.DebugRouter.Path("/debug/pprof/profile").HandlerFunc(pprof.Profile)	1✔
140	srv.DebugRouter.Path("/debug/pprof/symbol").HandlerFunc(pprof.Symbol)	1✔
141	srv.DebugRouter.Path("/debug/pprof/trace").HandlerFunc(pprof.Trace)	1✔
142	srv.DebugRouter.PathPrefix("/debug/pprof/").HandlerFunc(pprof.Index)	1✔
143		1✔
144	// metrics	1✔
145	srv.MetricsRouter.Handle("/metrics", srv.metricsMgr)	1✔
146		1✔
147	srv.filemgr = filemgr.NewManager()	1✔
148	srv.filemgr.ClearCache()	1✔
149		1✔
150	srv.Builder = envoyconfig.New(	1✔
151	srv.GRPCListener.Addr().String(),	1✔
152	srv.HTTPListener.Addr().String(),	1✔
153	srv.MetricsListener.Addr().String(),	1✔
154	srv.filemgr,	1✔
155	srv.reproxy,	1✔
156	)	1✔
157		1✔
158	ctx := log.WithContext(context.Background(), func(c zerolog.Context) zerolog.Context {	2✔
159	return c.Str("server_name", cfg.Options.Services)	1✔
160	})	1✔
161
162	res, err := srv.buildDiscoveryResources(ctx)	1✔
163	if err != nil {	1✔
164	return nil, err	×
165	}	×
166
167	srv.xdsmgr = xdsmgr.NewManager(res)	1✔
168	envoy_service_discovery_v3.RegisterAggregatedDiscoveryServiceServer(srv.GRPCServer, srv.xdsmgr)	1✔
169		1✔
170	return srv, nil	1✔
171	}
172
173	// Run runs the control-plane gRPC and HTTP servers.
174	func (srv *Server) Run(ctx context.Context) error {	1✔
175	eg, ctx := errgroup.WithContext(ctx)	1✔
176		1✔
177	handle := srv.EventsMgr.Register(func(evt events.Event) {	1✔
178	withGRPCBackoff(ctx, func() error {	×
179	return srv.storeEvent(ctx, evt)	×
180	})	×
181	})
182	defer srv.EventsMgr.Unregister(handle)	1✔
183		1✔
184	// start the gRPC server	1✔
185	eg.Go(func() error {	2✔
186	log.Info(ctx).Str("addr", srv.GRPCListener.Addr().String()).Msg("starting control-plane gRPC server")	1✔
187	return srv.GRPCServer.Serve(srv.GRPCListener)	1✔
188	})	1✔
189
190	// gracefully stop the gRPC server on context cancellation
191	eg.Go(func() error {	2✔
192	<-ctx.Done()	1✔
193		1✔
194	ctx, cancel := context.WithCancel(ctx)	1✔
195	ctx, cleanup := context.WithTimeout(ctx, time.Second*5)	1✔
196	defer cleanup()	1✔
197		1✔
198	go func() {	2✔
199	srv.GRPCServer.GracefulStop()	1✔
200	cancel()	1✔
201	}()	1✔
202
203	go func() {	1✔
204	<-ctx.Done()	×
205	srv.GRPCServer.Stop()	×
206	cancel()	×
207	}()	×
208
209	<-ctx.Done()	1✔
210		1✔
211	return nil	1✔
212	})
213
214	for _, entry := range []struct {	1✔
215	Name string	1✔
216	Listener net.Listener	1✔
217	Handler http.Handler	1✔
218	}{	1✔
219	{"http", srv.HTTPListener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {	4✔
220	srv.httpRouter.Load().ServeHTTP(w, r)	3✔
221	})},	3✔
222	{"debug", srv.DebugListener, srv.DebugRouter},
223	{"metrics", srv.MetricsListener, srv.MetricsRouter},
224	} {	3✔
225	entry := entry	3✔
226	hsrv := (&http.Server{	3✔
227	BaseContext: func(li net.Listener) context.Context {	6✔
228	return ctx	3✔
229	},	3✔
230	Handler: entry.Handler,
231	})
232
233	// start the HTTP server
234	eg.Go(func() error {	6✔
235	log.Info(ctx).	3✔
236	Str("addr", entry.Listener.Addr().String()).	3✔
237	Msgf("starting control-plane %s server", entry.Name)	3✔
238	return hsrv.Serve(entry.Listener)	3✔
239	})	3✔
240
241	// gracefully stop the HTTP server on context cancellation
242	eg.Go(func() error {	6✔
243	<-ctx.Done()	3✔
244		3✔
245	ctx, cleanup := context.WithTimeout(ctx, time.Second*5)	3✔
246	defer cleanup()	3✔
247		3✔
248	return hsrv.Shutdown(ctx)	3✔
249	})	3✔
250	}
251
252	return eg.Wait()	1✔
253	}
254
255	// OnConfigChange updates the pomerium config options.
256	func (srv Server) OnConfigChange(ctx context.Context, cfg config.Config) error {	×
257	if err := srv.updateRouter(cfg); err != nil {	×
258	return err	×
259	}	×
260	srv.reproxy.Update(ctx, cfg)	×
261	prev := srv.currentConfig.Load()	×
262	srv.currentConfig.Store(versionedConfig{	×
263	Config: cfg,	×
264	version: prev.version + 1,	×
265	})	×
266	res, err := srv.buildDiscoveryResources(ctx)	×
267	if err != nil {	×
268	return err	×
269	}	×
270	srv.xdsmgr.Update(ctx, res)	×
271	return nil	×
272	}
273
274	// EnableAuthenticate enables the authenticate service.
275	func (srv *Server) EnableAuthenticate(svc Service) error {	×
276	srv.authenticateSvc = svc	×
277	return srv.updateRouter(srv.currentConfig.Load().Config)	×
278	}	×
279
280	// EnableProxy enables the proxy service.
281	func (srv *Server) EnableProxy(svc Service) error {	×
282	srv.proxySvc = svc	×
283	return srv.updateRouter(srv.currentConfig.Load().Config)	×
284	}	×
285
286	func (srv Server) updateRouter(cfg config.Config) error {	1✔
287	httpRouter := mux.NewRouter()	1✔
288	srv.addHTTPMiddleware(httpRouter, cfg)	1✔
289	if err := srv.mountCommonEndpoints(httpRouter, cfg); err != nil {	1✔
290	return err	×
291	}	×
292	if srv.authenticateSvc != nil {	1✔
293	seen := make(map[string]struct{})	×
294	// mount auth handler for both internal and external endpoints	×
295	for _, fn := range []func() (*url.URL, error){cfg.Options.GetAuthenticateURL, cfg.Options.GetInternalAuthenticateURL} {	×
296	authenticateURL, err := fn()	×
297	if err != nil {	×
298	return err	×
299	}	×
300	authenticateHost := urlutil.StripPort(authenticateURL.Host)	×
301	if _, ok := seen[authenticateHost]; ok {	×
302	continue	×
303	}
304	seen[authenticateHost] = struct{}{}	×
305	srv.authenticateSvc.Mount(httpRouter.Host(authenticateHost).Subrouter())	×
306	}
307	}
308	if srv.proxySvc != nil {	1✔
309	srv.proxySvc.Mount(httpRouter)	×
310	}	×
311	srv.httpRouter.Store(httpRouter)	1✔
312	return nil	1✔
313	}

pomerium / pomerium / 5512814048

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous