mirror of
https://github.com/go-gitea/gitea
synced 2024-11-25 08:32:48 +01:00
bb0ff77e46
The recovery, API, Web and package frameworks all create their own HTML Renderers. This increases the memory requirements of Gitea unnecessarily with duplicate templates being kept in memory. Further the reloading framework in dev mode for these involves locking and recompiling all of the templates on each load. This will potentially hide concurrency issues and it is inefficient. This PR stores the templates renderer in the context and stores this context in the NormalRoutes, it then creates a fsnotify.Watcher framework to watch files. The watching framework is then extended to the mailer templates which were previously not being reloaded in dev. Then the locales are simplified to a similar structure. Fix #20210 Fix #20211 Fix #20217 Signed-off-by: Andrew Thornton <art27@cantab.net>
115 lines
3.1 KiB
Go
115 lines
3.1 KiB
Go
// Copyright 2022 The Gitea Authors. All rights reserved.
|
|
// Use of this source code is governed by a MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package watcher
|
|
|
|
import (
|
|
"context"
|
|
"io/fs"
|
|
"os"
|
|
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/process"
|
|
|
|
"github.com/fsnotify/fsnotify"
|
|
)
|
|
|
|
// CreateWatcherOpts are options to configure the watcher
|
|
type CreateWatcherOpts struct {
|
|
// PathsCallback is used to set the required paths to watch
|
|
PathsCallback func(func(path, name string, d fs.DirEntry, err error) error) error
|
|
|
|
// BeforeCallback is called before any files are watched
|
|
BeforeCallback func()
|
|
|
|
// Between Callback is called between after a watched event has occurred
|
|
BetweenCallback func()
|
|
|
|
// AfterCallback is called as this watcher ends
|
|
AfterCallback func()
|
|
}
|
|
|
|
// CreateWatcher creates a watcher labelled with the provided description and running with the provided options.
|
|
// The created watcher will create a subcontext from the provided ctx and register it with the process manager.
|
|
func CreateWatcher(ctx context.Context, desc string, opts *CreateWatcherOpts) {
|
|
go run(ctx, desc, opts)
|
|
}
|
|
|
|
func run(ctx context.Context, desc string, opts *CreateWatcherOpts) {
|
|
if opts.BeforeCallback != nil {
|
|
opts.BeforeCallback()
|
|
}
|
|
if opts.AfterCallback != nil {
|
|
defer opts.AfterCallback()
|
|
}
|
|
ctx, _, finished := process.GetManager().AddTypedContext(ctx, "Watcher: "+desc, process.SystemProcessType, true)
|
|
defer finished()
|
|
|
|
log.Trace("Watcher loop starting for %s", desc)
|
|
defer log.Trace("Watcher loop ended for %s", desc)
|
|
|
|
watcher, err := fsnotify.NewWatcher()
|
|
if err != nil {
|
|
log.Error("Unable to create watcher for %s: %v", desc, err)
|
|
return
|
|
}
|
|
if err := opts.PathsCallback(func(path, _ string, d fs.DirEntry, err error) error {
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
log.Trace("Watcher: %s watching %q", desc, path)
|
|
_ = watcher.Add(path)
|
|
return nil
|
|
}); err != nil {
|
|
log.Error("Unable to create watcher for %s: %v", desc, err)
|
|
_ = watcher.Close()
|
|
return
|
|
}
|
|
|
|
// Note we don't call the BetweenCallback here
|
|
|
|
for {
|
|
select {
|
|
case event, ok := <-watcher.Events:
|
|
if !ok {
|
|
_ = watcher.Close()
|
|
return
|
|
}
|
|
log.Debug("Watched file for %s had event: %v", desc, event)
|
|
case err, ok := <-watcher.Errors:
|
|
if !ok {
|
|
_ = watcher.Close()
|
|
return
|
|
}
|
|
log.Error("Error whilst watching files for %s: %v", desc, err)
|
|
case <-ctx.Done():
|
|
_ = watcher.Close()
|
|
return
|
|
}
|
|
|
|
// Recreate the watcher - only call the BetweenCallback after the new watcher is set-up
|
|
_ = watcher.Close()
|
|
watcher, err = fsnotify.NewWatcher()
|
|
if err != nil {
|
|
log.Error("Unable to create watcher for %s: %v", desc, err)
|
|
return
|
|
}
|
|
if err := opts.PathsCallback(func(path, _ string, _ fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = watcher.Add(path)
|
|
return nil
|
|
}); err != nil {
|
|
log.Error("Unable to create watcher for %s: %v", desc, err)
|
|
_ = watcher.Close()
|
|
return
|
|
}
|
|
|
|
// Inform our BetweenCallback that there has been an event
|
|
if opts.BetweenCallback != nil {
|
|
opts.BetweenCallback()
|
|
}
|
|
}
|
|
}
|