mosn

1
//go:build MOSNTest
2
// +build MOSNTest
3

4
package fallback
5

6
import (
7
	"fmt"
8
	"net"
9
	"net/http"
10
	"strconv"
11
	"testing"
12
	"time"
13

14
	. "mosn.io/mosn/test/framework"
15
	"mosn.io/mosn/test/lib/mosn"
16
)
17

18
var receiveHttpReq bool = false
19
var receiveTcpReq bool = true
20

21
func startTcpServer(port int) net.Listener {
22
	l, err := net.Listen("tcp", "127.0.0.1:"+strconv.Itoa(port))
23
	if err != nil || l == nil {
24
		fmt.Println("fail to start tcp server")
25
		return nil
26
	}
27

28
	go func() {
29
		for {
30
			conn, err := l.Accept()
31
			if err != nil {
32
				fmt.Println("fail to accept tcp connection")
33
				return
34
			}
35
			go func(conn net.Conn) {
36
				fmt.Println("Accepted new connection.")
37
				defer conn.Close()
38

39
				for {
40
					buf := make([]byte, 1024)
41
					size, err := conn.Read(buf)
42
					if err != nil {
43
						return
44
					}
45
					data := buf[:size]
46
					fmt.Println("Read new data from connection:", string(data))
47
					conn.Write(data)
48
					receiveTcpReq = true
49
				}
50
			}(conn)
51
		}
52
	}()
53
	return l
54
}
55

56
func startHttpServer(port int) *http.Server {
57
	server := &http.Server{Addr: "127.0.0.1:" + strconv.Itoa(port)}
58
	http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
59
		receiveHttpReq = true
60
	})
61
	go server.ListenAndServe()
62
	return server
63
}
64

65
func TestProxyFallback(t *testing.T) {
66
	Scenario(t, "proxy fallback", func() {
67
		var m *mosn.MosnOperator
68
		var tcpServer net.Listener
69
		var httpServer *http.Server
70

71
		Setup(func() {
72
			// start mosn
73
			m = mosn.StartMosn(ConfigFallback)
74
			Verify(m, NotNil)
75
			// start http server
76
			httpServer = startHttpServer(22164)
77
			// start tcp server
78
			tcpServer = startTcpServer(22165)
79
			// wait servers start
80
			time.Sleep(2 * time.Second)
81
		})
82

83
		Case("client-mosn-server", func() {
84
			// http req
85
			_, _ = http.Get("http://127.0.0.1:22163/")
86

87
			// tcp req
88
			c, err := net.Dial("tcp", "127.0.0.1:22163")
89
			Verify(err, Equal, nil)
90
			c.Write([]byte("hello world hello world\n"))
91

92
			time.Sleep(time.Second)
93

94
			// read tcp resp
95
			buf := make([]byte, 1024)
96
			size, err := c.Read(buf)
97
			Verify(err, Equal, nil)
98
			data := buf[:size]
99

100
			Verify(receiveHttpReq, Equal, true)
101
			Verify(receiveTcpReq, Equal, true)
102
			Verify(string(data), Equal, "hello world hello world\n")
103

104
			// no data, wait until time out
105
			_, err = net.Dial("tcp", "127.0.0.1:22163")
106
			Verify(err, Equal, nil)
107
			time.Sleep(18 * time.Second)
108
		})
109

110
		TearDown(func() {
111
			m.Stop()
112
			_ = tcpServer.Close()
113
			_ = httpServer.Close()
114
		})
115
	})
116
}
117

118
const ConfigFallback = `
119
{
120
  "servers": [
121
    {
122
      "default_log_path": "stdout",
123
      "routers": [
124
        {
125
          "router_config_name": "router_to_http_server",
126
          "virtual_hosts": [
127
            {
128
              "name": "server_hosts",
129
              "domains": [
130
                "*"
131
              ],
132
              "routers": [
133
                {
134
                  "match": {
135
                    "prefix": "/"
136
                  },
137
                  "route": {
138
                    "cluster_name": "server_http_cluster"
139
                  }
140
                }
141
              ]
142
            }
143
          ]
144
        }
145
      ],
146
      "listeners": [
147
        {
148
          "address": "127.0.0.1:22163",
149
          "bind_port": true,
150
          "filter_chains": [
151
            {
152
              "filters": [
153
                {
154
                  "type": "proxy",
155
                  "config": {
156
                    "fallback_for_unknown_protocol": true,
157
                    "downstream_protocol": "Auto",
158
                    "upstream_protocol": "Http1",
159
                    "router_config_name": "router_to_http_server"
160
                  }
161
                },
162
                {
163
                  "type": "tcp_proxy",
164
                  "config": {
165
                    "cluster": "server_tcp_cluster"
166
                  }
167
                }
168
              ]
169
            }
170
          ]
171
        }
172
      ]
173
    }
174
  ],
175
  "cluster_manager": {
176
    "clusters": [
177
      {
178
        "name": "server_http_cluster",
179
        "type": "SIMPLE",
180
        "lb_type": "LB_RANDOM",
181
        "hosts": [
182
          {
183
            "address": "127.0.0.1:22164"
184
          }
185
        ]
186
      },
187
      {
188
        "name": "server_tcp_cluster",
189
        "type": "SIMPLE",
190
        "lb_type": "LB_RANDOM",
191
        "hosts": [
192
          {
193
            "address": "127.0.0.1:22165"
194
          }
195
        ]
196
      }
197
    ]
198
  }
199
}
200
`
201