func NewWebSocketApp(urls []route.Uri, rPort uint16, mbusClient *nats.Conn, delay time.Duration) *common.TestApp {
app := common.NewTestApp(urls, rPort, mbusClient, nil, "")
app.AddHandler("/", func(w http.ResponseWriter, r *http.Request) {
defer ginkgo.GinkgoRecover()
Expect(r.Header.Get("Upgrade")).To(Equal("websocket"))
Expect(r.Header.Get("Connection")).To(Equal("upgrade"))
conn, _, err := w.(http.Hijacker).Hijack()
x := test_util.NewHttpConn(conn)
resp := test_util.NewResponse(http.StatusSwitchingProtocols)
resp.Header.Set("Upgrade", "websocket")
resp.Header.Set("Connection", "upgrade")
time.Sleep(delay)
x.WriteResponse(resp)
Expect(err).ToNot(HaveOccurred())
x.CheckLine("hello from client")
x.WriteLine("hello from server")
})
return app
}
func NewGreetApp(urls []route.Uri, rPort uint16, mbusClient *nats.Conn, tags map[string]string) *common.TestApp {
app := common.NewTestApp(urls, rPort, mbusClient, tags, "")
app.AddHandler("/", greetHandler)
app.AddHandler("/forwardedprotoheader", headerHandler)
return app
}
func NewSlowApp(urls []route.Uri, rPort uint16, mbusClient *nats.Conn, delay time.Duration) *common.TestApp {
app := common.NewTestApp(urls, rPort, mbusClient, nil, "")
app.AddHandler("/", func(w http.ResponseWriter, r *http.Request) {
time.Sleep(delay)
io.WriteString(w, "Hello, world")
})
app.AddHandler("/hello", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.(http.Flusher).Flush()
time.Sleep(delay)
io.WriteString(w, "Hello, world")
})
return app
}
logger lager.Logger
natsRunner *test_util.NATSRunner
config *cfg.Config
p proxy.Proxy
mbusClient *nats.Conn
registry *rregistry.RouteRegistry
varz vvarz.Varz
rtr *router.Router
subscriber ifrit.Process
natsPort uint16
healthCheck int32
)
testAndVerifyRouterStopsNoDrain := func(signals chan os.Signal, closeChannel chan struct{}, sigs ...os.Signal) {
app := common.NewTestApp([]route.Uri{"drain.vcap.me"}, config.Port, mbusClient, nil, "")
blocker := make(chan bool)
resultCh := make(chan bool, 2)
app.AddHandler("/", func(w http.ResponseWriter, r *http.Request) {
blocker <- true
_, err := ioutil.ReadAll(r.Body)
defer r.Body.Close()
Expect(err).ToNot(HaveOccurred())
<-blocker
w.WriteHeader(http.StatusNoContent)
})
app.Listen()
http_conn := test_util.NewHttpConn(conn)
http_conn.WriteRequest(req)
resp, body := http_conn.ReadResponse()
Expect(resp.Status).To(Equal("200 OK"))
Expect(body).To(Equal("ok\n"))
})
It("waits for all requests to finish", func() {
mbusClient, err := newMessageBus(config)
Expect(err).ToNot(HaveOccurred())
requestMade := make(chan bool)
requestProcessing := make(chan bool)
responseRead := make(chan bool)
longApp := common.NewTestApp([]route.Uri{"longapp.vcap.me"}, proxyPort, mbusClient, nil, "")
longApp.AddHandler("/", func(w http.ResponseWriter, r *http.Request) {
requestMade <- true
<-requestProcessing
_, ioErr := ioutil.ReadAll(r.Body)
defer r.Body.Close()
Expect(ioErr).ToNot(HaveOccurred())
w.WriteHeader(http.StatusOK)
w.Write([]byte{'b'})
})
longApp.Listen()
routesUri := fmt.Sprintf("http://%s:%s@%s:%d/routes", config.Status.User, config.Status.Pass, localIP, statusPort)
Eventually(func() bool {
return appRegistered(routesUri, longApp)
}).Should(BeTrue())
func NewRouteServiceApp(urls []route.Uri, rPort uint16, mbusClient *nats.Conn, routeService string) *common.TestApp {
app := common.NewTestApp(urls, rPort, mbusClient, nil, routeService)
app.AddHandler("/", rsGreetHandler)
return app
}
}).Should(BeTrue())
}
sessionCookie, vcapCookie, port1 := getSessionAndAppPort("sticky.vcap.me", config.Port)
port2 := getAppPortWithSticky("sticky.vcap.me", config.Port, sessionCookie, vcapCookie)
Expect(port1).To(Equal(port2))
Expect(vcapCookie.Path).To(Equal("/"))
for _, app := range apps {
app.Unregister()
}
})
Context("Stop", func() {
It("no longer proxies http", func() {
app := testcommon.NewTestApp([]route.Uri{"greet.vcap.me"}, config.Port, mbusClient, nil, "")
app.AddHandler("/", func(w http.ResponseWriter, r *http.Request) {
_, err := ioutil.ReadAll(r.Body)
defer r.Body.Close()
Expect(err).ToNot(HaveOccurred())
w.WriteHeader(http.StatusNoContent)
})
app.Listen()
Eventually(func() bool {
return appRegistered(registry, app)
}).Should(BeTrue())
req, err := http.NewRequest("GET", app.Endpoint(), nil)
Expect(err).ToNot(HaveOccurred())
func NewStickyApp(urls []route.Uri, rPort uint16, mbusClient *nats.Conn, tags map[string]string) *common.TestApp {
app := common.NewTestApp(urls, rPort, mbusClient, tags, "")
app.AddHandler("/sticky", stickyHandler(app.Port()))
return app
}