fix: resolve path parameter when route has trailing slash

fix: trigger listeners when reading file from reference before main file
fix: deadlock race condition in ConfigWatcher
improve: log messages for HTTP/HTTPS server
fix: logs/dashboard when HTTP request does not match any API

Author: marle3003

config/dynamic/config.go

@@ -2,11 +2,12 @@ package dynamic
 
 import (
 	"bytes"
-	"github.com/Masterminds/sprig"
 	"mokapi/sortedmap"
 	"strings"
 	"sync"
 	"text/template"
+
+	"github.com/Masterminds/sprig"
 )
 
 type Event int
@@ -31,13 +32,21 @@ type Validator interface {
 	Validate() error
 }
 
+type SourceType int
+
+const (
+	SourceMain SourceType = iota
+	SourceReference
+)
+
 type Config struct {
-	Info      ConfigInfo
-	Raw       []byte
-	Data      interface{}
-	Refs      Refs
-	Listeners Listeners
-	Scope     Scope
+	Info       ConfigInfo
+	Raw        []byte
+	Data       interface{}
+	Refs       Refs
+	Listeners  Listeners
+	Scope      Scope
+	SourceType SourceType
 }
 
 type Refs struct {

config/dynamic/provider/file/file.go

@@ -5,8 +5,6 @@ import (
 	"context"
 	"crypto/sha256"
 	"fmt"
-	"github.com/fsnotify/fsnotify"
-	log "github.com/sirupsen/logrus"
 	"io"
 	"io/fs"
 	"math"
@@ -20,6 +18,9 @@ import (
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/fsnotify/fsnotify"
+	log "github.com/sirupsen/logrus"
 )
 
 const mokapiIgnoreFile = ".mokapiignore"
@@ -82,6 +83,7 @@ func (p *Provider) Read(u *url.URL) (*dynamic.Config, error) {
 	if err != nil {
 		return nil, err
 	}
+	config.SourceType = dynamic.SourceReference
 
 	p.watchPath(file)
 	return config, nil

config/dynamic/provider/http/http.go

@@ -5,7 +5,6 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"fmt"
-	log "github.com/sirupsen/logrus"
 	"hash/fnv"
 	"io"
 	"mokapi/config/dynamic"
@@ -16,6 +15,8 @@ import (
 	"os"
 	"sync"
 	"time"
+
+	log "github.com/sirupsen/logrus"
 )
 
 type Provider struct {
@@ -81,6 +82,9 @@ func New(config static.HttpProvider) *Provider {
 
 func (p *Provider) Read(u *url.URL) (*dynamic.Config, error) {
 	c, _, err := p.readUrl(u)
+	if c != nil {
+		c.SourceType = dynamic.SourceReference
+	}
 	return c, err
 }
 

config/dynamic/provider/npm/npm.go

@@ -3,14 +3,15 @@ package npm
 import (
 	"context"
 	"fmt"
-	log "github.com/sirupsen/logrus"
 	"mokapi/config/dynamic"
 	"mokapi/config/dynamic/provider/file"
 	"mokapi/config/static"
 	"mokapi/safe"
 	"net/url"
 	"path/filepath"
 	"strings"
+
+	log "github.com/sirupsen/logrus"
 )
 
 type Provider struct {

lib/http.go

@@ -10,7 +10,7 @@ func GetUrl(r *http.Request) string {
 		return r.URL.String()
 	}
 	var sb strings.Builder
-	if strings.HasPrefix(r.Proto, "HTTPS") {
+	if r.TLS != nil {
 		sb.WriteString("https://")
 	} else {
 		sb.WriteString("http://")

providers/openapi/handler.go

@@ -249,8 +249,14 @@ func (h *operationHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request) *H
 	op, errOpResolve := findOperation(r.Method, requestPath, h.config.Paths)
 	if op != nil {
 		params := append(op.Path.Parameters, op.Parameters...)
+		route := op.Path.Path
+		if len(route) > 1 {
+			// there is no official specification for trailing slash. For ease of use, mokapi considers it equivalent
+			route = strings.TrimRight(route, "/")
+		}
+
 		var rp parameter.RequestParameters
-		rp, errOpResolve = parameter.FromRequest(params, op.Path.Path, r)
+		rp, errOpResolve = parameter.FromRequest(params, route, r)
 
 		if errOpResolve == nil {
 			r = r.WithContext(parameter.NewContext(r.Context(), rp))
@@ -280,7 +286,7 @@ func (h *operationHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request) *H
 		}
 	}
 
-	if ctx, err := NewLogEventContext(
+	/*if ctx, err := NewLogEventContext(
 		r,
 		false,
 		h.eh,
@@ -289,12 +295,12 @@ func (h *operationHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request) *H
 		log.Errorf("unable to log http event: %v", err)
 	} else {
 		r = r.WithContext(ctx)
-	}
+	}*/
 
 	// Not reading the request body can cause a couple of problems.
 	// Go’s HTTP server uses connection pooling by default.
 	// If you don’t read and fully consume (or close) the request body, the remaining unread bytes will stay in the TCP buffer.
-	_, _ = io.Copy(io.Discard, r.Body)
+	//_, _ = io.Copy(io.Discard, r.Body)
 
 	if errOpResolve == nil {
 		return newHttpErrorf(http.StatusNotFound, "no matching endpoint found: %v %v", strings.ToUpper(r.Method), lib.GetUrl(r))

providers/openapi/handler_requestbody_test.go

@@ -198,29 +198,6 @@ func TestResponseHandler_ServeHTTP_ResponseBody(t *testing.T) {
 			check: func(t *testing.T, r *engine2.EventRequest) {
 			},
 		},
-		{
-			name: "send request body to undefined endpoint",
-			config: openapitest.NewConfig("3.0.0",
-				openapitest.WithServer("http://localhost", ""),
-			),
-			fn: func(t *testing.T, handler openapi.Handler) {
-				spy := &spyBody{Reader: bytes.NewBufferString(`{"foo": "abc","bar": 12}`)}
-
-				r := httptest.NewRequest("post", "http://localhost/foo", spy)
-				r.Header.Set("Content-Type", "application/json")
-				rr := httptest.NewRecorder()
-
-				err := handler.ServeHTTP(rr, r)
-				require.Equal(t, &openapi.HttpError{
-					StatusCode: http.StatusNotFound,
-					Message:    "no matching endpoint found: POST http://localhost/foo",
-				}, err)
-
-				require.True(t, spy.readCalled, "server needs to read body")
-			},
-			check: func(t *testing.T, r *engine2.EventRequest) {
-			},
-		},
 	}
 
 	for _, tc := range testcases {

providers/openapi/handler_test.go

@@ -860,6 +860,31 @@ func TestHandler_Event(t *testing.T) {
 				return nil
 			},
 		},
+		{
+			name: "path parameter with trailing slash in route",
+			test: func(t *testing.T, h http.HandlerFunc, c *openapi.Config) {
+				op := openapitest.NewOperation(
+					openapitest.WithResponse(http.StatusOK,
+						openapitest.WithContent("application/json", openapitest.NewContent()),
+					))
+				openapitest.AppendPath("/foo/{id}/", c,
+					openapitest.WithOperation(http.MethodPost, op),
+					openapitest.WithPathParam("id", openapitest.WithParamSchema(schematest.New("string"))),
+				)
+				r := httptest.NewRequest("post", "http://localhost/foo/123", strings.NewReader(`{ "foo": "bar" }`))
+				r.Header.Set("Content-Type", "application/json")
+				rr := httptest.NewRecorder()
+				h(rr, r)
+				require.Equal(t, http.StatusOK, rr.Code)
+				require.Equal(t, `"123"`, rr.Body.String())
+			},
+			event: func(event string, args ...interface{}) []*common.Action {
+				req := args[0].(*common.EventRequest)
+				res := args[1].(*common.EventResponse)
+				res.Data = req.Path["id"]
+				return nil
+			},
+		},
 	}
 
 	t.Parallel()

providers/openapi/log.go

@@ -51,7 +51,7 @@ func NewLogEventContext(r *http.Request, deprecated bool, eh events.Handler, tra
 		Request: &HttpRequestLog{
 			Method:      r.Method,
 			Url:         lib.GetUrl(r),
-			ContentType: r.Header.Get("content-type"),
+			ContentType: r.Header.Get("Content-Type"),
 		},
 		Response:   &HttpResponseLog{Headers: make(map[string]string)},
 		Deprecated: deprecated,

providers/openapi/parameter/path_test.go

@@ -1,6 +1,7 @@
 package parameter_test
 
 import (
+	"context"
 	"mokapi/providers/openapi/parameter"
 	"mokapi/providers/openapi/schema/schematest"
 	"net/http"
@@ -268,6 +269,43 @@ func TestParsePath(t *testing.T) {
 				require.Equal(t, map[string]interface{}{"role": "admin", "firstName": "Alex"}, result[parameter.Path]["foo"].Value)
 			},
 		},
+		{
+			name: "path parameter and base path",
+			param: &parameter.Parameter{
+				Name:    "foo",
+				Type:    parameter.Path,
+				Schema:  schematest.New("string"),
+				Style:   "",
+				Explode: explode(false),
+			},
+			route: "/{foo}",
+			request: func() *http.Request {
+				r := httptest.NewRequest(http.MethodGet, "https://foo.bar/mokapi/foo/bar", nil)
+				return r.WithContext(context.WithValue(r.Context(), "servicePath", "/mokapi/foo"))
+			},
+			test: func(t *testing.T, result parameter.RequestParameters, err error) {
+				require.NoError(t, err)
+				require.Equal(t, "bar", result[parameter.Path]["foo"].Value)
+			},
+		},
+		{
+			name: "path parameter and trailing slash in request",
+			param: &parameter.Parameter{
+				Name:    "foo",
+				Type:    parameter.Path,
+				Schema:  schematest.New("string"),
+				Style:   "",
+				Explode: explode(false),
+			},
+			route: "/{foo}",
+			request: func() *http.Request {
+				return httptest.NewRequest(http.MethodGet, "https://foo.bar/bar/", nil)
+			},
+			test: func(t *testing.T, result parameter.RequestParameters, err error) {
+				require.NoError(t, err)
+				require.Equal(t, "bar", result[parameter.Path]["foo"].Value)
+			},
+		},
 	}
 
 	for _, tc := range testcases {