RegisterNoTopoSoloTests(HttpStaticPromTest, HttpGetTpsTest, HttpGetTpsInterruptModeTest, PromConcurrentConnectionsTest,
PromMemLeakTest, HttpClientPostMemLeakTest, HttpInvalidClientRequestMemLeakTest, HttpPostTpsTest, HttpPostTpsInterruptModeTest,
PromConsecutiveConnectionsTest, HttpGetTpsTlsTest, HttpPostTpsTlsTest, HttpClientGetRepeatMTTest, HttpClientPtrGetRepeatMTTest)
- RegisterNoTopo6Tests(HttpClientGetResponseBody6Test, HttpClientGetTlsResponseBody6Test)
+ RegisterNoTopo6SoloTests(HttpClientGetResponseBody6Test, HttpClientGetTlsResponseBody6Test)
}
const wwwRootPath = "/tmp/www_root"
func HttpGetTpsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
serverAddress := s.VppAddr()
- url := "http://" + serverAddress + ":8080/test_file_10M"
+ url := "http://" + serverAddress + ":" + s.Ports.Http + "/test_file_10M"
- vpp.Vppctl("http tps uri tcp://0.0.0.0/8080")
+ vpp.Vppctl("http tps uri tcp://0.0.0.0/" + s.Ports.Http)
s.RunBenchmark("HTTP tps download 10M", 10, 0, httpDownloadBenchmark, url)
}
func HttpGetTpsTlsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
serverAddress := s.VppAddr()
- url := "https://" + serverAddress + ":8080/test_file_10M"
+ url := "https://" + serverAddress + ":" + s.Ports.Http + "/test_file_10M"
- vpp.Vppctl("http tps uri tls://0.0.0.0/8080")
+ vpp.Vppctl("http tps uri tls://0.0.0.0/" + s.Ports.Http)
s.RunBenchmark("HTTP tps download 10M", 10, 0, httpDownloadBenchmark, url)
}
func HttpPostTpsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
serverAddress := s.VppAddr()
- url := "http://" + serverAddress + ":8080/test_file_10M"
+ url := "http://" + serverAddress + ":" + s.Ports.Http + "/test_file_10M"
- vpp.Vppctl("http tps uri tcp://0.0.0.0/8080")
+ vpp.Vppctl("http tps uri tcp://0.0.0.0/" + s.Ports.Http)
s.RunBenchmark("HTTP tps upload 10M", 10, 0, httpUploadBenchmark, url)
}
func HttpPostTpsTlsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
serverAddress := s.VppAddr()
- url := "https://" + serverAddress + ":8080/test_file_10M"
+ url := "https://" + serverAddress + ":" + s.Ports.Http + "/test_file_10M"
- vpp.Vppctl("http tps uri tls://0.0.0.0/8080")
+ vpp.Vppctl("http tps uri tls://0.0.0.0/" + s.Ports.Http)
s.RunBenchmark("HTTP tps upload 10M", 10, 0, httpUploadBenchmark, url)
}
// testing url handler app do not support multi-thread
s.SkipIfMultiWorker()
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers"))
s.Log(vpp.Vppctl("test-url-handler enable"))
transport := http.DefaultTransport
}}
body := []byte("{\"sandwich\": {\"spam\": 2, \"eggs\": 1}}")
- req, err := http.NewRequest("POST", "http://"+serverAddress+":80/test3", bytes.NewBuffer(body))
+ req, err := http.NewRequest("POST", "http://"+serverAddress+"/test3", bytes.NewBuffer(body))
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
s.Log(o1)
s.AssertContains(o1, "established")
- req, err = http.NewRequest("GET", "http://"+serverAddress+":80/test1", nil)
+ req, err = http.NewRequest("GET", "http://"+serverAddress+"/test1", nil)
s.AssertNil(err, fmt.Sprint(err))
clientTrace := &httptrace.ClientTrace{
GotConn: func(info httptrace.GotConnInfo) {
s.AssertContains(o2, "established")
s.AssertEqual(o1, o2)
- req, err = http.NewRequest("GET", "http://"+serverAddress+":80/test2", nil)
+ req, err = http.NewRequest("GET", "http://"+serverAddress+"/test2", nil)
s.AssertNil(err, fmt.Sprint(err))
req = req.WithContext(httptrace.WithClientTrace(req.Context(), clientTrace))
resp, err = client.Do(req)
// testing url handler app do not support multi-thread
s.SkipIfMultiWorker()
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug"))
s.Log(vpp.Vppctl("test-url-handler enable"))
- req1 := "GET /test_delayed HTTP/1.1\r\nHost:" + serverAddress + ":80\r\nUser-Agent:test\r\n\r\n"
- req2 := "GET /test1 HTTP/1.1\r\nHost:" + serverAddress + ":80\r\nUser-Agent:test\r\n\r\n"
+ req1 := "GET /test_delayed HTTP/1.1\r\nHost:" + serverAddress + "\r\nUser-Agent:test\r\n\r\n"
+ req2 := "GET /test1 HTTP/1.1\r\nHost:" + serverAddress + "\r\nUser-Agent:test\r\n\r\n"
- conn, err := net.DialTimeout("tcp", serverAddress+":80", time.Second*30)
+ conn, err := net.DialTimeout("tcp", serverAddress, time.Second*30)
s.AssertNil(err, fmt.Sprint(err))
defer conn.Close()
err = conn.SetDeadline(time.Now().Add(time.Second * 15))
// testing url handler app do not support multi-thread
s.SkipIfMultiWorker()
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug max-body-size 1m"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug max-body-size 1m"))
s.Log(vpp.Vppctl("test-url-handler enable"))
body := make([]byte, 131072)
_, err := rand.Read(body)
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("POST", "http://"+serverAddress+":80/test3", bytes.NewBuffer(body))
+ req, err := http.NewRequest("POST", "http://"+serverAddress+"/test3", bytes.NewBuffer(body))
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
}
func HttpCliTest(s *VethsSuite) {
- s.Containers.ServerVpp.VppInstance.Vppctl("http cli server")
+ serverAddress := s.Interfaces.Server.Ip4AddressString() + ":" + s.Ports.Port1
- uri := "http://" + s.Interfaces.Server.Ip4AddressString() + "/80"
+ cliServerCmd := "http cli server uri http://" + serverAddress
+ s.Containers.ServerVpp.VppInstance.Vppctl(cliServerCmd)
o := s.Containers.ClientVpp.VppInstance.Vppctl("http cli client" +
- " uri " + uri + " query /show/vlib/graph")
+ " uri http://" + serverAddress + " query /show/vlib/graph")
s.Log(o)
s.AssertContains(o, "<html>", "<html> not found in the result!")
clientCleanupDone := false
for nTries := 0; nTries < 30; nTries++ {
o := s.Containers.ClientVpp.VppInstance.Vppctl("show session verbose 2")
- if !strings.Contains(o, "->"+s.Interfaces.Server.Ip4AddressString()+":80") {
+ if !strings.Contains(o, "->"+serverAddress) {
clientCleanupDone = true
break
}
s.AssertEqual(true, clientCleanupDone)
/* test server app stop listen */
- s.Containers.ServerVpp.VppInstance.Vppctl("http cli server listener del")
+ s.Containers.ServerVpp.VppInstance.Vppctl(cliServerCmd + " listener del")
o = s.Containers.ServerVpp.VppInstance.Vppctl("show session verbose proto http")
s.AssertNotContains(o, "LISTEN")
}
func HttpCliTlsTest(s *VethsSuite) {
- uri := "tls://" + s.Interfaces.Server.Ip4AddressString() + "/443"
+ uri := "tls://" + s.Interfaces.Server.Ip4AddressString() + "/" + s.Ports.Port1
s.Containers.ServerVpp.VppInstance.Vppctl("http cli server uri " + uri)
}
func HttpClientTest(s *NoTopoSuite) {
- serverAddress := s.HostAddr()
+ serverAddress := s.HostAddr() + ":" + s.Ports.Http
server := ghttp.NewUnstartedServer()
- l, err := net.Listen("tcp", serverAddress+":80")
+ l, err := net.Listen("tcp", serverAddress)
s.AssertNil(err, fmt.Sprint(err))
server.HTTPTestServer.Listener = l
server.AppendHandlers(
))
server.Start()
defer server.Close()
- uri := "http://" + serverAddress + "/80"
+ uri := "http://" + serverAddress
vpp := s.Containers.Vpp.VppInstance
o := vpp.Vppctl("http cli client uri " + uri + " query /test")
}
func HttpClientErrRespTest(s *NoTopoSuite) {
- serverAddress := s.HostAddr()
+ serverAddress := s.HostAddr() + ":" + s.Ports.Http
server := ghttp.NewUnstartedServer()
- l, err := net.Listen("tcp", serverAddress+":80")
+ l, err := net.Listen("tcp", serverAddress)
s.AssertNil(err, fmt.Sprint(err))
server.HTTPTestServer.Listener = l
server.AppendHandlers(
))
server.Start()
defer server.Close()
- uri := "http://" + serverAddress + "/80"
+ uri := "http://" + serverAddress
vpp := s.Containers.Vpp.VppInstance
o := vpp.Vppctl("http cli client uri " + uri + " query /test")
}
func HttpClientPostFormTest(s *NoTopoSuite) {
- serverAddress := s.HostAddr()
+ serverAddress := s.HostAddr() + ":" + s.Ports.Http
body := "field1=value1&field2=value2"
server := ghttp.NewUnstartedServer()
- l, err := net.Listen("tcp", serverAddress+":80")
+ l, err := net.Listen("tcp", serverAddress)
s.AssertNil(err, fmt.Sprint(err))
server.HTTPTestServer.Listener = l
server.AppendHandlers(
func httpClientGet(s *NoTopoSuite, response string, size int, proto string) {
var l net.Listener
var err error
- var port string
vpp := s.Containers.Vpp.VppInstance
server := ghttp.NewUnstartedServer()
- serverAddress := s.HostAddr()
+ serverAddress := s.HostAddr() + ":" + s.Ports.Http
if proto == "https" {
certFile := "resources/cert/localhost.crt"
s.AssertNil(err)
tlsConfig := &tls.Config{Certificates: []tls.Certificate{cer}}
server.HTTPTestServer.TLS = tlsConfig
- port = "443"
- l, err = tls.Listen("tcp", serverAddress+":443", tlsConfig)
+ l, err = tls.Listen("tcp", serverAddress, tlsConfig)
} else {
- port = "80"
- l, err = net.Listen("tcp", serverAddress+":80")
+ l, err = net.Listen("tcp", serverAddress)
}
s.AssertNil(err, fmt.Sprint(err))
server.Start()
defer server.Close()
- uri := proto + "://" + serverAddress + ":" + port
+ uri := proto + "://" + serverAddress
cmd := "http client use-ptr verbose header Hello:World header Test-H2:Test-K2 save-to response.txt uri " + uri
o := vpp.Vppctl(cmd)
s.AssertContains(file_contents, response)
}
+// registered as a solo test and not using generated ports
func HttpClientGetResponseBody6Test(s *NoTopo6Suite) {
response := "<body>hello world</body>"
size := len(response)
httpClientGet6(s, response, size, "http")
}
+// registered as a solo test and not using generated ports
func HttpClientGetTlsResponseBody6Test(s *NoTopo6Suite) {
response := "<body>hello world</body>"
size := len(response)
func httpClientRepeat(s *NoTopoSuite, requestMethod string, clientArgs string) {
vpp := s.Containers.Vpp.VppInstance
logPath := s.Containers.NginxServer.GetContainerWorkDir() + "/" + s.Containers.NginxServer.Name + "-access.log"
- serverAddress := s.Interfaces.Tap.Ip4AddressString()
+ serverAddress := s.Interfaces.Tap.Ip4AddressString() + ":" + s.Ports.NginxServer
replyCountInt := 0
repeatAmount := 10000
durationInSec := 10
requestMethod += " file /tmp/test_file.txt"
}
- uri := "http://" + serverAddress + ":" + s.GetPortFromPpid() + "/index"
+ uri := "http://" + serverAddress + "/index"
cmd := fmt.Sprintf("http client %s %s duration %d header Hello:World uri %s",
requestMethod, clientArgs, durationInSec, uri)
}
func HttpClientGetTimeout(s *NoTopoSuite) {
- serverAddress := s.HostAddr()
+ serverAddress := s.HostAddr() + ":" + s.Ports.Http
vpp := s.Containers.Vpp.VppInstance
server := ghttp.NewUnstartedServer()
- l, err := net.Listen("tcp", serverAddress+":"+s.GetPortFromPpid())
+ l, err := net.Listen("tcp", serverAddress)
s.AssertNil(err, fmt.Sprint(err))
server.HTTPTestServer.Listener = l
server.AppendHandlers(
))
server.Start()
defer server.Close()
- uri := "http://" + serverAddress + ":" + s.GetPortFromPpid() + "/timeout"
+ uri := "http://" + serverAddress + "/timeout"
cmd := "http client verbose timeout 1 uri " + uri
o := vpp.Vppctl(cmd)
}
func httpClientPostFile(s *NoTopoSuite, usePtr bool, fileSize int) {
- serverAddress := s.HostAddr()
+ serverAddress := s.HostAddr() + ":" + s.Ports.Http
vpp := s.Containers.Vpp.VppInstance
fileName := "/tmp/test_file.txt"
s.Log(vpp.Container.Exec(false, "fallocate -l "+strconv.Itoa(fileSize)+" "+fileName))
s.Log(vpp.Container.Exec(false, "ls -la "+fileName))
server := ghttp.NewUnstartedServer()
- l, err := net.Listen("tcp", serverAddress+":80")
+ l, err := net.Listen("tcp", serverAddress)
s.AssertNil(err, fmt.Sprint(err))
server.HTTPTestServer.Listener = l
server.AppendHandlers(
func HttpStaticPromTest(s *NoTopoSuite) {
query := "stats.prom"
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers"))
s.Log(vpp.Vppctl("prom enable"))
time.Sleep(time.Second * 5)
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/"+query, nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/"+query, nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func PromConcurrentConnectionsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- url := "http://" + serverAddress + ":80/stats.prom"
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ url := "http://" + serverAddress + "/stats.prom"
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers"))
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers"))
s.Log(vpp.Vppctl("prom enable"))
time.Sleep(time.Second * 5)
func PromConsecutiveConnectionsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- url := "http://" + serverAddress + ":80/stats.prom"
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ url := "http://" + serverAddress + "/stats.prom"
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers"))
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers"))
s.Log(vpp.Vppctl("prom enable"))
time.Sleep(time.Second * 5)
s.SkipUnlessLeakCheck()
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- url := "http://" + serverAddress + ":80/stats.prom"
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ url := "http://" + serverAddress + "/stats.prom"
/* no goVPP less noise */
vpp.Disconnect()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers"))
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers"))
s.Log(vpp.Vppctl("prom enable"))
time.Sleep(time.Second * 3)
/* no goVPP less noise */
clientVpp.Disconnect()
- serverVpp.Vppctl("http cli server")
+ serverVpp.Vppctl("http cli server uri " + s.Interfaces.Server.Ip4AddressString() + "/" + s.Ports.Port1)
- uri := "http://" + s.Interfaces.Server.Ip4AddressString() + "/80"
+ uri := "http://" + s.Interfaces.Server.Ip4AddressString() + "/" + s.Ports.Port1
/* warmup request (FIB) */
clientVpp.Vppctl("http cli client uri " + uri + " query /show/version")
func HttpClientPostMemLeakTest(s *NoTopoSuite) {
s.SkipUnlessLeakCheck()
- serverAddress := s.HostAddr()
+ serverAddress := s.HostAddr() + ":" + s.Ports.Http
body := "field1=value1&field2=value2"
- uri := "http://" + serverAddress + "/80"
+ uri := "http://" + serverAddress
vpp := s.Containers.Vpp.VppInstance
/* no goVPP less noise */
vpp.Disconnect()
server := ghttp.NewUnstartedServer()
- l, err := net.Listen("tcp", serverAddress+":80")
+ l, err := net.Listen("tcp", serverAddress)
s.AssertNil(err, fmt.Sprint(err))
server.HTTPTestServer.Listener = l
server.AppendHandlers(
s.SkipUnlessLeakCheck()
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
/* no goVPP less noise */
vpp.Disconnect()
vpp.Vppctl("http cli server")
/* warmup request (FIB) */
- _, err := TcpSendReceive(serverAddress+":80", "GET / HTTP/1.1\r\n")
+ _, err := TcpSendReceive(serverAddress, "GET / HTTP/1.1\r\n")
s.AssertNil(err, fmt.Sprint(err))
/* let's give it some time to clean up sessions, so local port can be reused and we have less noise */
traces1, err := vpp.GetMemoryTrace()
s.AssertNil(err, fmt.Sprint(err))
- _, err = TcpSendReceive(serverAddress+":80", "GET / HTTP/1.1\r\n")
+ _, err = TcpSendReceive(serverAddress, "GET / HTTP/1.1\r\n")
s.AssertNil(err, fmt.Sprint(err))
/* let's give it some time to clean up sessions */
func runWrkPerf(s *NoTopoSuite) {
nConnections := 1000
- serverAddress := s.VppAddr()
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
- args := fmt.Sprintf("-c %d -t 2 -d 30s http://%s:80/64B", nConnections, serverAddress)
+ args := fmt.Sprintf("-c %d -t 2 -d 30s http://%s/64B", nConnections, serverAddress)
s.Containers.Wrk.ExtraRunningArgs = args
s.Containers.Wrk.Run()
s.Log("Please wait for 30s, test is running.")
func HttpStaticFileHandlerWrkTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
vpp.Container.Exec(false, "mkdir -p "+wwwRootPath)
content := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
err := vpp.Container.CreateFile(wwwRootPath+"/64B", content)
s.AssertNil(err, fmt.Sprint(err))
- s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + "/80 private-segment-size 256m"))
+ s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + " private-segment-size 256m"))
runWrkPerf(s)
}
func HttpStaticUrlHandlerWrkTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers private-segment-size 256m"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers private-segment-size 256m"))
s.Log(vpp.Vppctl("test-url-handler enable"))
runWrkPerf(s)
}
s.AssertNil(err, fmt.Sprint(err))
err = vpp.Container.CreateFile(wwwRootPath+"/page.html", content2)
s.AssertNil(err, fmt.Sprint(err))
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + "/80 debug cache-size 2m " + maxAgeFormatted))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + " debug cache-size 2m " + maxAgeFormatted))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/index.html", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/index.html", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
s.AssertHttpContentLength(resp, int64(len([]rune(content))))
s.AssertHttpBody(resp, content)
- req, err = http.NewRequest("GET", "http://"+serverAddress+":80/page.html", nil)
+ req, err = http.NewRequest("GET", "http://"+serverAddress+"/page.html", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err = client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
indexContent := "<html><body>index</body></html>"
err = vpp.Container.CreateFile(wwwRootPath+"/index.html", indexContent)
s.AssertNil(err, fmt.Sprint(err))
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + "/80 debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + " debug"))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/../secret_folder/secret_file.txt", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/../secret_folder/secret_file.txt", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
s.AssertHttpHeaderNotPresent(resp, "Cache-Control")
s.AssertHttpContentLength(resp, int64(0))
- req, err = http.NewRequest("GET", "http://"+serverAddress+":80//////fake/directory///../././//../../secret_folder/secret_file.txt", nil)
+ req, err = http.NewRequest("GET", "http://"+serverAddress+"//////fake/directory///../././//../../secret_folder/secret_file.txt", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err = client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
s.AssertHttpHeaderNotPresent(resp, "Cache-Control")
s.AssertHttpContentLength(resp, int64(0))
- req, err = http.NewRequest("GET", "http://"+serverAddress+":80/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////", nil)
+ req, err = http.NewRequest("GET", "http://"+serverAddress+"/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err = client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
defer resp.Body.Close()
s.Log(DumpHttpResp(resp, true))
s.AssertHttpStatus(resp, 301)
- s.AssertHttpHeaderWithValue(resp, "Location", "http://"+serverAddress+"/index.html")
+ s.AssertHttpHeaderWithValue(resp, "Location", "http://"+s.VppAddr()+"/index.html")
}
func HttpStaticMovedTest(s *NoTopoSuite) {
err := vpp.Container.CreateFile(wwwRootPath+"/tmp.aaa/index.html", "<html><body><p>Hello</p></body></html>")
s.AssertNil(err, fmt.Sprint(err))
serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + "/80 debug"))
+ s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + "/" + s.Ports.Http + " debug"))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/tmp.aaa", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+":"+s.Ports.Http+"/tmp.aaa", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpStaticNotFoundTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
vpp.Container.Exec(false, "mkdir -p "+wwwRootPath)
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + "/80 debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server www-root " + wwwRootPath + " uri tcp://" + serverAddress + " debug"))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/notfound.html", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/notfound.html", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpCliMethodNotAllowedTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("POST", "http://"+serverAddress+":80/test", nil)
+ req, err := http.NewRequest("POST", "http://"+serverAddress+"/test", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpCliBadRequestTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress, nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpStaticBuildInUrlGetVersionTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tls://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tls://" + serverAddress + " url-handlers debug"))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "https://"+serverAddress+":80/version.json", nil)
+ req, err := http.NewRequest("GET", "https://"+serverAddress+"/version.json", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpStaticBuildInUrlGetVersionVerboseTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug"))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/version.json?verbose=true", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/version.json?verbose=true", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpStaticBuildInUrlGetIfListTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug"))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/interface_list.json", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/interface_list.json", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpStaticBuildInUrlGetIfStatsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug"))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/interface_stats.json", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/interface_stats.json", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpStaticBuildInUrlPostIfStatsTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug"))
body := []byte(s.VppIfName())
client := NewHttpClient(defaultHttpTimeout, false)
req, err := http.NewRequest("POST",
- "http://"+serverAddress+":80/interface_stats.json", bytes.NewBuffer(body))
+ "http://"+serverAddress+"/interface_stats.json", bytes.NewBuffer(body))
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpStaticMacTimeTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug"))
s.Log(vpp.Vppctl("mactime enable-disable " + s.VppIfName()))
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/mactime.json", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/mactime.json", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpInvalidRequestLineTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
- resp, err := TcpSendReceive(serverAddress+":80", " GET / HTTP/1.1")
+ resp, err := TcpSendReceive(serverAddress, " GET / HTTP/1.1")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "invalid request line start not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "\rGET / HTTP/1.1")
+ resp, err = TcpSendReceive(serverAddress, "\rGET / HTTP/1.1")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "invalid request line start not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "\nGET / HTTP/1.1")
+ resp, err = TcpSendReceive(serverAddress, "\nGET / HTTP/1.1")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "invalid request line start not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET / HTTP/1.1")
+ resp, err = TcpSendReceive(serverAddress, "GET / HTTP/1.1")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "invalid framing not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET / HTTP/1.1\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET / HTTP/1.1\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "invalid framing not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "HTTP-version must be present")
- resp, err = TcpSendReceive(serverAddress+":80", "GET HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "request-target must be present")
- resp, err = TcpSendReceive(serverAddress+":80", "GET HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "request-target must be present")
- resp, err = TcpSendReceive(serverAddress+":80", "GET / HTTP/x\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET / HTTP/x\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "'HTTP/x' invalid http version not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET / HTTP1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET / HTTP1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "'HTTP1.1' invalid http version not allowed")
}
func HttpRequestLineTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
- resp, err := TcpSendReceive(serverAddress+":80", "\r\nGET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser-Agent:test\r\n\r\n")
+ resp, err := TcpSendReceive(serverAddress, "\r\nGET /show/version HTTP/1.1\r\nHost:"+serverAddress+"\r\nUser-Agent:test\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 200 OK")
s.AssertContains(resp, "<html>", "html content not found")
func HttpInvalidTargetSyntaxTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug"))
- resp, err := TcpSendReceive(serverAddress+":80", "GET /interface|stats.json HTTP/1.1\r\n\r\n")
+ resp, err := TcpSendReceive(serverAddress, "GET /interface|stats.json HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "'|' not allowed in target path")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /interface#stats.json HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /interface#stats.json HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "'#' not allowed in target path")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /interface%stats.json HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /interface%stats.json HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request",
"after '%' there must be two hex-digit characters in target path")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /interface%1stats.json HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /interface%1stats.json HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request",
"after '%' there must be two hex-digit characters in target path")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /interface%Bstats.json HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /interface%Bstats.json HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request",
"after '%' there must be two hex-digit characters in target path")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /interface%stats.json%B HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /interface%stats.json%B HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request",
"after '%' there must be two hex-digit characters in target path")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /version.json?verbose>true HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /version.json?verbose>true HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "'>' not allowed in target query")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /version.json?verbose%true HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /version.json?verbose%true HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request",
"after '%' there must be two hex-digit characters in target query")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /version.json?verbose=%1 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /version.json?verbose=%1 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request",
"after '%' there must be two hex-digit characters in target query")
- resp, err = TcpSendReceive(serverAddress+":80", "GET * HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET * HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "asterisk-form is only used for a server-wide OPTIONS request")
- resp, err = TcpSendReceive(serverAddress+":80", "GET www.example.com:80 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET www.example.com:80 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "authority-form is only used for CONNECT requests")
- resp, err = TcpSendReceive(serverAddress+":80", "CONNECT https://www.example.com/tunnel HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT https://www.example.com/tunnel HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "CONNECT requests must use authority-form only")
}
func HttpInvalidContentLengthTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
- resp, err := TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nContent-Length:\r\n\r\n")
+ resp, err := TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nContent-Length:\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "Content-Length value must be present")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nContent-Length: \r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nContent-Length: \r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "Content-Length value must be present")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nContent-Length: a\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nContent-Length: a\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request",
"Content-Length value other than digit not allowed")
func HttpContentLengthTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug max-body-size 12"))
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + ":80 url-handlers debug max-body-size 12"))
ifName := s.VppIfName()
resp, err := TcpSendReceive(serverAddress+":80",
func HttpHeaderErrorConnectionDropTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug max-body-size 12"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug max-body-size 12"))
request := "POST /interface_stats.json HTTP/1.1\r\nContent-Length: 18234234\r\n\r\n" + s.VppIfName()
- conn, err := net.DialTimeout("tcp", serverAddress+":80", time.Second*30)
+ conn, err := net.DialTimeout("tcp", serverAddress, time.Second*30)
s.AssertNil(err, fmt.Sprint(err))
err = conn.SetDeadline(time.Now().Add(time.Second * 10))
s.AssertNil(err, fmt.Sprint(err))
}
func HttpMethodNotImplementedTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("OPTIONS", "http://"+serverAddress+":80/show/version", nil)
+ req, err := http.NewRequest("OPTIONS", "http://"+serverAddress+"/show/version", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpVersionNotSupportedTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
- resp, err := TcpSendReceive(serverAddress+":80", "GET / HTTP/2\r\n\r\n")
+ resp, err := TcpSendReceive(serverAddress, "GET / HTTP/2\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 505 HTTP Version Not Supported")
}
func HttpUriDecodeTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/sh%6fw%20versio%6E%20verbose", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/sh%6fw%20versio%6E%20verbose", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpAbsoluteFormUriTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
- resp, err := TcpSendReceive(serverAddress+":80", "GET http://"+serverAddress+"/show/version HTTP/1.1\r\n\r\n")
+ resp, err := TcpSendReceive(serverAddress, "GET http://"+serverAddress+"/show/version HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 200 OK")
- resp, err = TcpSendReceive(serverAddress+":80", "GET http://"+serverAddress+":80/show/version HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET http://"+serverAddress+":80/show/version HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 200 OK")
}
func HttpInvalidAuthorityFormUriTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("test proxy server fifo-size 512k server-uri http://%s/8080", serverAddress)
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("test proxy server fifo-size 512k server-uri http://%s", serverAddress)
- resp, err := TcpSendReceive(serverAddress+":8080", "CONNECT 1.2.3.4:80a HTTP/1.1\r\n\r\n")
+ resp, err := TcpSendReceive(serverAddress, "CONNECT 1.2.3.4:80a HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request")
- resp, err = TcpSendReceive(serverAddress+":8080", "CONNECT 1.2.3.4:80000000 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT 1.2.3.4:80000000 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request")
- resp, err = TcpSendReceive(serverAddress+":8080", "CONNECT 1.2a3.4:80 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT 1.2a3.4:80 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request")
- resp, err = TcpSendReceive(serverAddress+":8080", "CONNECT 1.2.4:80 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT 1.2.4:80 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request")
- resp, err = TcpSendReceive(serverAddress+":8080", "CONNECT [dead:beef::1234:443 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT [dead:beef::1234:443 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request")
- resp, err = TcpSendReceive(serverAddress+":8080", "CONNECT [zyx:beef::1234]:443 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT [zyx:beef::1234]:443 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request")
- resp, err = TcpSendReceive(serverAddress+":8080", "CONNECT dead:beef::1234:443 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT dead:beef::1234:443 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request")
- resp, err = TcpSendReceive(serverAddress+":8080", "CONNECT example.org:443 HTTP/1.1\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "CONNECT example.org:443 HTTP/1.1\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "name resolution not supported")
}
func HttpHeadersTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
transport := http.DefaultTransport
transport.(*http.Transport).Proxy = nil
Timeout: time.Second * 30,
}
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/show/version", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/show/version", nil)
s.AssertNil(err, fmt.Sprint(err))
req.Header.Add("Accept", "text/xml")
req.Header.Add("Accept-Language", "*")
s.AssertNil(err, fmt.Sprint(err))
s.AssertNotContains(string(data), "<html>", "html content received instead of plain text")
- req2, err := http.NewRequest("GET", "http://"+serverAddress+":80/show/version", nil)
+ req2, err := http.NewRequest("GET", "http://"+serverAddress+"/show/version", nil)
s.AssertNil(err, fmt.Sprint(err))
req2.Header.Add("Accept", "text/html")
resp2, err := client.Do(req2)
client.CloseIdleConnections()
for nTries := 0; nTries < 10; nTries++ {
o := vpp.Vppctl("show session verbose 2")
- if !strings.Contains(o, serverAddress+":80->"+s.HostAddr()) {
+ if !strings.Contains(o, serverAddress+"->"+s.HostAddr()) {
break
}
time.Sleep(1 * time.Second)
func HttpInvalidHeadersTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
- resp, err := TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nUser-Agent: test\r\n")
+ resp, err := TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nUser-Agent: test\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "Header section must end with CRLF CRLF")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser@Agent:test\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser@Agent:test\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "'@' not allowed in field name")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser-Agent\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser-Agent\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "incomplete field line not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\n: test\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\n: test\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "empty field name not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\rUser-Agent:test\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\rUser-Agent:test\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "invalid field line end not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\nUser-Agent:test\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\nUser-Agent:test\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "invalid field line end not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser-Agent:\r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser-Agent:\r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "empty field value not allowed")
- resp, err = TcpSendReceive(serverAddress+":80", "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser-Agent: \r\n\r\n")
+ resp, err = TcpSendReceive(serverAddress, "GET /show/version HTTP/1.1\r\nHost:"+serverAddress+":80\r\nUser-Agent: \r\n\r\n")
s.AssertNil(err, fmt.Sprint(err))
s.AssertContains(resp, "HTTP/1.1 400 Bad Request", "empty field value not allowed")
}
func HeaderServerTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- vpp.Vppctl("http cli server")
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ vpp.Vppctl("http cli server uri http://" + serverAddress)
client := NewHttpClient(defaultHttpTimeout, false)
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/show/version", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/show/version", nil)
s.AssertNil(err, fmt.Sprint(err))
resp, err := client.Do(req)
s.AssertNil(err, fmt.Sprint(err))
func HttpConnTimeoutTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers debug keepalive-timeout 2"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers debug keepalive-timeout 2"))
- req := "GET /version.json HTTP/1.1\r\nHost:" + serverAddress + ":80\r\nUser-Agent:test\r\n\r\n"
- conn, err := net.DialTimeout("tcp", serverAddress+":80", time.Second*30)
+ req := "GET /version.json HTTP/1.1\r\nHost:" + serverAddress + "\r\nUser-Agent:test\r\n\r\n"
+ conn, err := net.DialTimeout("tcp", serverAddress, time.Second*30)
s.AssertNil(err, fmt.Sprint(err))
defer conn.Close()
err = conn.SetDeadline(time.Now().Add(time.Second * 30))
func HttpIgnoreH2UpgradeTest(s *NoTopoSuite) {
vpp := s.Containers.Vpp.VppInstance
- serverAddress := s.VppAddr()
- s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + "/80 url-handlers"))
+ serverAddress := s.VppAddr() + ":" + s.Ports.Http
+ s.Log(vpp.Vppctl("http static server uri tcp://" + serverAddress + " url-handlers"))
transport := http.DefaultTransport
transport.(*http.Transport).Proxy = nil
Timeout: time.Second * 30,
}
- req, err := http.NewRequest("GET", "http://"+serverAddress+":80/version.json", nil)
+ req, err := http.NewRequest("GET", "http://"+serverAddress+"/version.json", nil)
s.AssertNil(err, fmt.Sprint(err))
req.Header.Add("Connection", "Upgrade")
req.Header.Add("Upgrade", "HTTP/2.0")
VppConnectUdpUnknownCapsuleTest, VppConnectUdpClientCloseTest, VppConnectUdpInvalidTargetTest)
RegisterVppUdpProxySoloTests(VppProxyUdpMigrationMTTest, VppConnectUdpStressMTTest, VppConnectUdpStressTest)
RegisterEnvoyProxyTests(EnvoyProxyHttpGetTcpTest, EnvoyProxyHttpPutTcpTest)
- RegisterNginxProxyTests(NginxMirroringTest)
- RegisterNginxProxySoloTests(MirrorMultiThreadTest)
+ RegisterNginxProxySoloTests(NginxMirroringTest, MirrorMultiThreadTest)
}
func configureVppProxy(s *VppProxySuite, proto string, proxyPort uint16) {
proto = "tcp"
}
if proto != "http" {
- cmd += fmt.Sprintf(" client-uri %s://%s/%d", proto, s.ServerAddr(), s.ServerPort())
+ cmd += fmt.Sprintf(" client-uri %s://%s/%d", proto, s.ServerAddr(), s.Ports.Server)
}
output := vppProxy.Vppctl(cmd)
s.Containers.IperfC.Run()
s.Containers.IperfS.Run()
vppProxy := s.Containers.VppProxy.VppInstance
- proxyPort, err := strconv.Atoi(s.GetPortFromPpid())
- s.AssertNil(err)
// tap interfaces are created on test setup with 1 rx-queue,
// need to recreate them with 2 + consistent-qp
s.AssertNil(vppProxy.DeleteTap(s.Interfaces.Client))
s.AssertNil(vppProxy.CreateTap(s.Interfaces.Client, false, 2, uint32(s.Interfaces.Client.Peer.Index), Consistent_qp))
- configureVppProxy(s, "tcp", uint16(proxyPort))
+ configureVppProxy(s, "tcp", s.Ports.Proxy)
if proto == "udp" {
- configureVppProxy(s, "udp", uint16(proxyPort))
+ configureVppProxy(s, "udp", s.Ports.Proxy)
proto = "-u"
} else {
proto = ""
go func() {
defer GinkgoRecover()
- cmd := fmt.Sprintf("iperf3 -4 -s -B %s -p %s --logfile %s", s.ServerAddr(), fmt.Sprint(s.ServerPort()), s.IperfLogFileName(s.Containers.IperfS))
+ cmd := fmt.Sprintf("iperf3 -4 -s -B %s -p %s --logfile %s", s.ServerAddr(), fmt.Sprint(s.Ports.Server), s.IperfLogFileName(s.Containers.IperfS))
s.StartServerApp(s.Containers.IperfS, "iperf3", cmd, srvCh, stopServerCh)
}()
- err = <-srvCh
+ err := <-srvCh
s.AssertNil(err, fmt.Sprint(err))
go func() {
defer GinkgoRecover()
- cmd := fmt.Sprintf("iperf3 -c %s -P 4 -l 1460 -b 10g -J -p %d -B %s %s", s.VppProxyAddr(), proxyPort, s.ClientAddr(), proto)
+ cmd := fmt.Sprintf("iperf3 -c %s -P 4 -l 1460 -b 10g -J -p %d -B %s %s", s.VppProxyAddr(), s.Ports.Proxy, s.ClientAddr(), proto)
s.StartClientApp(s.Containers.IperfC, cmd, clnCh, clnRes)
}()
}
func VppProxyHttpGetTcpTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
s.SetupNginxServer()
- configureVppProxy(s, "tcp", proxyPort)
- uri := fmt.Sprintf("http://%s:%d/httpTestFile", s.VppProxyAddr(), proxyPort)
+ configureVppProxy(s, "tcp", s.Ports.Proxy)
+ uri := fmt.Sprintf("http://%s:%d/httpTestFile", s.VppProxyAddr(), s.Ports.Proxy)
s.CurlDownloadResource(uri)
}
func VppProxyHttpGetTlsTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
s.SetupNginxServer()
- configureVppProxy(s, "tls", proxyPort)
- uri := fmt.Sprintf("https://%s:%d/httpTestFile", s.VppProxyAddr(), proxyPort)
+ configureVppProxy(s, "tls", s.Ports.Proxy)
+ uri := fmt.Sprintf("https://%s:%d/httpTestFile", s.VppProxyAddr(), s.Ports.Proxy)
s.CurlDownloadResource(uri)
}
}
func VppProxyHttpPutTcpTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
s.SetupNginxServer()
- configureVppProxy(s, "tcp", proxyPort)
- uri := fmt.Sprintf("http://%s:%d/upload/testFile", s.VppProxyAddr(), proxyPort)
+ configureVppProxy(s, "tcp", s.Ports.Proxy)
+ uri := fmt.Sprintf("http://%s:%d/upload/testFile", s.VppProxyAddr(), s.Ports.Proxy)
s.CurlUploadResource(uri, CurlContainerTestFile)
}
func VppProxyHttpPutTlsTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
s.SetupNginxServer()
- configureVppProxy(s, "tls", proxyPort)
- uri := fmt.Sprintf("https://%s:%d/upload/testFile", s.VppProxyAddr(), proxyPort)
+ configureVppProxy(s, "tls", s.Ports.Proxy)
+ uri := fmt.Sprintf("https://%s:%d/upload/testFile", s.VppProxyAddr(), s.Ports.Proxy)
s.CurlUploadResource(uri, CurlContainerTestFile)
}
func EnvoyProxyHttpGetTcpTest(s *EnvoyProxySuite) {
- uri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ProxyAddr(), s.ProxyPort())
+ uri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ProxyAddr(), s.Ports.Proxy)
s.CurlDownloadResource(uri)
}
func EnvoyProxyHttpPutTcpTest(s *EnvoyProxySuite) {
- uri := fmt.Sprintf("http://%s:%d/upload/testFile", s.ProxyAddr(), s.ProxyPort())
+ uri := fmt.Sprintf("http://%s:%d/upload/testFile", s.ProxyAddr(), s.Ports.Proxy)
s.CurlUploadResource(uri, CurlContainerTestFile)
}
nginxMirroring(s, true)
}
+// unstable, registered as solo
func NginxMirroringTest(s *NginxProxySuite) {
nginxMirroring(s, false)
}
s.CreateNginxProxyConfig(s.Containers.NginxProxy, multiThreadWorkers)
s.Containers.NginxProxy.Start()
vpp.WaitForApp("nginx-", 5)
- uri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ProxyAddr(), s.ProxyPort())
+ uri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ProxyAddr(), s.Ports.Proxy)
s.CurlDownloadResource(uri)
}
func VppConnectProxyGetTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
s.SetupNginxServer()
- configureVppProxy(s, "http", proxyPort)
+ configureVppProxy(s, "http", s.Ports.Proxy)
- targetUri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ServerAddr(), s.ServerPort())
- proxyUri := fmt.Sprintf("http://%s:%d", s.VppProxyAddr(), proxyPort)
+ targetUri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ServerAddr(), s.Ports.Server)
+ proxyUri := fmt.Sprintf("http://%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
s.CurlDownloadResourceViaTunnel(targetUri, proxyUri)
}
func VppConnectProxyConnectionFailedMTTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
s.SetupNginxServer()
- configureVppProxy(s, "http", proxyPort)
+ configureVppProxy(s, "http", s.Ports.Proxy)
- targetUri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ServerAddr(), s.ServerPort()+1)
- proxyUri := fmt.Sprintf("http://%s:%d", s.VppProxyAddr(), proxyPort)
+ targetUri := fmt.Sprintf("http://%s:%d/httpTestFile", s.ServerAddr(), s.Ports.Server+1)
+ proxyUri := fmt.Sprintf("http://%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
_, log := s.CurlRequestViaTunnel(targetUri, proxyUri)
s.AssertContains(log, "HTTP/1.1 502 Bad Gateway")
}
func VppConnectProxyPutTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
s.SetupNginxServer()
- configureVppProxy(s, "http", proxyPort)
+ configureVppProxy(s, "http", s.Ports.Proxy)
- proxyUri := fmt.Sprintf("http://%s:%d", s.VppProxyAddr(), proxyPort)
- targetUri := fmt.Sprintf("http://%s:%d/upload/testFile", s.ServerAddr(), s.ServerPort())
+ proxyUri := fmt.Sprintf("http://%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
+ targetUri := fmt.Sprintf("http://%s:%d/upload/testFile", s.ServerAddr(), s.Ports.Server)
s.CurlUploadResourceViaTunnel(targetUri, proxyUri, CurlContainerTestFile)
}
wg sync.WaitGroup
)
stop := make(chan struct{})
- targetUri := fmt.Sprintf("%s:%d", s.ServerAddr(), s.ServerPort())
+ targetUri := fmt.Sprintf("%s:%d", s.ServerAddr(), s.Ports.Server)
s.Log("Running 30s test @ " + targetUri)
for i := 0; i < 1000; i++ {
}
func VppConnectProxyStressTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
remoteServerConn := s.StartEchoServer()
defer remoteServerConn.Close()
- configureVppProxy(s, "http", proxyPort)
+ configureVppProxy(s, "http", s.Ports.Proxy)
// no goVPP less noise
s.Containers.VppProxy.VppInstance.Disconnect()
- vppConnectProxyStressLoad(s, strconv.Itoa(int(proxyPort)))
+ vppConnectProxyStressLoad(s, strconv.Itoa(int(s.Ports.Proxy)))
}
func VppConnectProxyStressMTTest(s *VppProxySuite) {
- var proxyPort uint16 = 8080
remoteServerConn := s.StartEchoServer()
defer remoteServerConn.Close()
s.AssertNil(vppProxy.DeleteTap(s.Interfaces.Client))
s.AssertNil(vppProxy.CreateTap(s.Interfaces.Client, false, 2, uint32(s.Interfaces.Client.Peer.Index), Consistent_qp))
- configureVppProxy(s, "http", proxyPort)
+ configureVppProxy(s, "http", s.Ports.Proxy)
// no goVPP less noise
vppProxy.Disconnect()
- vppConnectProxyStressLoad(s, strconv.Itoa(int(proxyPort)))
+ vppConnectProxyStressLoad(s, strconv.Itoa(int(s.Ports.Proxy)))
}
func VppProxyUdpTest(s *VppUdpProxySuite) {
defer remoteServerConn.Close()
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri udp://%s/%d", s.VppProxyAddr(), s.ProxyPort())
- cmd += fmt.Sprintf(" client-uri udp://%s/%d", s.ServerAddr(), s.ServerPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri udp://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
+ cmd += fmt.Sprintf(" client-uri udp://%s/%d", s.ServerAddr(), s.Ports.Server)
s.Log(vppProxy.Vppctl(cmd))
b := make([]byte, 1500)
defer remoteServerConn.Close()
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri udp://%s/%d", s.VppProxyAddr(), s.ProxyPort())
- cmd += fmt.Sprintf(" client-uri udp://%s/%d", s.ServerAddr(), s.ServerPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri udp://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
+ cmd += fmt.Sprintf(" client-uri udp://%s/%d", s.ServerAddr(), s.Ports.Server)
s.Log(vppProxy.Vppctl(cmd))
b := make([]byte, 1500)
defer remoteServerConn.Close()
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.ProxyPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
s.Log(vppProxy.Vppctl(cmd))
- proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.ProxyPort())
- targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.ProxyPort(), s.ServerAddr(), s.ServerPort())
+ proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
+ targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.Ports.Proxy, s.ServerAddr(), s.Ports.Server)
c := s.NewConnectUdpClient(s.MaxTimeout, true)
err := c.Dial(proxyAddress, targetUri)
s.AssertNil(err, fmt.Sprint(err))
func VppConnectUdpInvalidTargetTest(s *VppUdpProxySuite) {
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.ProxyPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
s.Log(vppProxy.Vppctl(cmd))
- proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.ProxyPort())
+ proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
- targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/example.com/80/", s.VppProxyAddr(), s.ProxyPort())
+ targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/example.com/80/", s.VppProxyAddr(), s.Ports.Proxy)
c := s.NewConnectUdpClient(s.MaxTimeout, true)
err := c.Dial(proxyAddress, targetUri)
s.AssertNotNil(err, "name resolution not supported")
- targetUri = fmt.Sprintf("http://%s:%d/.well-known/masque/udp/1.2.3.4/800000000/", s.VppProxyAddr(), s.ProxyPort())
+ targetUri = fmt.Sprintf("http://%s:%d/.well-known/masque/udp/1.2.3.4/800000000/", s.VppProxyAddr(), s.Ports.Proxy)
c = s.NewConnectUdpClient(s.MaxTimeout, true)
err = c.Dial(proxyAddress, targetUri)
s.AssertNotNil(err, "invalid port number")
- targetUri = fmt.Sprintf("http://%s:%d/masque/udp/1.2.3.4/80/", s.VppProxyAddr(), s.ProxyPort())
+ targetUri = fmt.Sprintf("http://%s:%d/masque/udp/1.2.3.4/80/", s.VppProxyAddr(), s.Ports.Proxy)
c = s.NewConnectUdpClient(s.MaxTimeout, true)
err = c.Dial(proxyAddress, targetUri)
s.AssertNotNil(err, "invalid prefix")
defer remoteServerConn.Close()
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.ProxyPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
s.Log(vppProxy.Vppctl(cmd))
- proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.ProxyPort())
- targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.ProxyPort(), s.ServerAddr(), s.ServerPort())
+ proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
+ targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.Ports.Proxy, s.ServerAddr(), s.Ports.Server)
c := s.NewConnectUdpClient(s.MaxTimeout, true)
err := c.Dial(proxyAddress, targetUri)
s.AssertNil(err, fmt.Sprint(err))
defer remoteServerConn.Close()
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.ProxyPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
s.Log(vppProxy.Vppctl(cmd))
- proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.ProxyPort())
- targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.ProxyPort(), s.ServerAddr(), s.ServerPort())
+ proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
+ targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.Ports.Proxy, s.ServerAddr(), s.Ports.Server)
c := s.NewConnectUdpClient(s.MaxTimeout, true)
err := c.Dial(proxyAddress, targetUri)
s.AssertNil(err, fmt.Sprint(err))
defer remoteServerConn.Close()
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.ProxyPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
s.Log(vppProxy.Vppctl(cmd))
- proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.ProxyPort())
- targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.ProxyPort(), s.ServerAddr(), s.ServerPort())
+ proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
+ targetUri := fmt.Sprintf("http://%s:%d/.well-known/masque/udp/%s/%d/", s.VppProxyAddr(), s.Ports.Proxy, s.ServerAddr(), s.Ports.Server)
c := s.NewConnectUdpClient(s.MaxTimeout, true)
err := c.Dial(proxyAddress, targetUri)
s.AssertNil(err, fmt.Sprint(err))
err = c.Close()
s.AssertNil(err, fmt.Sprint(err))
- proxyClientConn := fmt.Sprintf("[T] %s:%d->%s", s.VppProxyAddr(), s.ProxyPort(), s.ClientAddr())
+ proxyClientConn := fmt.Sprintf("[T] %s:%d->%s", s.VppProxyAddr(), s.Ports.Proxy, s.ClientAddr())
proxyTargetConn := fmt.Sprintf("[U] %s:", s.Interfaces.Server.Peer.Ip4AddressString())
for nTries := 0; nTries < 10; nTries++ {
o := vppProxy.Vppctl("show session verbose 2")
wg sync.WaitGroup
)
- proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.ProxyPort())
- targetUri := fmt.Sprintf("http://%s/.well-known/masque/udp/%s/%d/", proxyAddress, s.ServerAddr(), s.ServerPort())
+ proxyAddress := fmt.Sprintf("%s:%d", s.VppProxyAddr(), s.Ports.Proxy)
+ targetUri := fmt.Sprintf("http://%s/.well-known/masque/udp/%s/%d/", proxyAddress, s.ServerAddr(), s.Ports.Server)
// warm-up
warmUp := s.NewConnectUdpClient(s.MaxTimeout, false)
defer remoteServerConn.Close()
vppProxy := s.Containers.VppProxy.VppInstance
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.ProxyPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
s.Log(vppProxy.Vppctl(cmd))
// no goVPP less noise
vppProxy := s.Containers.VppProxy.VppInstance
vppProxy.Disconnect()
- cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.ProxyPort())
+ cmd := fmt.Sprintf("test proxy server fifo-size 512k server-uri http://%s/%d", s.VppProxyAddr(), s.Ports.Proxy)
s.Log(vppProxy.Vppctl(cmd))
// no goVPP less noise
Code Review / vpp.git / commitdiff