2022-07-11 13:30:34 +00:00
|
|
|
package resource
|
2020-04-26 14:38:15 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"crypto/md5"
|
|
|
|
"os"
|
2020-06-06 16:35:32 +00:00
|
|
|
"path/filepath"
|
2020-04-26 14:38:15 +00:00
|
|
|
"time"
|
|
|
|
|
2021-07-04 12:32:59 +00:00
|
|
|
types "github.com/Dreamacro/clash/constant/provider"
|
2020-04-26 14:38:15 +00:00
|
|
|
"github.com/Dreamacro/clash/log"
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2021-10-10 15:44:09 +00:00
|
|
|
fileMode os.FileMode = 0o666
|
|
|
|
dirMode os.FileMode = 0o755
|
2020-04-26 14:38:15 +00:00
|
|
|
)
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
type Parser[V any] func([]byte) (V, error)
|
|
|
|
|
|
|
|
type Fetcher[V any] struct {
|
|
|
|
resourceType string
|
|
|
|
name string
|
|
|
|
vehicle types.Vehicle
|
|
|
|
UpdatedAt *time.Time
|
|
|
|
ticker *time.Ticker
|
|
|
|
done chan struct{}
|
|
|
|
hash [16]byte
|
|
|
|
parser Parser[V]
|
|
|
|
interval time.Duration
|
|
|
|
OnUpdate func(V)
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
func (f *Fetcher[V]) Name() string {
|
2020-04-26 14:38:15 +00:00
|
|
|
return f.name
|
|
|
|
}
|
|
|
|
|
2022-11-04 18:24:08 +00:00
|
|
|
func (f *Fetcher[V]) Vehicle() types.Vehicle {
|
|
|
|
return f.vehicle
|
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
func (f *Fetcher[V]) VehicleType() types.VehicleType {
|
2020-04-26 14:38:15 +00:00
|
|
|
return f.vehicle.Type()
|
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
func (f *Fetcher[V]) Initial() (V, error) {
|
2020-05-29 13:56:29 +00:00
|
|
|
var (
|
2022-06-18 08:05:09 +00:00
|
|
|
buf []byte
|
|
|
|
err error
|
|
|
|
isLocal bool
|
|
|
|
forceUpdate bool
|
2020-05-29 13:56:29 +00:00
|
|
|
)
|
2022-05-07 16:04:16 +00:00
|
|
|
|
2020-05-29 13:56:29 +00:00
|
|
|
if stat, fErr := os.Stat(f.vehicle.Path()); fErr == nil {
|
2021-10-09 12:35:06 +00:00
|
|
|
buf, err = os.ReadFile(f.vehicle.Path())
|
2020-04-26 14:38:15 +00:00
|
|
|
modTime := stat.ModTime()
|
2022-07-11 13:30:34 +00:00
|
|
|
f.UpdatedAt = &modTime
|
2020-04-26 14:38:15 +00:00
|
|
|
isLocal = true
|
2022-05-26 13:05:00 +00:00
|
|
|
if f.interval != 0 && modTime.Add(f.interval).Before(time.Now()) {
|
2023-01-23 03:14:45 +00:00
|
|
|
log.Warnln("[Provider] %s not updated for a long time, force refresh", f.Name())
|
2022-06-18 08:05:09 +00:00
|
|
|
forceUpdate = true
|
2022-05-26 13:05:00 +00:00
|
|
|
}
|
2020-04-26 14:38:15 +00:00
|
|
|
} else {
|
|
|
|
buf, err = f.vehicle.Read()
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), err
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
var contents V
|
2022-06-18 08:05:09 +00:00
|
|
|
if forceUpdate {
|
|
|
|
var forceBuf []byte
|
|
|
|
if forceBuf, err = f.vehicle.Read(); err == nil {
|
2022-07-11 13:30:34 +00:00
|
|
|
if contents, err = f.parser(forceBuf); err == nil {
|
2022-06-18 08:05:09 +00:00
|
|
|
isLocal = false
|
|
|
|
buf = forceBuf
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil || !forceUpdate {
|
2022-07-11 13:30:34 +00:00
|
|
|
contents, err = f.parser(buf)
|
2022-06-18 08:05:09 +00:00
|
|
|
}
|
|
|
|
|
2020-04-26 14:38:15 +00:00
|
|
|
if err != nil {
|
|
|
|
if !isLocal {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), err
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// parse local file error, fallback to remote
|
|
|
|
buf, err = f.vehicle.Read()
|
|
|
|
if err != nil {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), err
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
contents, err = f.parser(buf)
|
2020-04-26 14:38:15 +00:00
|
|
|
if err != nil {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), err
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
2021-04-19 09:40:38 +00:00
|
|
|
|
|
|
|
isLocal = false
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2021-07-04 12:32:59 +00:00
|
|
|
if f.vehicle.Type() != types.File && !isLocal {
|
2020-07-18 11:32:40 +00:00
|
|
|
if err := safeWrite(f.vehicle.Path(), buf); err != nil {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), err
|
2020-07-18 11:32:40 +00:00
|
|
|
}
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
f.hash = md5.Sum(buf)
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
// pull contents automatically
|
2022-06-05 08:54:56 +00:00
|
|
|
if f.ticker != nil {
|
|
|
|
go f.pullLoop()
|
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
return contents, nil
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
func (f *Fetcher[V]) Update() (V, bool, error) {
|
2020-04-26 14:38:15 +00:00
|
|
|
buf, err := f.vehicle.Read()
|
|
|
|
if err != nil {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), false, err
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
now := time.Now()
|
|
|
|
hash := md5.Sum(buf)
|
|
|
|
if bytes.Equal(f.hash[:], hash[:]) {
|
2022-07-11 13:30:34 +00:00
|
|
|
f.UpdatedAt = &now
|
|
|
|
_ = os.Chtimes(f.vehicle.Path(), now, now)
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), true, nil
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
contents, err := f.parser(buf)
|
2020-04-26 14:38:15 +00:00
|
|
|
if err != nil {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), false, err
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2021-07-04 12:32:59 +00:00
|
|
|
if f.vehicle.Type() != types.File {
|
2021-01-06 06:20:15 +00:00
|
|
|
if err := safeWrite(f.vehicle.Path(), buf); err != nil {
|
2022-06-05 08:54:56 +00:00
|
|
|
return getZero[V](), false, err
|
2021-01-06 06:20:15 +00:00
|
|
|
}
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
f.UpdatedAt = &now
|
2020-04-26 14:38:15 +00:00
|
|
|
f.hash = hash
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
return contents, false, nil
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
func (f *Fetcher[V]) Destroy() error {
|
2020-04-26 14:38:15 +00:00
|
|
|
if f.ticker != nil {
|
2020-07-12 16:25:54 +00:00
|
|
|
f.done <- struct{}{}
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
func (f *Fetcher[V]) pullLoop() {
|
2020-07-12 16:25:54 +00:00
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-f.ticker.C:
|
2022-06-05 08:54:56 +00:00
|
|
|
elm, same, err := f.Update()
|
|
|
|
if err != nil {
|
2023-01-23 03:14:45 +00:00
|
|
|
log.Errorln("[Provider] %s pull error: %s", f.Name(), err.Error())
|
2020-07-12 16:25:54 +00:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2022-06-05 08:54:56 +00:00
|
|
|
if same {
|
2022-07-11 13:30:34 +00:00
|
|
|
log.Debugln("[Provider] %s's content doesn't change", f.Name())
|
2022-06-05 08:54:56 +00:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
log.Infoln("[Provider] %s's content update", f.Name())
|
|
|
|
if f.OnUpdate != nil {
|
|
|
|
f.OnUpdate(elm)
|
2022-06-05 08:54:56 +00:00
|
|
|
}
|
2020-07-12 16:25:54 +00:00
|
|
|
case <-f.done:
|
|
|
|
f.ticker.Stop()
|
|
|
|
return
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-06 16:35:32 +00:00
|
|
|
func safeWrite(path string, buf []byte) error {
|
|
|
|
dir := filepath.Dir(path)
|
|
|
|
|
|
|
|
if _, err := os.Stat(dir); os.IsNotExist(err) {
|
|
|
|
if err := os.MkdirAll(dir, dirMode); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-09 12:35:06 +00:00
|
|
|
return os.WriteFile(path, buf, fileMode)
|
2020-06-06 16:35:32 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
func NewFetcher[V any](name string, interval time.Duration, vehicle types.Vehicle, parser Parser[V], onUpdate func(V)) *Fetcher[V] {
|
2020-04-26 14:38:15 +00:00
|
|
|
var ticker *time.Ticker
|
|
|
|
if interval != 0 {
|
|
|
|
ticker = time.NewTicker(interval)
|
|
|
|
}
|
|
|
|
|
2022-07-11 13:30:34 +00:00
|
|
|
return &Fetcher[V]{
|
2020-04-26 14:38:15 +00:00
|
|
|
name: name,
|
|
|
|
ticker: ticker,
|
|
|
|
vehicle: vehicle,
|
|
|
|
parser: parser,
|
2020-07-12 16:25:54 +00:00
|
|
|
done: make(chan struct{}, 1),
|
2022-07-11 13:30:34 +00:00
|
|
|
OnUpdate: onUpdate,
|
2022-06-25 04:42:52 +00:00
|
|
|
interval: interval,
|
2020-04-26 14:38:15 +00:00
|
|
|
}
|
|
|
|
}
|
2022-06-05 08:54:56 +00:00
|
|
|
|
|
|
|
func getZero[V any]() V {
|
|
|
|
var result V
|
|
|
|
return result
|
|
|
|
}
|