add e2e tests for v1 config (#3608)

test/e2e/legacy/features/bandwidth_limit.go

@@ -0,0 +1,105 @@
+package features
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/onsi/ginkgo/v2"
+
+	plugin "github.com/fatedier/frp/pkg/plugin/server"
+	"github.com/fatedier/frp/test/e2e/framework"
+	"github.com/fatedier/frp/test/e2e/framework/consts"
+	plugintest "github.com/fatedier/frp/test/e2e/legacy/plugin"
+	"github.com/fatedier/frp/test/e2e/mock/server/streamserver"
+	"github.com/fatedier/frp/test/e2e/pkg/request"
+)
+
+var _ = ginkgo.Describe("[Feature: Bandwidth Limit]", func() {
+	f := framework.NewDefaultFramework()
+
+	ginkgo.It("Proxy Bandwidth Limit by Client", func() {
+		serverConf := consts.LegacyDefaultServerConfig
+		clientConf := consts.LegacyDefaultClientConfig
+
+		localPort := f.AllocPort()
+		localServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(localPort))
+		f.RunServer("", localServer)
+
+		remotePort := f.AllocPort()
+		clientConf += fmt.Sprintf(`
+			[tcp]
+			type = tcp
+			local_port = %d
+			remote_port = %d
+			bandwidth_limit = 10KB
+			`, localPort, remotePort)
+
+		f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+		content := strings.Repeat("a", 50*1024) // 5KB
+		start := time.Now()
+		framework.NewRequestExpect(f).Port(remotePort).RequestModify(func(r *request.Request) {
+			r.Body([]byte(content)).Timeout(30 * time.Second)
+		}).ExpectResp([]byte(content)).Ensure()
+
+		duration := time.Since(start)
+		framework.Logf("request duration: %s", duration.String())
+
+		framework.ExpectTrue(duration.Seconds() > 8, "100Kb with 10KB limit, want > 8 seconds, but got %s", duration.String())
+	})
+
+	ginkgo.It("Proxy Bandwidth Limit by Server", func() {
+		// new test plugin server
+		newFunc := func() *plugin.Request {
+			var r plugin.Request
+			r.Content = &plugin.NewProxyContent{}
+			return &r
+		}
+		pluginPort := f.AllocPort()
+		handler := func(req *plugin.Request) *plugin.Response {
+			var ret plugin.Response
+			content := req.Content.(*plugin.NewProxyContent)
+			content.BandwidthLimit = "10KB"
+			content.BandwidthLimitMode = "server"
+			ret.Content = content
+			return &ret
+		}
+		pluginServer := plugintest.NewHTTPPluginServer(pluginPort, newFunc, handler, nil)
+
+		f.RunServer("", pluginServer)
+
+		serverConf := consts.LegacyDefaultServerConfig + fmt.Sprintf(`
+		[plugin.test]
+		addr = 127.0.0.1:%d
+		path = /handler
+		ops = NewProxy
+		`, pluginPort)
+		clientConf := consts.LegacyDefaultClientConfig
+
+		localPort := f.AllocPort()
+		localServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(localPort))
+		f.RunServer("", localServer)
+
+		remotePort := f.AllocPort()
+		clientConf += fmt.Sprintf(`
+			[tcp]
+			type = tcp
+			local_port = %d
+			remote_port = %d
+			`, localPort, remotePort)
+
+		f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+		content := strings.Repeat("a", 50*1024) // 5KB
+		start := time.Now()
+		framework.NewRequestExpect(f).Port(remotePort).RequestModify(func(r *request.Request) {
+			r.Body([]byte(content)).Timeout(30 * time.Second)
+		}).ExpectResp([]byte(content)).Ensure()
+
+		duration := time.Since(start)
+		framework.Logf("request duration: %s", duration.String())
+
+		framework.ExpectTrue(duration.Seconds() > 8, "100Kb with 10KB limit, want > 8 seconds, but got %s", duration.String())
+	})
+})

test/e2e/legacy/features/chaos.go

@@ -0,0 +1,65 @@
+package features
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/onsi/ginkgo/v2"
+
+	"github.com/fatedier/frp/test/e2e/framework"
+)
+
+var _ = ginkgo.Describe("[Feature: Chaos]", func() {
+	f := framework.NewDefaultFramework()
+
+	ginkgo.It("reconnect after frps restart", func() {
+		serverPort := f.AllocPort()
+		serverConfigPath := f.GenerateConfigFile(fmt.Sprintf(`
+		[common]
+		bind_addr = 0.0.0.0
+		bind_port = %d
+		`, serverPort))
+
+		remotePort := f.AllocPort()
+		clientConfigPath := f.GenerateConfigFile(fmt.Sprintf(`
+		[common]
+		server_port = %d
+		log_level = trace
+
+		[tcp]
+		type = tcp
+		local_port = %d
+		remote_port = %d
+		`, serverPort, f.PortByName(framework.TCPEchoServerPort), remotePort))
+
+		// 1. start frps and frpc, expect request success
+		ps, _, err := f.RunFrps("-c", serverConfigPath)
+		framework.ExpectNoError(err)
+
+		pc, _, err := f.RunFrpc("-c", clientConfigPath)
+		framework.ExpectNoError(err)
+		framework.NewRequestExpect(f).Port(remotePort).Ensure()
+
+		// 2. stop frps, expect request failed
+		_ = ps.Stop()
+		time.Sleep(200 * time.Millisecond)
+		framework.NewRequestExpect(f).Port(remotePort).ExpectError(true).Ensure()
+
+		// 3. restart frps, expect request success
+		_, _, err = f.RunFrps("-c", serverConfigPath)
+		framework.ExpectNoError(err)
+		time.Sleep(2 * time.Second)
+		framework.NewRequestExpect(f).Port(remotePort).Ensure()
+
+		// 4. stop frpc, expect request failed
+		_ = pc.Stop()
+		time.Sleep(200 * time.Millisecond)
+		framework.NewRequestExpect(f).Port(remotePort).ExpectError(true).Ensure()
+
+		// 5. restart frpc, expect request success
+		_, _, err = f.RunFrpc("-c", clientConfigPath)
+		framework.ExpectNoError(err)
+		time.Sleep(time.Second)
+		framework.NewRequestExpect(f).Port(remotePort).Ensure()
+	})
+})

test/e2e/legacy/features/group.go

@@ -0,0 +1,261 @@
+package features
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/onsi/ginkgo/v2"
+
+	"github.com/fatedier/frp/test/e2e/framework"
+	"github.com/fatedier/frp/test/e2e/framework/consts"
+	"github.com/fatedier/frp/test/e2e/mock/server/httpserver"
+	"github.com/fatedier/frp/test/e2e/mock/server/streamserver"
+	"github.com/fatedier/frp/test/e2e/pkg/request"
+)
+
+var _ = ginkgo.Describe("[Feature: Group]", func() {
+	f := framework.NewDefaultFramework()
+
+	newHTTPServer := func(port int, respContent string) *httpserver.Server {
+		return httpserver.New(
+			httpserver.WithBindPort(port),
+			httpserver.WithHandler(framework.SpecifiedHTTPBodyHandler([]byte(respContent))),
+		)
+	}
+
+	validateFooBarResponse := func(resp *request.Response) bool {
+		if string(resp.Content) == "foo" || string(resp.Content) == "bar" {
+			return true
+		}
+		return false
+	}
+
+	doFooBarHTTPRequest := func(vhostPort int, host string) []string {
+		results := []string{}
+		var wait sync.WaitGroup
+		var mu sync.Mutex
+		expectFn := func() {
+			framework.NewRequestExpect(f).Port(vhostPort).
+				RequestModify(func(r *request.Request) {
+					r.HTTP().HTTPHost(host)
+				}).
+				Ensure(validateFooBarResponse, func(resp *request.Response) bool {
+					mu.Lock()
+					defer mu.Unlock()
+					results = append(results, string(resp.Content))
+					return true
+				})
+		}
+		for i := 0; i < 10; i++ {
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				expectFn()
+			}()
+		}
+
+		wait.Wait()
+		return results
+	}
+
+	ginkgo.Describe("Load Balancing", func() {
+		ginkgo.It("TCP", func() {
+			serverConf := consts.LegacyDefaultServerConfig
+			clientConf := consts.LegacyDefaultClientConfig
+
+			fooPort := f.AllocPort()
+			fooServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(fooPort), streamserver.WithRespContent([]byte("foo")))
+			f.RunServer("", fooServer)
+
+			barPort := f.AllocPort()
+			barServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(barPort), streamserver.WithRespContent([]byte("bar")))
+			f.RunServer("", barServer)
+
+			remotePort := f.AllocPort()
+			clientConf += fmt.Sprintf(`
+			[foo]
+			type = tcp
+			local_port = %d
+			remote_port = %d
+			group = test
+			group_key = 123
+
+			[bar]
+			type = tcp
+			local_port = %d
+			remote_port = %d
+			group = test
+			group_key = 123
+			`, fooPort, remotePort, barPort, remotePort)
+
+			f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+			fooCount := 0
+			barCount := 0
+			for i := 0; i < 10; i++ {
+				framework.NewRequestExpect(f).Explain("times " + strconv.Itoa(i)).Port(remotePort).Ensure(func(resp *request.Response) bool {
+					switch string(resp.Content) {
+					case "foo":
+						fooCount++
+					case "bar":
+						barCount++
+					default:
+						return false
+					}
+					return true
+				})
+			}
+
+			framework.ExpectTrue(fooCount > 1 && barCount > 1, "fooCount: %d, barCount: %d", fooCount, barCount)
+		})
+	})
+
+	ginkgo.Describe("Health Check", func() {
+		ginkgo.It("TCP", func() {
+			serverConf := consts.LegacyDefaultServerConfig
+			clientConf := consts.LegacyDefaultClientConfig
+
+			fooPort := f.AllocPort()
+			fooServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(fooPort), streamserver.WithRespContent([]byte("foo")))
+			f.RunServer("", fooServer)
+
+			barPort := f.AllocPort()
+			barServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(barPort), streamserver.WithRespContent([]byte("bar")))
+			f.RunServer("", barServer)
+
+			remotePort := f.AllocPort()
+			clientConf += fmt.Sprintf(`
+			[foo]
+			type = tcp
+			local_port = %d
+			remote_port = %d
+			group = test
+			group_key = 123
+			health_check_type = tcp
+			health_check_interval_s = 1
+
+			[bar]
+			type = tcp
+			local_port = %d
+			remote_port = %d
+			group = test
+			group_key = 123
+			health_check_type = tcp
+			health_check_interval_s = 1
+			`, fooPort, remotePort, barPort, remotePort)
+
+			f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+			// check foo and bar is ok
+			results := []string{}
+			for i := 0; i < 10; i++ {
+				framework.NewRequestExpect(f).Port(remotePort).Ensure(validateFooBarResponse, func(resp *request.Response) bool {
+					results = append(results, string(resp.Content))
+					return true
+				})
+			}
+			framework.ExpectContainElements(results, []string{"foo", "bar"})
+
+			// close bar server, check foo is ok
+			barServer.Close()
+			time.Sleep(2 * time.Second)
+			for i := 0; i < 10; i++ {
+				framework.NewRequestExpect(f).Port(remotePort).ExpectResp([]byte("foo")).Ensure()
+			}
+
+			// resume bar server, check foo and bar is ok
+			f.RunServer("", barServer)
+			time.Sleep(2 * time.Second)
+			results = []string{}
+			for i := 0; i < 10; i++ {
+				framework.NewRequestExpect(f).Port(remotePort).Ensure(validateFooBarResponse, func(resp *request.Response) bool {
+					results = append(results, string(resp.Content))
+					return true
+				})
+			}
+			framework.ExpectContainElements(results, []string{"foo", "bar"})
+		})
+
+		ginkgo.It("HTTP", func() {
+			vhostPort := f.AllocPort()
+			serverConf := consts.LegacyDefaultServerConfig + fmt.Sprintf(`
+			vhost_http_port = %d
+			`, vhostPort)
+			clientConf := consts.LegacyDefaultClientConfig
+
+			fooPort := f.AllocPort()
+			fooServer := newHTTPServer(fooPort, "foo")
+			f.RunServer("", fooServer)
+
+			barPort := f.AllocPort()
+			barServer := newHTTPServer(barPort, "bar")
+			f.RunServer("", barServer)
+
+			clientConf += fmt.Sprintf(`
+			[foo]
+			type = http
+			local_port = %d
+			custom_domains = example.com
+			group = test
+			group_key = 123
+			health_check_type = http
+			health_check_interval_s = 1
+			health_check_url = /healthz
+
+			[bar]
+			type = http
+			local_port = %d
+			custom_domains = example.com
+			group = test
+			group_key = 123
+			health_check_type = http
+			health_check_interval_s = 1
+			health_check_url = /healthz
+			`, fooPort, barPort)
+
+			f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+			// send first HTTP request
+			var contents []string
+			framework.NewRequestExpect(f).Port(vhostPort).
+				RequestModify(func(r *request.Request) {
+					r.HTTP().HTTPHost("example.com")
+				}).
+				Ensure(func(resp *request.Response) bool {
+					contents = append(contents, string(resp.Content))
+					return true
+				})
+
+			// send second HTTP request, should be forwarded to another service
+			framework.NewRequestExpect(f).Port(vhostPort).
+				RequestModify(func(r *request.Request) {
+					r.HTTP().HTTPHost("example.com")
+				}).
+				Ensure(func(resp *request.Response) bool {
+					contents = append(contents, string(resp.Content))
+					return true
+				})
+
+			framework.ExpectContainElements(contents, []string{"foo", "bar"})
+
+			// check foo and bar is ok
+			results := doFooBarHTTPRequest(vhostPort, "example.com")
+			framework.ExpectContainElements(results, []string{"foo", "bar"})
+
+			// close bar server, check foo is ok
+			barServer.Close()
+			time.Sleep(2 * time.Second)
+			results = doFooBarHTTPRequest(vhostPort, "example.com")
+			framework.ExpectContainElements(results, []string{"foo"})
+			framework.ExpectNotContainElements(results, []string{"bar"})
+
+			// resume bar server, check foo and bar is ok
+			f.RunServer("", barServer)
+			time.Sleep(2 * time.Second)
+			results = doFooBarHTTPRequest(vhostPort, "example.com")
+			framework.ExpectContainElements(results, []string{"foo", "bar"})
+		})
+	})
+})

test/e2e/legacy/features/heartbeat.go

@@ -0,0 +1,48 @@
+package features
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/onsi/ginkgo/v2"
+
+	"github.com/fatedier/frp/test/e2e/framework"
+)
+
+var _ = ginkgo.Describe("[Feature: Heartbeat]", func() {
+	f := framework.NewDefaultFramework()
+
+	ginkgo.It("disable application layer heartbeat", func() {
+		serverPort := f.AllocPort()
+		serverConf := fmt.Sprintf(`
+		[common]
+		bind_addr = 0.0.0.0
+		bind_port = %d
+		heartbeat_timeout = -1
+		tcp_mux_keepalive_interval = 2
+		`, serverPort)
+
+		remotePort := f.AllocPort()
+		clientConf := fmt.Sprintf(`
+		[common]
+		server_port = %d
+		log_level = trace
+		heartbeat_interval = -1
+		heartbeat_timeout = -1
+		tcp_mux_keepalive_interval = 2
+
+		[tcp]
+		type = tcp
+		local_port = %d
+		remote_port = %d
+		`, serverPort, f.PortByName(framework.TCPEchoServerPort), remotePort)
+
+		// run frps and frpc
+		f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+		framework.NewRequestExpect(f).Protocol("tcp").Port(remotePort).Ensure()
+
+		time.Sleep(5 * time.Second)
+		framework.NewRequestExpect(f).Protocol("tcp").Port(remotePort).Ensure()
+	})
+})

test/e2e/legacy/features/monitor.go

@@ -0,0 +1,54 @@
+package features
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/onsi/ginkgo/v2"
+
+	"github.com/fatedier/frp/pkg/util/log"
+	"github.com/fatedier/frp/test/e2e/framework"
+	"github.com/fatedier/frp/test/e2e/framework/consts"
+	"github.com/fatedier/frp/test/e2e/pkg/request"
+)
+
+var _ = ginkgo.Describe("[Feature: Monitor]", func() {
+	f := framework.NewDefaultFramework()
+
+	ginkgo.It("Prometheus metrics", func() {
+		dashboardPort := f.AllocPort()
+		serverConf := consts.LegacyDefaultServerConfig + fmt.Sprintf(`
+		enable_prometheus = true
+		dashboard_addr = 0.0.0.0
+		dashboard_port = %d
+		`, dashboardPort)
+
+		clientConf := consts.LegacyDefaultClientConfig
+		remotePort := f.AllocPort()
+		clientConf += fmt.Sprintf(`
+		[tcp]
+		type = tcp
+		local_port = {{ .%s }}
+		remote_port = %d
+		`, framework.TCPEchoServerPort, remotePort)
+
+		f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+		framework.NewRequestExpect(f).Port(remotePort).Ensure()
+		time.Sleep(500 * time.Millisecond)
+
+		framework.NewRequestExpect(f).RequestModify(func(r *request.Request) {
+			r.HTTP().Port(dashboardPort).HTTPPath("/metrics")
+		}).Ensure(func(resp *request.Response) bool {
+			log.Trace("prometheus metrics response: \n%s", resp.Content)
+			if resp.Code != 200 {
+				return false
+			}
+			if !strings.Contains(string(resp.Content), "traffic_in") {
+				return false
+			}
+			return true
+		})
+	})
+})

test/e2e/legacy/features/real_ip.go

@@ -0,0 +1,151 @@
+package features
+
+import (
+	"bufio"
+	"fmt"
+	"net"
+	"net/http"
+
+	"github.com/onsi/ginkgo/v2"
+	pp "github.com/pires/go-proxyproto"
+
+	"github.com/fatedier/frp/pkg/util/log"
+	"github.com/fatedier/frp/test/e2e/framework"
+	"github.com/fatedier/frp/test/e2e/framework/consts"
+	"github.com/fatedier/frp/test/e2e/mock/server/httpserver"
+	"github.com/fatedier/frp/test/e2e/mock/server/streamserver"
+	"github.com/fatedier/frp/test/e2e/pkg/request"
+	"github.com/fatedier/frp/test/e2e/pkg/rpc"
+)
+
+var _ = ginkgo.Describe("[Feature: Real IP]", func() {
+	f := framework.NewDefaultFramework()
+
+	ginkgo.It("HTTP X-Forwarded-For", func() {
+		vhostHTTPPort := f.AllocPort()
+		serverConf := consts.LegacyDefaultServerConfig + fmt.Sprintf(`
+		vhost_http_port = %d
+		`, vhostHTTPPort)
+
+		localPort := f.AllocPort()
+		localServer := httpserver.New(
+			httpserver.WithBindPort(localPort),
+			httpserver.WithHandler(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+				_, _ = w.Write([]byte(req.Header.Get("X-Forwarded-For")))
+			})),
+		)
+		f.RunServer("", localServer)
+
+		clientConf := consts.LegacyDefaultClientConfig
+		clientConf += fmt.Sprintf(`
+		[test]
+		type = http
+		local_port = %d
+		custom_domains = normal.example.com
+		`, localPort)
+
+		f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+		framework.NewRequestExpect(f).Port(vhostHTTPPort).
+			RequestModify(func(r *request.Request) {
+				r.HTTP().HTTPHost("normal.example.com")
+			}).
+			ExpectResp([]byte("127.0.0.1")).
+			Ensure()
+	})
+
+	ginkgo.Describe("Proxy Protocol", func() {
+		ginkgo.It("TCP", func() {
+			serverConf := consts.LegacyDefaultServerConfig
+			clientConf := consts.LegacyDefaultClientConfig
+
+			localPort := f.AllocPort()
+			localServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(localPort),
+				streamserver.WithCustomHandler(func(c net.Conn) {
+					defer c.Close()
+					rd := bufio.NewReader(c)
+					ppHeader, err := pp.Read(rd)
+					if err != nil {
+						log.Error("read proxy protocol error: %v", err)
+						return
+					}
+
+					for {
+						if _, err := rpc.ReadBytes(rd); err != nil {
+							return
+						}
+
+						buf := []byte(ppHeader.SourceAddr.String())
+						_, _ = rpc.WriteBytes(c, buf)
+					}
+				}))
+			f.RunServer("", localServer)
+
+			remotePort := f.AllocPort()
+			clientConf += fmt.Sprintf(`
+			[tcp]
+			type = tcp
+			local_port = %d
+			remote_port = %d
+			proxy_protocol_version = v2
+			`, localPort, remotePort)
+
+			f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+			framework.NewRequestExpect(f).Port(remotePort).Ensure(func(resp *request.Response) bool {
+				log.Trace("ProxyProtocol get SourceAddr: %s", string(resp.Content))
+				addr, err := net.ResolveTCPAddr("tcp", string(resp.Content))
+				if err != nil {
+					return false
+				}
+				if addr.IP.String() != "127.0.0.1" {
+					return false
+				}
+				return true
+			})
+		})
+
+		ginkgo.It("HTTP", func() {
+			vhostHTTPPort := f.AllocPort()
+			serverConf := consts.LegacyDefaultServerConfig + fmt.Sprintf(`
+		vhost_http_port = %d
+		`, vhostHTTPPort)
+
+			clientConf := consts.LegacyDefaultClientConfig
+
+			localPort := f.AllocPort()
+			var srcAddrRecord string
+			localServer := streamserver.New(streamserver.TCP, streamserver.WithBindPort(localPort),
+				streamserver.WithCustomHandler(func(c net.Conn) {
+					defer c.Close()
+					rd := bufio.NewReader(c)
+					ppHeader, err := pp.Read(rd)
+					if err != nil {
+						log.Error("read proxy protocol error: %v", err)
+						return
+					}
+					srcAddrRecord = ppHeader.SourceAddr.String()
+				}))
+			f.RunServer("", localServer)
+
+			clientConf += fmt.Sprintf(`
+			[test]
+			type = http
+			local_port = %d
+			custom_domains = normal.example.com
+			proxy_protocol_version = v2
+			`, localPort)
+
+			f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+			framework.NewRequestExpect(f).Port(vhostHTTPPort).RequestModify(func(r *request.Request) {
+				r.HTTP().HTTPHost("normal.example.com")
+			}).Ensure(framework.ExpectResponseCode(404))
+
+			log.Trace("ProxyProtocol get SourceAddr: %s", srcAddrRecord)
+			addr, err := net.ResolveTCPAddr("tcp", srcAddrRecord)
+			framework.ExpectNoError(err, srcAddrRecord)
+			framework.ExpectEqualValues("127.0.0.1", addr.IP.String())
+		})
+	})
+})