var _ = Describe("AccessHandler", func() { const ( host = "1.2.3.4" port = 1234 ) var ( accessHandler *middleware.AccessHandler mockHandler *mockHttpHandler mockAccessLogger *mockAccessLogger ) BeforeEach(func() { gostLogger := loggertesthelper.Logger() mockHandler = newMockHttpHandler() mockAccessLogger = newMockAccessLogger() accessMiddleware := middleware.Access(mockAccessLogger, host, port, gostLogger) accessHandler = accessMiddleware(mockHandler) var _ http.Handler = accessHandler }) Describe("ServeHTTP", func() { It("Logs the access", func() { mockAccessLogger.LogAccessOutput.Ret0 <- nil req, err := newServerRequest("GET", "https://foo.bar/baz", nil) Expect(err).ToNot(HaveOccurred()) resp := httptest.NewRecorder() accessHandler.ServeHTTP(resp, req) Eventually(mockHandler.ServeHTTPInput).Should(BeCalled(With(resp, req))) Expect(mockAccessLogger.LogAccessCalled).To(HaveLen(1))
func main() { flag.Parse() config, err := config.ParseConfig(*logLevel, *configFile) if err != nil { panic(fmt.Errorf("Unable to parse config: %s", err)) } transport := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: config.SkipCertVerify}} http.DefaultClient.Transport = transport ipAddress, err := localip.LocalIP() if err != nil { panic(fmt.Errorf("Unable to resolve own IP address: %s", err)) } log := logger.NewLogger(*logLevel, *logFilePath, "loggregator trafficcontroller", config.Syslog) log.Info("Startup: Setting up the loggregator traffic controller") dropsonde.Initialize(net.JoinHostPort(config.MetronHost, strconv.Itoa(config.MetronPort)), "LoggregatorTrafficController") go func() { err := http.ListenAndServe(net.JoinHostPort(ipAddress, pprofPort), nil) if err != nil { log.Errorf("Error starting pprof server: %s", err.Error()) } }() uptimeMonitor := monitor.NewUptimeMonitor(time.Duration(config.MonitorIntervalSeconds) * time.Second) go uptimeMonitor.Start() defer uptimeMonitor.Stop() etcdAdapter := defaultStoreAdapterProvider(config.EtcdUrls, config.EtcdMaxConcurrentRequests) err = etcdAdapter.Connect() if err != nil { panic(fmt.Errorf("Unable to connect to ETCD: %s", err)) } logAuthorizer := authorization.NewLogAccessAuthorizer(*disableAccessControl, config.ApiHost) uaaClient := uaa_client.NewUaaClient(config.UaaHost, config.UaaClientId, config.UaaClientSecret) adminAuthorizer := authorization.NewAdminAccessAuthorizer(*disableAccessControl, &uaaClient) // TODO: The preferredProtocol of udp tells the finder to pull out the Doppler URLs from the legacy ETCD endpoint. // Eventually we'll have a separate websocket client pool finder := dopplerservice.NewFinder(etcdAdapter, int(config.DopplerPort), []string{"udp"}, "", log) finder.Start() // Draining the finder's events channel in order to not block the finder from handling etcd events. go func() { for { finder.Next() } }() var accessMiddleware, legacyAccessMiddleware func(middleware.HttpHandler) *middleware.AccessHandler if config.SecurityEventLog != "" { accessLog, err := os.OpenFile(config.SecurityEventLog, os.O_APPEND|os.O_WRONLY, os.ModeAppend) if err != nil { panic(fmt.Errorf("Unable to open access log: %s", err)) } defer func() { accessLog.Sync() accessLog.Close() }() accessLogger := accesslogger.New(accessLog, log) accessMiddleware = middleware.Access(accessLogger, ipAddress, config.OutgoingDropsondePort, log) legacyAccessMiddleware = middleware.Access(accessLogger, ipAddress, config.OutgoingPort, log) } dopplerCgc := channel_group_connector.NewChannelGroupConnector(finder, newDropsondeWebsocketListener, marshaller.DropsondeLogMessage, log) dopplerHandler := http.Handler(dopplerproxy.NewDopplerProxy(logAuthorizer, adminAuthorizer, dopplerCgc, dopplerproxy.TranslateFromDropsondePath, "doppler."+config.SystemDomain, log)) if accessMiddleware != nil { dopplerHandler = accessMiddleware(dopplerHandler) } startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingDropsondePort), 10)), dopplerHandler) legacyCgc := channel_group_connector.NewChannelGroupConnector(finder, newLegacyWebsocketListener, marshaller.LoggregatorLogMessage, log) legacyHandler := http.Handler(dopplerproxy.NewDopplerProxy(logAuthorizer, adminAuthorizer, legacyCgc, dopplerproxy.TranslateFromLegacyPath, "loggregator."+config.SystemDomain, log)) if legacyAccessMiddleware != nil { legacyHandler = legacyAccessMiddleware(legacyHandler) } startOutgoingProxy(net.JoinHostPort(ipAddress, strconv.FormatUint(uint64(config.OutgoingPort), 10)), legacyHandler) killChan := signalmanager.RegisterKillSignalChannel() dumpChan := signalmanager.RegisterGoRoutineDumpSignalChannel() for { select { case <-dumpChan: signalmanager.DumpGoRoutine() case <-killChan: log.Info("Shutting down") return } } }