remove route

[lph110]

how to remove a route? added by e. post() or e.group

[lammel]

This is currently not possible. For now routes can only be added to the router which will register all handlers for the provided methods.

[joewhite86]

A real-world use-case would be to build a reverse proxy using a auto-discovery feature.

For instance I'm currently working on such an implementation for a kubernetes-based solution that automatically detects new services, reads out the annotations and dynamically adds routes for this service.

Now, if the service is deleted, the routes should be deleted in echo as well.
Otherwise the end-user would receive a 504 instead of a 404.

[aldas]

This would need serious rework (which we have done in v5 proposal. Currently (v4) Echo supports single implementation of Router - which is not goroutine safe i.e. you should not mutate routes after server has started.

Add/Removing route and matching Request to route at the same time leads to data-races/panics. There are no mutexes to prevent these things.

[joewhite86]

Hm that’s really good to know, thanks!

[joewhite86]

As a temporary solution I planned to implement the route removal like this

e.Pre(func(next echo.HandlerFunc) echo.HandlerFunc {
	return func(ctx echo.Context) error {
		if _, removed := removedRoutes[ctx.Request().Method+ctx.Request().URL.Path]; removed {
			return errors.ResourceNotFound("code=404, message=Not Found")
		}

		return next(ctx)
	}
})

I know that it's not perfect and might lead to memory problems but I don't expect thousands of routes atm and we need that feature.

Wouldn't it be possible to add an own lock in this pre middleware to prevent the panics /race conditions when adding new routes as well?

[aldas]

Add a mutex that guards Router Add/Find/Routes methods.

This is quite extreme example:

type customEcho struct {
	mu   sync.Mutex
	echo *echo.Echo
}

func (ce *customEcho) Add(method, path string, handler echo.HandlerFunc, middleware ...echo.MiddlewareFunc) *echo.Route {
	ce.mu.Lock()
	defer ce.mu.Unlock()
	return ce.echo.Add(method, path, handler, middleware...)
}

func (ce *customEcho) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	c := ce.echo.AcquireContext()
	defer ce.echo.ReleaseContext(c)
	c.Reset(r, w)

	ce.mu.Lock()
	ce.echo.Router().Find(r.Method, echo.GetPath(r), c)
	ce.mu.Unlock() // FIXME: should be fixed to Unlock on panic

	err := c.Handler()(c) // no c.Pre or c.Use middlewares will be executed only those that are added with route
	if err != nil {
		ce.echo.HTTPErrorHandler(err, c)
	}
}

func main() {
	ce := &customEcho{
		mu:   sync.Mutex{},
		echo: echo.New(),
	}

	ce.Add(http.MethodGet, "/test", func(c echo.Context) error {
		return c.String(http.StatusOK, "OK")
	})

	s := http.Server{
		Addr:    ":8080",
		Handler: ce,
	}

	if err := s.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
		log.Fatal(err)
	}
}