mirror of
https://github.com/MetaCubeX/mihomo.git
synced 2024-09-06 17:12:32 +00:00
239 lines
4.9 KiB
Go
239 lines
4.9 KiB
Go
package provider
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/dlclark/regexp2"
|
|
"runtime"
|
|
"time"
|
|
|
|
"github.com/Dreamacro/clash/adapter"
|
|
C "github.com/Dreamacro/clash/constant"
|
|
types "github.com/Dreamacro/clash/constant/provider"
|
|
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
const (
|
|
ReservedName = "default"
|
|
)
|
|
|
|
type ProxySchema struct {
|
|
Proxies []map[string]any `yaml:"proxies"`
|
|
}
|
|
|
|
// for auto gc
|
|
type ProxySetProvider struct {
|
|
*proxySetProvider
|
|
}
|
|
|
|
type proxySetProvider struct {
|
|
*fetcher
|
|
proxies []C.Proxy
|
|
healthCheck *HealthCheck
|
|
}
|
|
|
|
func (pp *proxySetProvider) MarshalJSON() ([]byte, error) {
|
|
return json.Marshal(map[string]any{
|
|
"name": pp.Name(),
|
|
"type": pp.Type().String(),
|
|
"vehicleType": pp.VehicleType().String(),
|
|
"proxies": pp.Proxies(),
|
|
//TODO maybe error because year value overflow
|
|
"updatedAt": pp.updatedAt,
|
|
})
|
|
}
|
|
|
|
func (pp *proxySetProvider) Name() string {
|
|
return pp.name
|
|
}
|
|
|
|
func (pp *proxySetProvider) HealthCheck() {
|
|
pp.healthCheck.check()
|
|
}
|
|
|
|
func (pp *proxySetProvider) Update() error {
|
|
elm, same, err := pp.fetcher.Update()
|
|
if err == nil && !same {
|
|
pp.onUpdate(elm)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (pp *proxySetProvider) Initial() error {
|
|
elm, err := pp.fetcher.Initial()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
pp.onUpdate(elm)
|
|
if pp.healthCheck.auto() {
|
|
go pp.healthCheck.process()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (pp *proxySetProvider) Type() types.ProviderType {
|
|
return types.Proxy
|
|
}
|
|
|
|
func (pp *proxySetProvider) Proxies() []C.Proxy {
|
|
return pp.proxies
|
|
}
|
|
|
|
func (pp *proxySetProvider) ProxiesWithTouch() []C.Proxy {
|
|
pp.healthCheck.touch()
|
|
return pp.Proxies()
|
|
}
|
|
|
|
func (pp *proxySetProvider) setProxies(proxies []C.Proxy) {
|
|
pp.proxies = proxies
|
|
pp.healthCheck.setProxy(proxies)
|
|
if pp.healthCheck.auto() {
|
|
go pp.healthCheck.check()
|
|
}
|
|
}
|
|
|
|
func stopProxyProvider(pd *ProxySetProvider) {
|
|
pd.healthCheck.close()
|
|
pd.fetcher.Destroy()
|
|
}
|
|
|
|
func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
|
|
//filterReg, err := regexp.Compile(filter)
|
|
filterReg, err := regexp2.Compile(filter, 0)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid filter regex: %w", err)
|
|
}
|
|
|
|
pd := &proxySetProvider{
|
|
proxies: []C.Proxy{},
|
|
healthCheck: hc,
|
|
}
|
|
|
|
onUpdate := func(elm any) {
|
|
ret := elm.([]C.Proxy)
|
|
pd.setProxies(ret)
|
|
}
|
|
|
|
proxiesParseAndFilter := func(buf []byte) (any, 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 {
|
|
name, ok := mapping["name"]
|
|
mat, _ := filterReg.FindStringMatch(name.(string))
|
|
if ok && len(filter) > 0 && mat == nil {
|
|
continue
|
|
}
|
|
proxy, err := adapter.ParseProxy(mapping)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("proxy %d error: %w", idx, err)
|
|
}
|
|
proxies = append(proxies, proxy)
|
|
}
|
|
|
|
if len(proxies) == 0 {
|
|
if len(filter) > 0 {
|
|
return nil, errors.New("doesn't match any proxy, please check your filter")
|
|
}
|
|
return nil, errors.New("file doesn't have any proxy")
|
|
}
|
|
|
|
return proxies, nil
|
|
}
|
|
|
|
fetcher := newFetcher(name, interval, vehicle, proxiesParseAndFilter, onUpdate)
|
|
pd.fetcher = fetcher
|
|
|
|
wrapper := &ProxySetProvider{pd}
|
|
runtime.SetFinalizer(wrapper, stopProxyProvider)
|
|
return wrapper, nil
|
|
}
|
|
|
|
// for auto gc
|
|
type CompatibleProvider struct {
|
|
*compatibleProvider
|
|
}
|
|
|
|
type compatibleProvider struct {
|
|
name string
|
|
healthCheck *HealthCheck
|
|
proxies []C.Proxy
|
|
}
|
|
|
|
func (cp *compatibleProvider) MarshalJSON() ([]byte, error) {
|
|
return json.Marshal(map[string]any{
|
|
"name": cp.Name(),
|
|
"type": cp.Type().String(),
|
|
"vehicleType": cp.VehicleType().String(),
|
|
"proxies": cp.Proxies(),
|
|
})
|
|
}
|
|
|
|
func (cp *compatibleProvider) Name() string {
|
|
return cp.name
|
|
}
|
|
|
|
func (cp *compatibleProvider) HealthCheck() {
|
|
cp.healthCheck.check()
|
|
}
|
|
|
|
func (cp *compatibleProvider) Update() error {
|
|
return nil
|
|
}
|
|
|
|
func (cp *compatibleProvider) Initial() error {
|
|
if cp.healthCheck.auto() {
|
|
go cp.healthCheck.process()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (cp *compatibleProvider) VehicleType() types.VehicleType {
|
|
return types.Compatible
|
|
}
|
|
|
|
func (cp *compatibleProvider) Type() types.ProviderType {
|
|
return types.Proxy
|
|
}
|
|
|
|
func (cp *compatibleProvider) Proxies() []C.Proxy {
|
|
return cp.proxies
|
|
}
|
|
|
|
func (cp *compatibleProvider) ProxiesWithTouch() []C.Proxy {
|
|
cp.healthCheck.touch()
|
|
return cp.Proxies()
|
|
}
|
|
|
|
func stopCompatibleProvider(pd *CompatibleProvider) {
|
|
pd.healthCheck.close()
|
|
}
|
|
|
|
func NewCompatibleProvider(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvider, error) {
|
|
if len(proxies) == 0 {
|
|
return nil, errors.New("provider need one proxy at least")
|
|
}
|
|
|
|
pd := &compatibleProvider{
|
|
name: name,
|
|
proxies: proxies,
|
|
healthCheck: hc,
|
|
}
|
|
|
|
wrapper := &CompatibleProvider{pd}
|
|
runtime.SetFinalizer(wrapper, stopCompatibleProvider)
|
|
return wrapper, nil
|
|
}
|