Feature: add experimental provider

adapters/provider/provider.go

@@ -0,0 +1,293 @@
+package provider
+
+import (
+	"bytes"
+	"crypto/md5"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/Dreamacro/clash/adapters/outbound"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
+
+	"gopkg.in/yaml.v2"
+)
+
+const (
+	ReservedName = "default"
+
+	fileMode = 0666
+)
+
+// Provider Type
+const (
+	Proxy ProviderType = iota
+	Rule
+)
+
+// ProviderType defined
+type ProviderType int
+
+func (pt ProviderType) String() string {
+	switch pt {
+	case Proxy:
+		return "Proxy"
+	case Rule:
+		return "Rule"
+	default:
+		return "Unknown"
+	}
+}
+
+// Provider interface
+type Provider interface {
+	Name() string
+	VehicleType() VehicleType
+	Type() ProviderType
+	Initial() error
+	Reload() error
+	Destroy() error
+}
+
+// ProxyProvider interface
+type ProxyProvider interface {
+	Provider
+	Proxies() []C.Proxy
+}
+
+type ProxySchema struct {
+	Proxies []map[string]interface{} `yaml:"proxies"`
+}
+
+type ProxySetProvider struct {
+	name              string
+	vehicle           Vehicle
+	hash              [16]byte
+	proxies           []C.Proxy
+	healthCheck       *healthCheck
+	healthCheckOption *HealthCheckOption
+	ticker            *time.Ticker
+
+	// mux for avoiding creating new goroutines when pulling
+	mux sync.Mutex
+}
+
+func (pp *ProxySetProvider) Name() string {
+	return pp.name
+}
+
+func (pp *ProxySetProvider) Reload() error {
+	return nil
+}
+
+func (pp *ProxySetProvider) Destroy() error {
+	pp.mux.Lock()
+	defer pp.mux.Unlock()
+	if pp.healthCheck != nil {
+		pp.healthCheck.close()
+		pp.healthCheck = nil
+	}
+
+	if pp.ticker != nil {
+		pp.ticker.Stop()
+	}
+
+	return nil
+}
+
+func (pp *ProxySetProvider) Initial() error {
+	var buf []byte
+	var err error
+	if _, err := os.Stat(pp.vehicle.Path()); err == nil {
+		buf, err = ioutil.ReadFile(pp.vehicle.Path())
+	} else {
+		buf, err = pp.vehicle.Read()
+	}
+
+	if err != nil {
+		return err
+	}
+
+	proxies, err := pp.parse(buf)
+	if err != nil {
+		return err
+	}
+
+	if err := ioutil.WriteFile(pp.vehicle.Path(), buf, fileMode); err != nil {
+		return err
+	}
+
+	pp.hash = md5.Sum(buf)
+	pp.setProxies(proxies)
+
+	// pull proxies automatically
+	if pp.ticker != nil {
+		go pp.pullLoop()
+	}
+
+	return nil
+}
+
+func (pp *ProxySetProvider) VehicleType() VehicleType {
+	return pp.vehicle.Type()
+}
+
+func (pp *ProxySetProvider) Type() ProviderType {
+	return Proxy
+}
+
+func (pp *ProxySetProvider) Proxies() []C.Proxy {
+	return pp.proxies
+}
+
+func (pp *ProxySetProvider) pullLoop() {
+	for range pp.ticker.C {
+		if err := pp.pull(); err != nil {
+			log.Warnln("[Provider] %s pull error: %s", pp.Name(), err.Error())
+		}
+	}
+}
+
+func (pp *ProxySetProvider) pull() error {
+	buf, err := pp.vehicle.Read()
+	if err != nil {
+		return err
+	}
+
+	hash := md5.Sum(buf)
+	if bytes.Equal(pp.hash[:], hash[:]) {
+		log.Debugln("[Provider] %s's proxies doesn't change", pp.Name())
+		return nil
+	}
+
+	proxies, err := pp.parse(buf)
+	if err != nil {
+		return err
+	}
+	log.Infoln("[Provider] %s's proxies update", pp.Name())
+
+	if err := ioutil.WriteFile(pp.vehicle.Path(), buf, fileMode); err != nil {
+		return err
+	}
+
+	pp.hash = hash
+	pp.setProxies(proxies)
+
+	return nil
+}
+
+func (pp *ProxySetProvider) parse(buf []byte) ([]C.Proxy, error) {
+	schema := &ProxySchema{}
+
+	if err := yaml.Unmarshal(buf, schema); err != nil {
+		return nil, err
+	}
+
+	if schema.Proxies == nil {
+		return nil, errors.New("File must have a `proxies` field")
+	}
+
+	proxies := []C.Proxy{}
+	for idx, mapping := range schema.Proxies {
+		proxy, err := outbound.ParseProxy(mapping)
+		if err != nil {
+			return nil, fmt.Errorf("Proxy %d error: %w", idx, err)
+		}
+		proxies = append(proxies, proxy)
+	}
+
+	return proxies, nil
+}
+
+func (pp *ProxySetProvider) setProxies(proxies []C.Proxy) {
+	pp.proxies = proxies
+	if pp.healthCheckOption != nil {
+		pp.mux.Lock()
+		if pp.healthCheck != nil {
+			pp.healthCheck.close()
+			pp.healthCheck = newHealthCheck(proxies, pp.healthCheckOption.URL, pp.healthCheckOption.Interval)
+			go pp.healthCheck.process()
+		}
+		pp.mux.Unlock()
+	}
+}
+
+func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
+	var ticker *time.Ticker
+	if interval != 0 {
+		ticker = time.NewTicker(interval)
+	}
+
+	return &ProxySetProvider{
+		name:              name,
+		vehicle:           vehicle,
+		proxies:           []C.Proxy{},
+		healthCheckOption: option,
+		ticker:            ticker,
+	}
+}
+
+type CompatibleProvier struct {
+	name        string
+	healthCheck *healthCheck
+	proxies     []C.Proxy
+}
+
+func (cp *CompatibleProvier) Name() string {
+	return cp.name
+}
+
+func (cp *CompatibleProvier) Reload() error {
+	return nil
+}
+
+func (cp *CompatibleProvier) Destroy() error {
+	if cp.healthCheck != nil {
+		cp.healthCheck.close()
+	}
+	return nil
+}
+
+func (cp *CompatibleProvier) Initial() error {
+	if cp.healthCheck != nil {
+		go cp.healthCheck.process()
+	}
+	return nil
+}
+
+func (cp *CompatibleProvier) VehicleType() VehicleType {
+	return Compatible
+}
+
+func (cp *CompatibleProvier) Type() ProviderType {
+	return Proxy
+}
+
+func (cp *CompatibleProvier) Proxies() []C.Proxy {
+	return cp.proxies
+}
+
+func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
+	if len(proxies) == 0 {
+		return nil, errors.New("Provider need one proxy at least")
+	}
+
+	var hc *healthCheck
+	if option != nil {
+		if _, err := url.Parse(option.URL); err != nil {
+			return nil, fmt.Errorf("URL format error: %w", err)
+		}
+		hc = newHealthCheck(proxies, option.URL, option.Interval)
+	}
+
+	return &CompatibleProvier{
+		name:        name,
+		proxies:     proxies,
+		healthCheck: hc,
+	}, nil
+}