Fixed a few issues:

- Incorrect name being shown on dashboard "Proxies page"
- Apps being shown when homepage.show is false
- Load balanced routes are shown on homepage instead of the load balancer
- Route with idlewatcher will now be removed on container destroy
- Idlewatcher panic
- Performance improvement
- Idlewatcher infinitely loading
- Reload stucked / not working properly
- Streams stuck on shutdown / reload
- etc...
Added:
- support idlewatcher for loadbalanced routes
- partial implementation for stream type idlewatcher
Issues:
- graceful shutdown

internal/route/provider/provider.go

@@ -0,0 +1,188 @@
+package provider
+
+import (
+	"fmt"
+	"path"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	E "github.com/yusing/go-proxy/internal/error"
+	R "github.com/yusing/go-proxy/internal/route"
+	"github.com/yusing/go-proxy/internal/task"
+	W "github.com/yusing/go-proxy/internal/watcher"
+	"github.com/yusing/go-proxy/internal/watcher/events"
+)
+
+type (
+	Provider struct {
+		ProviderImpl `json:"-"`
+
+		name   string
+		t      ProviderType
+		routes R.Routes
+
+		watcher W.Watcher
+
+		l *logrus.Entry
+	}
+	ProviderImpl interface {
+		fmt.Stringer
+		NewWatcher() W.Watcher
+		LoadRoutesImpl() (R.Routes, E.NestedError)
+	}
+	ProviderType  string
+	ProviderStats struct {
+		NumRPs     int          `json:"num_reverse_proxies"`
+		NumStreams int          `json:"num_streams"`
+		Type       ProviderType `json:"type"`
+	}
+)
+
+const (
+	ProviderTypeDocker ProviderType = "docker"
+	ProviderTypeFile   ProviderType = "file"
+
+	providerEventFlushInterval = 500 * time.Millisecond
+)
+
+func newProvider(name string, t ProviderType) *Provider {
+	p := &Provider{
+		name:   name,
+		t:      t,
+		routes: R.NewRoutes(),
+	}
+	p.l = logrus.WithField("provider", p)
+	return p
+}
+
+func NewFileProvider(filename string) (p *Provider, err E.NestedError) {
+	name := path.Base(filename)
+	if name == "" {
+		return nil, E.Invalid("file name", "empty")
+	}
+	p = newProvider(name, ProviderTypeFile)
+	p.ProviderImpl, err = FileProviderImpl(filename)
+	if err != nil {
+		return nil, err
+	}
+	p.watcher = p.NewWatcher()
+	return
+}
+
+func NewDockerProvider(name string, dockerHost string) (p *Provider, err E.NestedError) {
+	if name == "" {
+		return nil, E.Invalid("provider name", "empty")
+	}
+
+	p = newProvider(name, ProviderTypeDocker)
+	p.ProviderImpl, err = DockerProviderImpl(name, dockerHost, p.IsExplicitOnly())
+	if err != nil {
+		return nil, err
+	}
+	p.watcher = p.NewWatcher()
+	return
+}
+
+func (p *Provider) IsExplicitOnly() bool {
+	return p.name[len(p.name)-1] == '!'
+}
+
+func (p *Provider) GetName() string {
+	return p.name
+}
+
+func (p *Provider) GetType() ProviderType {
+	return p.t
+}
+
+// to work with json marshaller.
+func (p *Provider) MarshalText() ([]byte, error) {
+	return []byte(p.String()), nil
+}
+
+func (p *Provider) startRoute(parent task.Task, r *R.Route) E.NestedError {
+	subtask := parent.Subtask("route %s", r.Entry.Alias)
+	err := r.Start(subtask)
+	if err != nil {
+		p.routes.Delete(r.Entry.Alias)
+		subtask.Finish(err.String()) // just to ensure
+		return err
+	} else {
+		subtask.OnComplete("del from provider", func() {
+			p.routes.Delete(r.Entry.Alias)
+		})
+	}
+	return nil
+}
+
+// Start implements task.TaskStarter.
+func (p *Provider) Start(configSubtask task.Task) (res E.NestedError) {
+	errors := E.NewBuilder("errors starting routes")
+	defer errors.To(&res)
+
+	// routes and event queue will stop on parent cancel
+	providerTask := configSubtask
+
+	p.routes.RangeAllParallel(func(alias string, r *R.Route) {
+		errors.Add(p.startRoute(providerTask, r))
+	})
+
+	eventQueue := events.NewEventQueue(
+		providerTask,
+		providerEventFlushInterval,
+		func(flushTask task.Task, events []events.Event) {
+			handler := p.newEventHandler()
+			// routes' lifetime should follow the provider's lifetime
+			handler.Handle(providerTask, events)
+			handler.Log()
+			flushTask.Finish("events flushed")
+		},
+		func(err E.NestedError) {
+			p.l.Error(err)
+		},
+	)
+	eventQueue.Start(p.watcher.Events(providerTask.Context()))
+	return
+}
+
+func (p *Provider) RangeRoutes(do func(string, *R.Route)) {
+	p.routes.RangeAll(do)
+}
+
+func (p *Provider) GetRoute(alias string) (*R.Route, bool) {
+	return p.routes.Load(alias)
+}
+
+func (p *Provider) LoadRoutes() E.NestedError {
+	var err E.NestedError
+	p.routes, err = p.LoadRoutesImpl()
+	if p.routes.Size() > 0 {
+		return err
+	}
+	if err == nil {
+		return nil
+	}
+	return E.FailWith("loading routes", err)
+}
+
+func (p *Provider) NumRoutes() int {
+	return p.routes.Size()
+}
+
+func (p *Provider) Statistics() ProviderStats {
+	numRPs := 0
+	numStreams := 0
+	p.routes.RangeAll(func(_ string, r *R.Route) {
+		switch r.Type {
+		case R.RouteTypeReverseProxy:
+			numRPs++
+		case R.RouteTypeStream:
+			numStreams++
+		}
+	})
+	return ProviderStats{
+		NumRPs:     numRPs,
+		NumStreams: numStreams,
+		Type:       p.t,
+	}
+}