openstack
/
octavia-tempest-plugin
Code Issues Proposed changes

Fix Go lint errors 

Three Go lint errors are addressed in this patch:

- Don't use underscores in Go names
- Exported type ConnectionCount should have comment or be unexported
- Println arg list ends with redundant newline

Change-Id: I4774fd3f2837f474399d0735af0cd18322fe0eee
This commit is contained in:
Carlos Goncalves 2020-10-13 14:51:54 +02:00 committed by Michael Johnson
parent 7a47c372ca
commit eb33e69a6a
1 changed files with 69 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
octavia_tempest_plugin/contrib/test_server/test_server.go
View File

@ -16,60 +16,60 @@ import (
"time" "time"
) )
var sess_cookie http.Cookie var sessCookie http.Cookie
var resp string var resp string
type ConnectionCount struct { type connectionCount struct {
mu sync.Mutex mu sync.Mutex
cur_conn int curConn int
max_conn int maxConn int
total_conn int totalConn int
} }
var scoreboard ConnectionCount var scoreboard connectionCount
func (cc *ConnectionCount) open() { func (cc *connectionCount) open() {
cc.mu.Lock() cc.mu.Lock()
defer cc.mu.Unlock() defer cc.mu.Unlock()
cc.cur_conn++ cc.curConn++
cc.total_conn++ cc.totalConn++
} }
func (cc *ConnectionCount) close() { func (cc *connectionCount) close() {
cc.mu.Lock() cc.mu.Lock()
defer cc.mu.Unlock() defer cc.mu.Unlock()
if cc.cur_conn > cc.max_conn { if cc.curConn > cc.maxConn {
cc.max_conn = cc.cur_conn cc.maxConn = cc.curConn
} }
cc.cur_conn-- cc.curConn--
} }
func (cc *ConnectionCount) stats() (int, int) { func (cc *connectionCount) stats() (int, int) {
cc.mu.Lock() cc.mu.Lock()
defer cc.mu.Unlock() defer cc.mu.Unlock()
return cc.max_conn, cc.total_conn return cc.maxConn, cc.totalConn
} }
func (cc *ConnectionCount) reset() { func (cc *connectionCount) reset() {
cc.mu.Lock() cc.mu.Lock()
defer cc.mu.Unlock() defer cc.mu.Unlock()
cc.max_conn = 0 cc.maxConn = 0
cc.total_conn = 0 cc.totalConn = 0
} }
func root_handler(w http.ResponseWriter, r *http.Request) { func rootHandler(w http.ResponseWriter, r *http.Request) {
scoreboard.open() scoreboard.open()
defer scoreboard.close() defer scoreboard.close()
http.SetCookie(w, &sess_cookie) http.SetCookie(w, &sessCookie)
io.WriteString(w, resp) io.WriteString(w, resp)
} }
func slow_handler(w http.ResponseWriter, r *http.Request) { func slowHandler(w http.ResponseWriter, r *http.Request) {
scoreboard.open() scoreboard.open()
defer scoreboard.close() defer scoreboard.close()
@ -79,59 +79,59 @@ func slow_handler(w http.ResponseWriter, r *http.Request) {
} }
time.Sleep(delay) time.Sleep(delay)
http.SetCookie(w, &sess_cookie) http.SetCookie(w, &sessCookie)
io.WriteString(w, resp) io.WriteString(w, resp)
} }
func stats_handler(w http.ResponseWriter, r *http.Request) { func statsHandler(w http.ResponseWriter, r *http.Request) {
http.SetCookie(w, &sess_cookie) http.SetCookie(w, &sessCookie)
max_conn, total_conn := scoreboard.stats() maxConn, totalConn := scoreboard.stats()
fmt.Fprintf(w, "max_conn=%d\ntotal_conn=%d\n", max_conn, total_conn) fmt.Fprintf(w, "maxConn=%d\ntotalConn=%d\n", maxConn, totalConn)
} }
func https_wrapper(base_handler func(http.ResponseWriter, func httpsWrapper(baseHandler func(http.ResponseWriter,
*http.Request)) http.Handler { *http.Request)) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Strict-Transport-Security", w.Header().Add("Strict-Transport-Security",
"max-age=66012000; includeSubDomains") "max-age=66012000; includeSubDomains")
base_handler(w, r) baseHandler(w, r)
}) })
} }
func reset_handler(w http.ResponseWriter, r *http.Request) { func resetHandler(w http.ResponseWriter, r *http.Request) {
http.SetCookie(w, &sess_cookie) http.SetCookie(w, &sessCookie)
scoreboard.reset() scoreboard.reset()
fmt.Fprintf(w, "reset\n") fmt.Fprintf(w, "reset\n")
} }
func http_setup(id string) { func httpSetup(id string) {
sess_cookie.Name = "JSESSIONID" sessCookie.Name = "JSESSIONID"
sess_cookie.Value = id sessCookie.Value = id
http.HandleFunc("/", root_handler) http.HandleFunc("/", rootHandler)
http.HandleFunc("/slow", slow_handler) http.HandleFunc("/slow", slowHandler)
http.HandleFunc("/stats", stats_handler) http.HandleFunc("/stats", statsHandler)
http.HandleFunc("/reset", reset_handler) http.HandleFunc("/reset", resetHandler)
} }
func http_serve(port int, id string) { func httpServe(port int, id string) {
portStr := fmt.Sprintf(":%d", port) portStr := fmt.Sprintf(":%d", port)
log.Fatal(http.ListenAndServe(portStr, nil)) log.Fatal(http.ListenAndServe(portStr, nil))
} }
func https_serve(port int, id string, cert tls.Certificate, func httpsServe(port int, id string, cert tls.Certificate,
certpool *x509.CertPool, server_cert_pem string, certpool *x509.CertPool, serverCertPem string,
server_key_pem string) { serverKeyPem string) {
mux := http.NewServeMux() mux := http.NewServeMux()
mux.Handle("/", https_wrapper(root_handler)) mux.Handle("/", httpsWrapper(rootHandler))
mux.Handle("/slow", https_wrapper(slow_handler)) mux.Handle("/slow", httpsWrapper(slowHandler))
mux.Handle("/stats", https_wrapper(stats_handler)) mux.Handle("/stats", httpsWrapper(statsHandler))
mux.Handle("/reset", https_wrapper(reset_handler)) mux.Handle("/reset", httpsWrapper(resetHandler))
var tls_config *tls.Config var tlsConfig *tls.Config
if certpool != nil { if certpool != nil {
tls_config = &tls.Config{ tlsConfig = &tls.Config{
Certificates: []tls.Certificate{cert}, Certificates: []tls.Certificate{cert},
ClientAuth: tls.RequireAndVerifyClientCert, ClientAuth: tls.RequireAndVerifyClientCert,
ClientCAs: certpool, ClientCAs: certpool,
@ -147,7 +147,7 @@ func https_serve(port int, id string, cert tls.Certificate,
}, },
} }
} else { } else {
tls_config = &tls.Config{ tlsConfig = &tls.Config{
Certificates: []tls.Certificate{cert}, Certificates: []tls.Certificate{cert},
ClientAuth: tls.NoClientCert, ClientAuth: tls.NoClientCert,
MinVersion: tls.VersionTLS12, MinVersion: tls.VersionTLS12,
@ -163,19 +163,19 @@ func https_serve(port int, id string, cert tls.Certificate,
NextProtos: []string{"h2", "http/1.1", "http/1.0"}, NextProtos: []string{"h2", "http/1.1", "http/1.0"},
} }
} }
tls_config.Rand = rand.Reader tlsConfig.Rand = rand.Reader
portStr := fmt.Sprintf(":%d", port) portStr := fmt.Sprintf(":%d", port)
srv := &http.Server{ srv := &http.Server{
Addr: portStr, Addr: portStr,
Handler: mux, Handler: mux,
TLSConfig: tls_config, TLSConfig: tlsConfig,
TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, TLSNextProto: make(map[string]func(*http.Server, *tls.Conn,
http.Handler), 0), http.Handler), 0),
} }
log.Fatal(srv.ListenAndServeTLS(server_cert_pem, server_key_pem)) log.Fatal(srv.ListenAndServeTLS(serverCertPem, serverKeyPem))
} }
func udp_serve(port int, id string) { func udpServe(port int, id string) {
portStr := fmt.Sprintf("0.0.0.0:%d", port) portStr := fmt.Sprintf("0.0.0.0:%d", port)
pc, err := net.ListenPacket("udp", portStr) pc, err := net.ListenPacket("udp", portStr)
@ -203,44 +203,44 @@ func udp_serve(port int, id string) {
func main() { func main() {
portPtr := flag.Int("port", 8080, "Port to listen on") portPtr := flag.Int("port", 8080, "Port to listen on")
idPtr := flag.String("id", "1", "Server ID") idPtr := flag.String("id", "1", "Server ID")
https_portPtr := flag.Int("https_port", -1, httpsPortPtr := flag.Int("https_port", -1,
"HTTPS port to listen on, -1 is disabled.") "HTTPS port to listen on, -1 is disabled.")
server_cert_pem := flag.String("cert", "", serverCertPem := flag.String("cert", "",
"Server side PEM format certificate.") "Server side PEM format certificate.")
server_key := flag.String("key", "", "Server side PEM format key.") serverKey := flag.String("key", "", "Server side PEM format key.")
client_ca_cert_pem := flag.String("client_ca", "", clientCaCertPem := flag.String("client_ca", "",
"Client side PEM format CA certificate.") "Client side PEM format CA certificate.")
flag.Parse() flag.Parse()
resp = fmt.Sprintf("%s", *idPtr) resp = fmt.Sprintf("%s", *idPtr)
http_setup(*idPtr) httpSetup(*idPtr)
if *https_portPtr > -1 { if *httpsPortPtr > -1 {
cert, err := tls.LoadX509KeyPair(*server_cert_pem, *server_key) cert, err := tls.LoadX509KeyPair(*serverCertPem, *serverKey)
if err != nil { if err != nil {
fmt.Println("Error load server certificate and key.\n") fmt.Println("Error load server certificate and key.")
os.Exit(1) os.Exit(1)
} }
certpool := x509.NewCertPool() certpool := x509.NewCertPool()
if *client_ca_cert_pem != "" { if *clientCaCertPem != "" {
ca_pem, err := ioutil.ReadFile(*client_ca_cert_pem) caPem, err := ioutil.ReadFile(*clientCaCertPem)
if err != nil { if err != nil {
fmt.Println("Error load client side CA cert.\n") fmt.Println("Error load client side CA cert.")
os.Exit(1) os.Exit(1)
} }
if !certpool.AppendCertsFromPEM(ca_pem) { if !certpool.AppendCertsFromPEM(caPem) {
fmt.Println("Can't parse client side certificate authority") fmt.Println("Can't parse client side certificate authority")
os.Exit(1) os.Exit(1)
} }
} else { } else {
certpool = nil certpool = nil
} }
go https_serve(*https_portPtr, *idPtr, cert, certpool, go httpsServe(*httpsPortPtr, *idPtr, cert, certpool,
*server_cert_pem, *server_key) *serverCertPem, *serverKey)
} }
go http_serve(*portPtr, *idPtr) go httpServe(*portPtr, *idPtr)
udp_serve(*portPtr, *idPtr) udpServe(*portPtr, *idPtr)
} }