chore: modernization

acme/acme.go

@@ -71,8 +71,8 @@ func IssueCertificates(cacheDir, email, challengeType string, domains []string,
 
 	cfg.Issuers = append(cfg.Issuers, myAcme)
 
-	for i := range domains {
-		err := cfg.ObtainCertAsync(context.Background(), domains[i])
+	for _, domain := range domains {
+		err := cfg.ObtainCertAsync(context.Background(), domain)
 		if err != nil {
 			return nil, err
 		}

config/uploads.go

@@ -30,12 +30,12 @@ func (cfg *Uploads) InitDefaults() error {
 	cfg.Forbidden = make(map[string]struct{})
 	cfg.Allowed = make(map[string]struct{})
 
-	for i := range cfg.Forbid {
-		cfg.Forbidden[cfg.Forbid[i]] = struct{}{}
+	for _, ext := range cfg.Forbid {
+		cfg.Forbidden[ext] = struct{}{}
 	}
 
-	for i := range cfg.Allow {
-		cfg.Allowed[cfg.Allow[i]] = struct{}{}
+	for _, ext := range cfg.Allow {
+		cfg.Allowed[ext] = struct{}{}
 	}
 
 	for k := range cfg.Forbidden {

handler/response.go

@@ -53,8 +53,8 @@ func (h *Handler) handlePROTOresponse(pld *payload.Payload, w http.ResponseWrite
 			push := rsp.GetHeaders()[HTTP2Push].GetValues()
 
 			if pusher, ok := w.(http.Pusher); ok {
-				for i := range push {
-					err = pusher.Push(string(rsp.GetHeaders()[HTTP2Push].GetValues()[i]), nil)
+				for _, pushVal := range push {
+					err = pusher.Push(string(pushVal), nil)
 					if err != nil {
 						return err
 					}

init.go

@@ -57,16 +57,16 @@ func nilOr(cfg *config.Config) *acme.Config {
 
 func (p *Plugin) applyBundledMiddleware() {
 	// apply max_req_size and logger middleware
-	for i := range p.servers {
-		switch srv := p.servers[i].Server().(type) {
+	for _, s := range p.servers {
+		switch srv := s.Server().(type) {
 		case *http.Server:
 			srv.Handler = bundledMw.MaxRequestSize(srv.Handler, p.cfg.MaxRequestSize*MB)
 			srv.Handler = bundledMw.NewLogMiddleware(srv.Handler, p.cfg.AccessLogs, p.log)
 		case *http3.Server:
 			srv.Handler = bundledMw.MaxRequestSize(srv.Handler, p.cfg.MaxRequestSize*MB)
 			srv.Handler = bundledMw.NewLogMiddleware(srv.Handler, p.cfg.AccessLogs, p.log)
 		default:
-			p.log.DPanic("unknown server type", zap.Any("server", p.servers[i].Server()))
+			p.log.DPanic("unknown server type", zap.Any("server", s.Server()))
 		}
 	}
 }

metrics.go

@@ -68,14 +68,14 @@ func (s *StatsExporter) Collect(ch chan<- prometheus.Metric) {
 	var invalid float64
 
 	// collect the memory
-	for i := range workerStates {
-		cum += float64(workerStates[i].MemoryUsage)
+	for _, ws := range workerStates {
+		cum += float64(ws.MemoryUsage)
 
-		ch <- prometheus.MustNewConstMetric(s.StateDesc, prometheus.GaugeValue, 0, workerStates[i].StatusStr, strconv.Itoa(int(workerStates[i].Pid)))
-		ch <- prometheus.MustNewConstMetric(s.WorkerMemoryDesc, prometheus.GaugeValue, float64(workerStates[i].MemoryUsage), strconv.Itoa(int(workerStates[i].Pid)))
+		ch <- prometheus.MustNewConstMetric(s.StateDesc, prometheus.GaugeValue, 0, ws.StatusStr, strconv.Itoa(int(ws.Pid)))
+		ch <- prometheus.MustNewConstMetric(s.WorkerMemoryDesc, prometheus.GaugeValue, float64(ws.MemoryUsage), strconv.Itoa(int(ws.Pid)))
 
 		// sync with sdk/worker/state.go
-		switch workerStates[i].Status {
+		switch ws.Status {
 		case fsm.StateReady:
 			ready++
 		case fsm.StateWorking:

middleware/redirect.go

@@ -27,7 +27,7 @@ func Redirect(_ http.Handler, port int) http.Handler {
 // TLSAddr replaces listen or host port with port configured by SSLConfig config.
 func TLSAddr(host string, forcePort bool, sslPort int) string {
 	// remove current forcePort first
-	host = strings.Split(host, ":")[0]
+	host, _, _ = strings.Cut(host, ":")
 
 	if forcePort || sslPort != 443 {
 		host = fmt.Sprintf("%s:%v", host, sslPort)

plugin.go

@@ -171,9 +171,9 @@ func (p *Plugin) Stop(ctx context.Context) error {
 	doneCh := make(chan struct{}, 1)
 
 	go func() {
-		for i := range p.servers {
-			if p.servers[i] != nil {
-				p.servers[i].Stop()
+		for _, srv := range p.servers {
+			if srv != nil {
+				srv.Stop()
 			}
 		}
 

servers/fcgi/fcgi.go

@@ -65,11 +65,11 @@ func (s *Server) Stop() {
 }
 
 func applyMiddleware(server *http.Server, middleware map[string]api.Middleware, order []string, log *zap.Logger) {
-	for i := range order {
-		if mdwr, ok := middleware[order[i]]; ok {
+	for _, name := range order {
+		if mdwr, ok := middleware[name]; ok {
 			server.Handler = mdwr.Middleware(server.Handler)
 		} else {
-			log.Warn("requested middleware does not exist", zap.String("requested", order[i]))
+			log.Warn("requested middleware does not exist", zap.String("requested", name))
 		}
 	}
 }

servers/http11/http.go

@@ -110,11 +110,11 @@ func (s *Server) Stop() {
 }
 
 func applyMiddleware(server *http.Server, middleware map[string]api.Middleware, order []string, log *zap.Logger) {
-	for i := range order {
-		if mdwr, ok := middleware[order[i]]; ok {
+	for _, name := range order {
+		if mdwr, ok := middleware[name]; ok {
 			server.Handler = mdwr.Middleware(server.Handler)
 		} else {
-			log.Warn("requested middleware does not exist", zap.String("requested", order[i]))
+			log.Warn("requested middleware does not exist", zap.String("requested", name))
 		}
 	}
 }

servers/http3/http3.go

@@ -85,11 +85,11 @@ func (s *Server) Stop() {
 }
 
 func applyMiddleware(server *http3.Server, middleware map[string]api.Middleware, order []string, log *zap.Logger) {
-	for i := range order {
-		if mdwr, ok := middleware[order[i]]; ok {
+	for _, name := range order {
+		if mdwr, ok := middleware[name]; ok {
 			server.Handler = mdwr.Middleware(server.Handler)
 		} else {
-			log.Warn("requested middleware does not exist", zap.String("requested", order[i]))
+			log.Warn("requested middleware does not exist", zap.String("requested", name))
 		}
 	}
 }

servers/https/config.go

@@ -97,26 +97,20 @@ func (s *SSL) EnableACME() bool {
 func (s *SSL) Valid() error {
 	const op = errors.Op("ssl_valid")
 
-	parts := strings.Split(s.Address, ":")
-	switch len(parts) {
-	// :443 form
-	// 127.0.0.1:443 form
-	// use 0.0.0.0 as host and 443 as port
-	case 2:
-		if parts[0] == "" {
-			s.host = "127.0.0.1"
-		} else {
-			s.host = parts[0]
-		}
-
-		port, err := strconv.Atoi(parts[1])
-		if err != nil {
-			return errors.E(op, err)
-		}
-		s.Port = port
-	default:
+	host, portStr, ok := strings.Cut(s.Address, ":")
+	if !ok {
 		return errors.E(op, errors.Errorf("unknown format, accepted format is [:<port> or <host>:<port>], provided: %s", s.Address))
 	}
+	if host == "" {
+		s.host = "127.0.0.1"
+	} else {
+		s.host = host
+	}
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		return errors.E(op, err)
+	}
+	s.Port = port
 
 	// the user use they own certificates
 	if s.Acme == nil {

servers/https/https.go

@@ -186,7 +186,7 @@ func initTLS(handler http.Handler, errLog *log.Logger, addr string, port int) *h
 // tlsAddr replaces listen or host port with port configured by SSLConfig config.
 func tlsAddr(host string, forcePort bool, sslPort int) string {
 	// remove current forcePort first
-	host = strings.Split(host, ":")[0]
+	host, _, _ = strings.Cut(host, ":")
 
 	if forcePort || sslPort != 443 {
 		host = fmt.Sprintf("%s:%v", host, sslPort)
@@ -196,11 +196,11 @@ func tlsAddr(host string, forcePort bool, sslPort int) string {
 }
 
 func applyMiddleware(server *http.Server, middleware map[string]api.Middleware, order []string, log *zap.Logger) {
-	for i := range order {
-		if mdwr, ok := middleware[order[i]]; ok {
+	for _, name := range order {
+		if mdwr, ok := middleware[name]; ok {
 			server.Handler = mdwr.Middleware(server.Handler)
 		} else {
-			log.Warn("requested middleware does not exist", zap.String("requested", order[i]))
+			log.Warn("requested middleware does not exist", zap.String("requested", name))
 		}
 	}
 }

status.go

@@ -14,8 +14,8 @@ func (p *Plugin) Status() (*status.Status, error) {
 
 	workers := p.pool.Workers()
 
-	for i := range workers {
-		if workers[i].State().IsActive() {
+	for _, w := range workers {
+		if w.State().IsActive() {
 			return &status.Status{
 				Code: http.StatusOK,
 			}, nil
@@ -34,10 +34,10 @@ func (p *Plugin) Ready() (*status.Status, error) {
 
 	workers := p.pool.Workers()
 
-	for i := range workers {
+	for _, w := range workers {
 		// If state of the worker is ready (at least 1)
 		// we assume, that plugin's worker pool is ready
-		if workers[i].State().Compare(fsm.StateReady) {
+		if w.State().Compare(fsm.StateReady) {
 			return &status.Status{
 				Code: http.StatusOK,
 			}, nil