func (fakeDoppler *FakeDoppler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
select {
case fakeDoppler.TrafficControllerConnected <- request:
default:
}
fakeDoppler.Lock()
fakeDoppler.connectionPresent = true
fakeDoppler.Unlock()
handlers.NewWebsocketHandler(fakeDoppler.sendMessageChan, time.Millisecond*100, loggertesthelper.Logger()).ServeHTTP(writer, request)
fakeDoppler.Lock()
fakeDoppler.connectionPresent = false
fakeDoppler.Unlock()
}
log.SetOutput(buf)
})
BeforeEach(func() {
messagesToSend = make(chan []byte, 256)
})
AfterEach(func() {
if testServer != nil {
testServer.Close()
}
})
Describe("SetOnConnectCallback", func() {
BeforeEach(func() {
testServer = httptest.NewServer(handlers.NewWebsocketHandler(messagesToSend, 100*time.Millisecond))
endpoint = "ws://" + testServer.Listener.Addr().String()
close(messagesToSend)
})
It("sets a callback and calls it when connecting", func() {
called := false
cb := func() { called = true }
connection = consumer.New(endpoint, tlsSettings, nil)
connection.SetOnConnectCallback(cb)
connection.Tail(appGuid, authToken)
Eventually(func() bool { return called }).Should(BeTrue())
})
func WebsocketHandlerProvider(messages <-chan []byte, logger *gosteno.Logger) http.Handler {
return handlers.NewWebsocketHandler(messages, WebsocketKeepAliveDuration, logger)
}
consumerProxyFunc func(*http.Request) (*url.URL, error)
appGuid string
authToken string
incomingChan chan *events.Envelope
messagesToSend chan []byte
testProxyServer *httptest.Server
goProxyHandler *goproxy.ProxyHttpServer
err error
)
BeforeEach(func() {
messagesToSend = make(chan []byte, 256)
testServer = httptest.NewServer(handlers.NewWebsocketHandler(messagesToSend, 100*time.Millisecond, loggertesthelper.Logger()))
endpoint = "ws://" + testServer.Listener.Addr().String()
goProxyHandler = goproxy.NewProxyHttpServer()
goProxyHandler.Logger = log.New(bytes.NewBufferString(""), "", 0)
testProxyServer = httptest.NewServer(goProxyHandler)
consumerProxyFunc = func(*http.Request) (*url.URL, error) {
return url.Parse(testProxyServer.URL)
}
})
AfterEach(func() {
consumerProxyFunc = nil
if testProxyServer != nil {
testProxyServer.Close()
}
if testServer != nil {
"net/http/httptest"
"time"
"tools/benchmark/metricsreporter"
"github.com/cloudfoundry/loggregatorlib/loggertesthelper"
"github.com/cloudfoundry/loggregatorlib/server/handlers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Websocketmessagereader", func() {
It("connects to a websocket endpoint", func() {
sentMessage := "a message"
messages := make(chan []byte, 1)
wsh := handlers.NewWebsocketHandler(messages, time.Second, loggertesthelper.Logger())
server := httptest.NewServer(wsh)
defer server.Close()
messages <- []byte(sentMessage)
receivedCounter := metricsreporter.NewCounter("counter")
reader := websocketmessagereader.New(server.Listener.Addr().String(), receivedCounter)
reader.Read()
Eventually(receivedCounter.GetValue).Should(BeEquivalentTo(1))
})
})
Expect(recorder.Header().Get("Access-Control-Allow-Credentials")).To(Equal("true"))
})
})
})
var _ = Describe("DefaultHandlerProvider", func() {
It("returns an HTTP handler for .../recentlogs", func() {
httpHandler := handlers.NewHttpHandler(make(chan []byte), loggertesthelper.Logger())
target := doppler_endpoint.HttpHandlerProvider(make(chan []byte), loggertesthelper.Logger())
Expect(target).To(BeAssignableToTypeOf(httpHandler))
})
It("returns a Websocket handler for .../stream", func() {
wsHandler := handlers.NewWebsocketHandler(make(chan []byte), time.Minute, loggertesthelper.Logger())
target := doppler_endpoint.WebsocketHandlerProvider(make(chan []byte), loggertesthelper.Logger())
Expect(target).To(BeAssignableToTypeOf(wsHandler))
})
It("returns a Websocket handler for anything else", func() {
wsHandler := handlers.NewWebsocketHandler(make(chan []byte), time.Minute, loggertesthelper.Logger())
target := doppler_endpoint.WebsocketHandlerProvider(make(chan []byte), loggertesthelper.Logger())
Expect(target).To(BeAssignableToTypeOf(wsHandler))
})
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("RefreshTokenFrom", func() {
Context("Asynchronous", func() {
var (
cnsmr *consumer.Consumer
testHandler *errorRespondingHandler
tcURL string
refresher *mockTokenRefresher
)
BeforeEach(func() {
testHandler = &errorRespondingHandler{
subHandler: handlers.NewWebsocketHandler(make(chan []byte), 100*time.Millisecond, loggertesthelper.Logger()),
responseStatuses: make(chan int, 10),
}
server := httptest.NewServer(testHandler)
tcURL = "ws://" + server.Listener.Addr().String()
refresher = newMockTokenRefresher()
cnsmr = consumer.New(tcURL, nil, nil)
cnsmr.RefreshTokenFrom(refresher)
})
Describe("TailingLogs", func() {
It("loads a token if the provided token is empty", func() {
cnsmr.TailingLogs("some-fake-app-guid", "")
Eventually(refresher.RefreshAuthTokenCalled).Should(BeCalled())
"trafficcontroller/listener"
)
type Proxy struct {
hashers []hasher.Hasher
logger *gosteno.Logger
authorize authorization.LogAccessAuthorizer
listener net.Listener
}
type WebsocketHandler interface {
HandleWebSocket(string, string, []hasher.Hasher)
}
var NewWebsocketHandlerProvider = func(messages <-chan []byte) http.Handler {
return handlers.NewWebsocketHandler(messages, 30*time.Second)
}
var NewHttpHandlerProvider = func(messages <-chan []byte) http.Handler {
return handlers.NewHttpHandler(messages)
}
var NewWebsocketListener = func() listener.Listener {
return listener.NewWebsocket()
}
func NewProxy(hashers []hasher.Hasher, authorizer authorization.LogAccessAuthorizer, logger *gosteno.Logger) *Proxy {
return &Proxy{hashers: hashers, authorize: authorizer, logger: logger}
}
func (proxy *Proxy) isAuthorized(appId, authToken string, clientAddress string) (bool, *logmessage.LogMessage) {
consumerProxyFunc func(*http.Request) (*url.URL, error)
appGuid string
authToken string
incomingChan <-chan *logmessage.LogMessage
messagesToSend chan []byte
testProxyServer *httptest.Server
goProxyHandler *goproxy.ProxyHttpServer
err error
)
BeforeEach(func() {
messagesToSend = make(chan []byte, 256)
testServer = httptest.NewServer(handlers.NewWebsocketHandler(messagesToSend, 100*time.Millisecond))
endpoint = "ws://" + testServer.Listener.Addr().String()
goProxyHandler = goproxy.NewProxyHttpServer()
goProxyHandler.Logger = log.New(bytes.NewBufferString(""), "", 0)
testProxyServer = httptest.NewServer(goProxyHandler)
consumerProxyFunc = func(*http.Request) (*url.URL, error) {
return url.Parse(testProxyServer.URL)
}
})
AfterEach(func() {
consumerProxyFunc = nil
if testProxyServer != nil {
testProxyServer.Close()
}
if testServer != nil {
