mosn

1
package http
2

3
import (
4
	"net"
5
	"net/http"
6
	"sync"
7

8
	"mosn.io/mosn/pkg/log"
9
	"mosn.io/mosn/test/lib"
10
	"mosn.io/mosn/test/lib/types"
11
)
12

13
func init() {
14
	lib.RegisterCreateServer("Http1", NewHTTPServer)
15
}
16

17
type MockHttpServer struct {
18
	mutex sync.Mutex
19
	addr  string
20
	mux   map[string]func(http.ResponseWriter, *http.Request)
21
	stats *types.ServerStats
22

23
	// running state
24
	server   *http.Server
25
	listener *StatsListener
26
}
27

28
func NewHTTPServer(config interface{}) types.MockServer {
29
	cfg, err := NewHttpServerConfig(config)
30
	if err != nil {
31
		log.DefaultLogger.Errorf("new http server config error: %v", err)
32
		return nil
33
	}
34
	if len(cfg.Configs) == 0 { // use default config
35
		cfg.Configs = map[string]*ResonseConfig{
36
			"/": &ResonseConfig{
37
				Condition: nil, // always matched true
38
				CommonBuilder: &ResponseBuilder{
39
					StatusCode: http.StatusOK,
40
					Header: map[string][]string{
41
						"mosn-test-default": []string{"http1"},
42
					},
43
					Body: string("default-http1"),
44
				},
45
				ErrorBuilder: &ResponseBuilder{
46
					StatusCode: http.StatusInternalServerError, // 500
47
					Body:       string("condition is not matched"),
48
				},
49
			},
50
		}
51

52
	}
53
	s := &MockHttpServer{
54
		addr:   cfg.Addr,
55
		mux:    make(map[string]func(http.ResponseWriter, *http.Request)),
56
		stats:  types.NewServerStats(),
57
		server: &http.Server{},
58
	}
59
	for pattern, c := range cfg.Configs {
60
		s.mux[pattern] = c.ServeHTTP
61
	}
62
	return s
63
}
64

65
// Wrap a http server so we can get the metrics info
66
func (s *MockHttpServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
67
	// receive a request
68
	s.stats.Records().RecordRequest()
69
	ww := &ResponseWriterWrapper{
70
		ResponseWriter: w,
71
		stats:          s.stats,
72
	}
73
	handler, ok := s.mux[r.URL.Path]
74
	if !ok {
75
		ww.WriteHeader(http.StatusNotFound)
76
		return
77
	}
78
	handler(ww, r)
79
}
80

81
func (s *MockHttpServer) Start() {
82
	s.mutex.Lock()
83
	defer s.mutex.Unlock()
84
	if s.listener != nil {
85
		return
86
	}
87
	ln, err := net.Listen("tcp", s.addr)
88
	if err != nil {
89
		log.DefaultLogger.Fatalf("listen %s failed", s.addr)
90
	}
91
	s.listener = NewStatsListener(ln, s.stats)
92

93
	// register http server
94
	mux := &http.ServeMux{}
95
	mux.HandleFunc("/", s.ServeHTTP) // use mock server http
96
	s.server.Handler = mux
97
	go s.server.Serve(s.listener)
98

99
}
100

101
func (s *MockHttpServer) Stop() {
102
	s.mutex.Lock()
103
	defer s.mutex.Unlock()
104
	s.server.Close()
105
	s.listener = nil
106
}
107

108
func (s *MockHttpServer) Stats() types.ServerStatsReadOnly {
109
	return s.stats
110
}
111