Bring over changes from master (latest commit f36d566)

Author: aldas

.github/workflows/checks.yml

@@ -0,0 +1,47 @@
+name: Run checks
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+  workflow_dispatch:
+
+permissions:
+  contents: read #  to fetch code (actions/checkout)
+
+env:
+  # run static analysis only with the latest Go version
+  LATEST_GO_VERSION: 1.19
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+
+      - name: Set up Go ${{ matrix.go }}
+        uses: actions/setup-go@v3
+        with:
+          go-version: ${{ env.LATEST_GO_VERSION }}
+          check-latest: true
+
+      - name: Run golint
+        run: |
+          go install golang.org/x/lint/golint@latest
+          golint -set_exit_status ./...
+
+      - name: Run staticcheck
+        run: |
+          go install honnef.co/go/tools/cmd/staticcheck@latest
+          staticcheck ./...
+
+      - name: Run govulncheck
+        run: |
+          go version
+          go install golang.org/x/vuln/cmd/govulncheck@latest
+          govulncheck ./...
+

.github/workflows/echo.yml

@@ -4,23 +4,18 @@ on:
   push:
     branches:
       - master
-    paths:
-      - '**.go'
-      - 'go.*'
-      - '_fixture/**'
-      - '.github/**'
-      - 'codecov.yml'
   pull_request:
     branches:
       - master
-    paths:
-      - '**.go'
-      - 'go.*'
-      - '_fixture/**'
-      - '.github/**'
-      - 'codecov.yml'
   workflow_dispatch:
 
+permissions:
+  contents: read #  to fetch code (actions/checkout)
+
+env:
+  # run coverage and benchmarks only with the latest Go version
+  LATEST_GO_VERSION: 1.19
+
 jobs:
   test:
     strategy:
@@ -30,14 +25,12 @@ jobs:
         # Echo tests with last four major releases (unless there are pressing vulnerabilities)
         # As we depend on `golang.org/x/` libraries which only support last 2 Go releases we could have situations when
         # we derive from last four major releases promise.
-        go: [1.17, 1.18, 1.19]
+        go: [1.18, 1.19]
     name: ${{ matrix.os }} @ Go ${{ matrix.go }}
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout Code
         uses: actions/checkout@v3
-        with:
-          ref: ${{ github.ref }}
 
       - name: Set up Go ${{ matrix.go }}
         uses: actions/setup-go@v3
@@ -47,31 +40,17 @@ jobs:
       - name: Run Tests
         run: go test -race --coverprofile=coverage.coverprofile --covermode=atomic ./...
 
-      - name: Install dependencies for checks
-        run: |
-          go install golang.org/x/lint/golint@latest
-          go install honnef.co/go/tools/cmd/staticcheck@latest
-
-      - name: Run golint
-        run: golint -set_exit_status ./...
-
-      - name: Run staticcheck
-        run: staticcheck ./...
-
       - name: Upload coverage to Codecov
-        if: success() && matrix.go == 1.19 && matrix.os == 'ubuntu-latest'
+        if: success() && matrix.go == env.LATEST_GO_VERSION && matrix.os == 'ubuntu-latest'
         uses: codecov/codecov-action@v3
         with:
           token:
           fail_ci_if_error: false
+
   benchmark:
     needs: test
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        go: [1.19]
-    name: Benchmark comparison ${{ matrix.os }} @ Go ${{ matrix.go }}
-    runs-on: ${{ matrix.os }}
+    name: Benchmark comparison
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout Code (Previous)
         uses: actions/checkout@v3
@@ -87,7 +66,7 @@ jobs:
       - name: Set up Go ${{ matrix.go }}
         uses: actions/setup-go@v3
         with:
-          go-version: ${{ matrix.go }}
+          go-version: ${{ env.LATEST_GO_VERSION }}
 
       - name: Install Dependencies
         run: go install golang.org/x/perf/cmd/benchstat@latest

echo.go

@@ -55,8 +55,9 @@ import (
 
 // Echo is the top-level framework instance.
 //
-// Note: replacing/nilling public fields is not coroutine/thread-safe and can cause data-races/panics. This is very likely
-// to happen when you access Echo instances through Context.Echo() method.
+// Goroutine safety: Do not mutate Echo instance fields after server has started. Accessing these
+// fields from handlers/middlewares and changing field values at the same time leads to data-races.
+// Same rule applies to adding new routes after server has been started - Adding a route is not Goroutine safe action.
 type Echo struct {
 	// premiddleware are middlewares that are run for every request before routing is done
 	premiddleware []MiddlewareFunc
@@ -90,6 +91,10 @@ type Echo struct {
 	// prefix for directory path. This is necessary as `//go:embed assets/images` embeds files with paths
 	// including `assets/images` as their prefix.
 	Filesystem fs.FS
+
+	// OnAddRoute is called when Echo adds new route to specific host router. Handler is called for every router
+	// and before route is added to the host router.
+	OnAddRoute func(host string, route Routable) error
 }
 
 // JSONSerializer is the interface that encodes and decodes JSON to and from interfaces.
@@ -278,14 +283,22 @@ func (e *Echo) Router() Router {
 	return e.router
 }
 
-// Routers returns the map of host => router.
+// Routers returns the new map of host => router.
 func (e *Echo) Routers() map[string]Router {
-	return e.routers
+	result := make(map[string]Router)
+	for host, r := range e.routers {
+		result[host] = r
+	}
+	return result
 }
 
-// RouterFor returns Router for given host.
-func (e *Echo) RouterFor(host string) Router {
-	return e.routers[host]
+// RouterFor returns Router for given host. When host is left empty the default router is returned.
+func (e *Echo) RouterFor(host string) (Router, bool) {
+	if host == "" {
+		return e.router, true
+	}
+	router, ok := e.routers[host]
+	return router, ok
 }
 
 // ResetRouterCreator resets callback for creating new router instances.
@@ -549,6 +562,12 @@ func (e *Echo) AddRoute(route Routable) (RouteInfo, error) {
 }
 
 func (e *Echo) add(host string, route Routable) (RouteInfo, error) {
+	if e.OnAddRoute != nil {
+		if err := e.OnAddRoute(host, route); err != nil {
+			return nil, err
+		}
+	}
+
 	router := e.findRouter(host)
 	ri, err := router.Add(route)
 	if err != nil {

echo_test.go

@@ -1013,6 +1013,150 @@ func TestEchoMethodNotAllowed(t *testing.T) {
 	assert.Equal(t, "OPTIONS, GET", rec.Header().Get(HeaderAllow))
 }
 
+func TestEcho_OnAddRoute(t *testing.T) {
+	type rr struct {
+		host string
+		path string
+	}
+	exampleRoute := Route{
+		Method:      http.MethodGet,
+		Path:        "/api/files/:id",
+		Handler:     notFoundHandler,
+		Middlewares: nil,
+		Name:        "x",
+	}
+
+	var testCases = []struct {
+		name        string
+		whenHost    string
+		whenRoute   Routable
+		whenError   error
+		expectLen   int
+		expectAdded []rr
+		expectError string
+	}{
+		{
+			name:      "ok, for default host",
+			whenHost:  "",
+			whenRoute: exampleRoute,
+			whenError: nil,
+			expectAdded: []rr{
+				{host: "", path: "/static"},
+				{host: "", path: "/api/files/:id"},
+			},
+			expectError: "",
+			expectLen:   2,
+		},
+		{
+			name:      "ok, for specific host",
+			whenHost:  "test.com",
+			whenRoute: exampleRoute,
+			whenError: nil,
+			expectAdded: []rr{
+				{host: "", path: "/static"},
+				{host: "test.com", path: "/api/files/:id"},
+			},
+			expectError: "",
+			expectLen:   1,
+		},
+		{
+			name:      "nok, error is returned",
+			whenHost:  "test.com",
+			whenRoute: exampleRoute,
+			whenError: errors.New("nope"),
+			expectAdded: []rr{
+				{host: "", path: "/static"},
+			},
+			expectError: "nope",
+			expectLen:   0,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+
+			e := New()
+
+			added := make([]rr, 0)
+			cnt := 0
+			e.OnAddRoute = func(host string, route Routable) error {
+				if cnt > 0 && tc.whenError != nil { // we want to GET /static to succeed for nok tests
+					return tc.whenError
+				}
+				cnt++
+				added = append(added, rr{
+					host: host,
+					path: route.ToRoute().Path,
+				})
+				return nil
+			}
+
+			e.GET("/static", notFoundHandler)
+
+			var err error
+			if tc.whenHost != "" {
+				_, err = e.Host(tc.whenHost).AddRoute(tc.whenRoute)
+			} else {
+				_, err = e.AddRoute(tc.whenRoute)
+			}
+
+			if tc.expectError != "" {
+				assert.EqualError(t, err, tc.expectError)
+			} else {
+				assert.NoError(t, err)
+			}
+
+			r, _ := e.RouterFor(tc.whenHost)
+			assert.Len(t, r.Routes(), tc.expectLen)
+			assert.Equal(t, tc.expectAdded, added)
+		})
+	}
+}
+
+func TestEcho_RouterFor(t *testing.T) {
+	var testCases = []struct {
+		name      string
+		whenHost  string
+		expectLen int
+		expectOk  bool
+	}{
+		{
+			name:      "ok, default host",
+			whenHost:  "",
+			expectLen: 2,
+			expectOk:  true,
+		},
+		{
+			name:      "ok, specific host with routes",
+			whenHost:  "test.com",
+			expectLen: 1,
+			expectOk:  true,
+		},
+		{
+			name:      "ok, non-existent host",
+			whenHost:  "oups.com",
+			expectLen: 0,
+			expectOk:  false,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			e := New()
+
+			e.GET("/1", notFoundHandler)
+			e.GET("/2", notFoundHandler)
+			e.Host("test.com").GET("/3", notFoundHandler)
+
+			r, ok := e.RouterFor(tc.whenHost)
+			assert.Equal(t, tc.expectOk, ok)
+			if tc.expectLen > 0 {
+				assert.Len(t, r.Routes(), tc.expectLen)
+			} else {
+				assert.Nil(t, r)
+			}
+		})
+	}
+}
+
 func TestEchoContext(t *testing.T) {
 	e := New()
 	c := e.AcquireContext()

go.mod

@@ -1,19 +1,18 @@
 module github.com/labstack/echo/v5
 
-go 1.17
+go 1.18
 
 require (
-	github.com/golang-jwt/jwt/v4 v4.4.3
 	github.com/stretchr/testify v1.8.1
 	github.com/valyala/fasttemplate v1.2.2
-	golang.org/x/net v0.2.0
+	golang.org/x/net v0.4.0
 	golang.org/x/time v0.3.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	golang.org/x/text v0.4.0 // indirect
+	golang.org/x/text v0.5.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )