docstring_tokens stringlengths 0 76.5k | code_tokens stringlengths 75 1.81M | label_window listlengths 4 2.12k | html_url stringlengths 74 116 | file_name stringlengths 3 311 |
|---|---|---|---|---|
func (b *Base) Destroy() {}
| <mask> return b.tp
<mask> }
<mask>
<mask> func (b *Base) MarshalJSON() ([]byte, error) {
<mask> return json.Marshal(map[string]string{
<mask> "type": b.Type().String(),
<mask> })
<mask> }
</s> Improve: `Dial` would reset proxy alive status </s> remove all = append(all, proxy.RawProxy.Name())
</s> add all = append(all, proxy.Name()) </s> remove type Proxy interface {
</s> add type ProxyAdapter interface { </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/base.go |
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type proxy struct {
<mask> RawProxy C.Proxy
<mask> Valid bool
<mask> }
<mask>
<mask> type Fallback struct {
<mask> *Base
<mask> proxies []*proxy
<mask> rawURL string
<mask> interval time.Duration
</s> Improve: `Dial` would reset proxy alive status </s> remove proxies []*proxy
</s> add proxies []C.Proxy </s> remove type Proxy interface {
</s> add type ProxyAdapter interface { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go | |
proxies []C.Proxy | <mask> }
<mask>
<mask> type Fallback struct {
<mask> *Base
<mask> proxies []*proxy
<mask> rawURL string
<mask> interval time.Duration
<mask> done chan struct{}
<mask> }
<mask>
</s> Improve: `Dial` would reset proxy alive status </s> remove type proxy struct {
RawProxy C.Proxy
Valid bool
}
</s> add </s> remove warpperProxies := make([]*proxy, len(proxies))
for idx := range proxies {
warpperProxies[idx] = &proxy{
RawProxy: proxies[idx],
Valid: true,
}
}
</s> add </s> remove type Proxy interface {
</s> add type ProxyAdapter interface { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
proxy := f.findAliveProxy()
return proxy.Name() | <mask> Interval int `proxy:"interval"`
<mask> }
<mask>
<mask> func (f *Fallback) Now() string {
<mask> _, proxy := f.findNextValidProxy(0)
<mask> if proxy != nil {
<mask> return proxy.RawProxy.Name()
<mask> }
<mask> return f.proxies[0].RawProxy.Name()
<mask> }
<mask>
<mask> func (f *Fallback) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> idx := 0
<mask> var proxy *proxy
</s> Improve: `Dial` would reset proxy alive status </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy </s> remove func (f *Fallback) Close() {
</s> add func (f *Fallback) Destroy() { </s> remove all = append(all, proxy.RawProxy.Name())
</s> add all = append(all, proxy.Name()) </s> remove return -1, nil
</s> add return f.proxies[0] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
proxy := f.findAliveProxy()
return proxy.Dial(metadata) | <mask> return f.proxies[0].RawProxy.Name()
<mask> }
<mask>
<mask> func (f *Fallback) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> idx := 0
<mask> var proxy *proxy
<mask> for {
<mask> idx, proxy = f.findNextValidProxy(idx)
<mask> if proxy == nil {
<mask> break
<mask> }
<mask> adapter, err := proxy.RawProxy.Dial(metadata)
<mask> if err != nil {
<mask> proxy.Valid = false
<mask> idx++
<mask> continue
<mask> }
<mask> return adapter, err
<mask> }
<mask> return f.proxies[0].RawProxy.Dial(metadata)
<mask> }
<mask>
<mask> func (f *Fallback) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range f.proxies {
</s> Improve: `Dial` would reset proxy alive status </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() </s> remove all = append(all, proxy.RawProxy.Name())
</s> add all = append(all, proxy.Name()) </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy </s> remove for i := 0; i < lb.maxRetry; i++ {
</s> add for i := 0; i < lb.maxRetry; i, key = i+1, key+1 { </s> remove func (f *Fallback) Close() {
</s> add func (f *Fallback) Destroy() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
all = append(all, proxy.Name()) | <mask>
<mask> func (f *Fallback) MarshalJSON() ([]byte, error) {
<mask> var all []string
<mask> for _, proxy := range f.proxies {
<mask> all = append(all, proxy.RawProxy.Name())
<mask> }
<mask> return json.Marshal(map[string]interface{}{
<mask> "type": f.Type().String(),
<mask> "now": f.Now(),
<mask> "all": all,
</s> Improve: `Dial` would reset proxy alive status </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove func (f *Fallback) Close() {
</s> add func (f *Fallback) Destroy() { </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
func (f *Fallback) Destroy() { | <mask> "all": all,
<mask> })
<mask> }
<mask>
<mask> func (f *Fallback) Close() {
<mask> f.done <- struct{}{}
<mask> }
<mask>
<mask> func (f *Fallback) loop() {
<mask> tick := time.NewTicker(f.interval)
</s> Improve: `Dial` would reset proxy alive status </s> remove func (u *URLTest) Close() {
</s> add func (u *URLTest) Destroy() { </s> remove all = append(all, proxy.RawProxy.Name())
</s> add all = append(all, proxy.Name()) </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() </s> remove return -1, nil
</s> add return f.proxies[0] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy | <mask> }
<mask> }
<mask> }
<mask>
<mask> func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
<mask> for i := start; i < len(f.proxies); i++ {
<mask> if f.proxies[i].Valid {
<mask> return i, f.proxies[i]
<mask> }
<mask> }
<mask> return -1, nil
<mask> }
<mask>
</s> Improve: `Dial` would reset proxy alive status </s> remove return -1, nil
</s> add return f.proxies[0] </s> remove for i := 0; i < lb.maxRetry; i++ {
</s> add for i := 0; i < lb.maxRetry; i, key = i+1, key+1 { </s> remove if proxy, err := lb.proxies[idx].Dial(metadata); err == nil {
return proxy, nil
</s> add proxy := lb.proxies[idx]
if proxy.Alive() {
return proxy.Dial(metadata) </s> remove func (f *Fallback) Close() {
</s> add func (f *Fallback) Destroy() { </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
return f.proxies[0] | <mask> if f.proxies[i].Valid {
<mask> return i, f.proxies[i]
<mask> }
<mask> }
<mask> return -1, nil
<mask> }
<mask>
<mask> func (f *Fallback) validTest() {
<mask> wg := sync.WaitGroup{}
<mask> wg.Add(len(f.proxies))
</s> Improve: `Dial` would reset proxy alive status </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy </s> remove go func(p *proxy) {
_, err := DelayTest(p.RawProxy, f.rawURL)
p.Valid = err == nil
</s> add go func(p C.Proxy) {
p.URLTest(f.rawURL) </s> remove func (f *Fallback) Close() {
</s> add func (f *Fallback) Destroy() { </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
go func(p C.Proxy) {
p.URLTest(f.rawURL) | <mask> wg := sync.WaitGroup{}
<mask> wg.Add(len(f.proxies))
<mask>
<mask> for _, p := range f.proxies {
<mask> go func(p *proxy) {
<mask> _, err := DelayTest(p.RawProxy, f.rawURL)
<mask> p.Valid = err == nil
<mask> wg.Done()
<mask> }(p)
<mask> }
<mask>
<mask> wg.Wait()
</s> Improve: `Dial` would reset proxy alive status </s> remove _, err := DelayTest(p, u.rawURL)
</s> add _, err := p.URLTest(u.rawURL) </s> remove fast := selectFast(c)
</s> add fast := picker.SelectFast(context.Background(), c) </s> remove return -1, nil
</s> add return f.proxies[0] </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
<mask> return nil, errors.New("The number of proxies cannot be 0")
<mask> }
<mask>
<mask> interval := time.Duration(option.Interval) * time.Second
<mask> warpperProxies := make([]*proxy, len(proxies))
<mask> for idx := range proxies {
<mask> warpperProxies[idx] = &proxy{
<mask> RawProxy: proxies[idx],
<mask> Valid: true,
<mask> }
<mask> }
<mask>
<mask> Fallback := &Fallback{
<mask> Base: &Base{
<mask> name: option.Name,
<mask> tp: C.Fallback,
</s> Improve: `Dial` would reset proxy alive status </s> remove proxies: warpperProxies,
</s> add proxies: proxies, </s> remove proxies []*proxy
</s> add proxies []C.Proxy </s> remove proxies[groupName] = group
</s> add proxies[groupName] = adapters.NewProxy(group) </s> remove proxies["GLOBAL"], _ = adapters.NewSelector("GLOBAL", ps)
</s> add global, _ := adapters.NewSelector("GLOBAL", ps)
proxies["GLOBAL"] = adapters.NewProxy(global) </s> remove type proxy struct {
RawProxy C.Proxy
Valid bool
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go | |
proxies: proxies, | <mask> Base: &Base{
<mask> name: option.Name,
<mask> tp: C.Fallback,
<mask> },
<mask> proxies: warpperProxies,
<mask> rawURL: option.URL,
<mask> interval: interval,
<mask> done: make(chan struct{}),
<mask> }
<mask> go Fallback.loop()
</s> Improve: `Dial` would reset proxy alive status </s> remove warpperProxies := make([]*proxy, len(proxies))
for idx := range proxies {
warpperProxies[idx] = &proxy{
RawProxy: proxies[idx],
Valid: true,
}
}
</s> add </s> remove t, err := A.DelayTest(proxy, url)
</s> add t, err := proxy.URLTest(url) </s> remove func selectFast(in chan interface{}) chan interface{} {
out := make(chan interface{})
go func() {
p, open := <-in
if open {
out <- p
}
close(out)
for range in {
}
}()
return out
}
</s> add </s> remove fast := selectFast(c)
</s> add fast := picker.SelectFast(context.Background(), c) </s> remove go func(p *proxy) {
_, err := DelayTest(p.RawProxy, f.rawURL)
p.Valid = err == nil
</s> add go func(p C.Proxy) {
p.URLTest(f.rawURL) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/fallback.go |
for i := 0; i < lb.maxRetry; i, key = i+1, key+1 { | <mask>
<mask> func (lb *LoadBalance) Dial(metadata *C.Metadata) (net.Conn, error) {
<mask> key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
<mask> buckets := int32(len(lb.proxies))
<mask> for i := 0; i < lb.maxRetry; i++ {
<mask> idx := jumpHash(key, buckets)
<mask> if proxy, err := lb.proxies[idx].Dial(metadata); err == nil {
<mask> return proxy, nil
<mask> }
<mask> key++
</s> Improve: `Dial` would reset proxy alive status </s> remove if proxy, err := lb.proxies[idx].Dial(metadata); err == nil {
return proxy, nil
</s> add proxy := lb.proxies[idx]
if proxy.Alive() {
return proxy.Dial(metadata) </s> remove key++
</s> add </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/loadbalance.go |
proxy := lb.proxies[idx]
if proxy.Alive() {
return proxy.Dial(metadata) | <mask> key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
<mask> buckets := int32(len(lb.proxies))
<mask> for i := 0; i < lb.maxRetry; i++ {
<mask> idx := jumpHash(key, buckets)
<mask> if proxy, err := lb.proxies[idx].Dial(metadata); err == nil {
<mask> return proxy, nil
<mask> }
<mask> key++
<mask> }
<mask>
<mask> return lb.proxies[0].Dial(metadata)
</s> Improve: `Dial` would reset proxy alive status </s> remove for i := 0; i < lb.maxRetry; i++ {
</s> add for i := 0; i < lb.maxRetry; i, key = i+1, key+1 { </s> remove key++
</s> add </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy </s> remove _, err := DelayTest(p, u.rawURL)
</s> add _, err := p.URLTest(u.rawURL) </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/loadbalance.go |
<mask> idx := jumpHash(key, buckets)
<mask> if proxy, err := lb.proxies[idx].Dial(metadata); err == nil {
<mask> return proxy, nil
<mask> }
<mask> key++
<mask> }
<mask>
<mask> return lb.proxies[0].Dial(metadata)
<mask> }
<mask>
</s> Improve: `Dial` would reset proxy alive status </s> remove if proxy, err := lb.proxies[idx].Dial(metadata); err == nil {
return proxy, nil
</s> add proxy := lb.proxies[idx]
if proxy.Alive() {
return proxy.Dial(metadata) </s> remove for i := 0; i < lb.maxRetry; i++ {
</s> add for i := 0; i < lb.maxRetry; i, key = i+1, key+1 { </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove _, err := DelayTest(p, u.rawURL)
</s> add _, err := p.URLTest(u.rawURL) </s> remove // DelayTest get the delay for the specified URL
func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
addr, err := urlToMetadata(url)
if err != nil {
return
}
start := time.Now()
instance, err := proxy.Dial(&addr)
if err != nil {
return
}
defer instance.Close()
transport := &http.Transport{
Dial: func(string, string) (net.Conn, error) {
return instance, nil
},
// from http.DefaultTransport
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
client := http.Client{Transport: transport}
resp, err := client.Get(url)
if err != nil {
return
}
resp.Body.Close()
t = int16(time.Since(start) / time.Millisecond)
return
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/loadbalance.go | |
"context" | <mask> package adapters
<mask>
<mask> import (
<mask> "encoding/json"
<mask> "errors"
<mask> "net"
<mask> "sort"
<mask> "sync"
<mask> "sync/atomic"
</s> Improve: `Dial` would reset proxy alive status </s> remove "net/http"
</s> add </s> remove adapters "github.com/Dreamacro/clash/adapters/outbound"
</s> add | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/urltest.go |
"github.com/Dreamacro/clash/common/picker" | <mask> "sync"
<mask> "sync/atomic"
<mask> "time"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
<mask> )
<mask>
<mask> type URLTest struct {
<mask> *Base
</s> Improve: `Dial` would reset proxy alive status </s> remove type proxy struct {
RawProxy C.Proxy
Valid bool
}
</s> add </s> remove "net/http"
</s> add </s> remove proxies []*proxy
</s> add proxies []C.Proxy | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/urltest.go |
func (u *URLTest) Destroy() { | <mask> "all": all,
<mask> })
<mask> }
<mask>
<mask> func (u *URLTest) Close() {
<mask> u.done <- struct{}{}
<mask> }
<mask>
<mask> func (u *URLTest) loop() {
<mask> tick := time.NewTicker(u.interval)
</s> Improve: `Dial` would reset proxy alive status </s> remove func (f *Fallback) Close() {
</s> add func (f *Fallback) Destroy() { </s> remove all = append(all, proxy.RawProxy.Name())
</s> add all = append(all, proxy.Name()) </s> remove func selectFast(in chan interface{}) chan interface{} {
out := make(chan interface{})
go func() {
p, open := <-in
if open {
out <- p
}
close(out)
for range in {
}
}()
return out
}
</s> add </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/urltest.go |
fast := picker.SelectFast(context.Background(), c) | <mask>
<mask> wg := sync.WaitGroup{}
<mask> wg.Add(len(u.proxies))
<mask> c := make(chan interface{})
<mask> fast := selectFast(c)
<mask> timer := time.NewTimer(u.interval)
<mask>
<mask> for _, p := range u.proxies {
<mask> go func(p C.Proxy) {
<mask> _, err := DelayTest(p, u.rawURL)
</s> Improve: `Dial` would reset proxy alive status </s> remove _, err := DelayTest(p, u.rawURL)
</s> add _, err := p.URLTest(u.rawURL) </s> remove go func(p *proxy) {
_, err := DelayTest(p.RawProxy, f.rawURL)
p.Valid = err == nil
</s> add go func(p C.Proxy) {
p.URLTest(f.rawURL) </s> remove func selectFast(in chan interface{}) chan interface{} {
out := make(chan interface{})
go func() {
p, open := <-in
if open {
out <- p
}
close(out)
for range in {
}
}()
return out
}
</s> add </s> remove t, err := A.DelayTest(proxy, url)
</s> add t, err := proxy.URLTest(url) </s> remove return -1, nil
</s> add return f.proxies[0] | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/urltest.go |
_, err := p.URLTest(u.rawURL) | <mask> timer := time.NewTimer(u.interval)
<mask>
<mask> for _, p := range u.proxies {
<mask> go func(p C.Proxy) {
<mask> _, err := DelayTest(p, u.rawURL)
<mask> if err == nil {
<mask> c <- p
<mask> }
<mask> wg.Done()
<mask> }(p)
</s> Improve: `Dial` would reset proxy alive status </s> remove fast := selectFast(c)
</s> add fast := picker.SelectFast(context.Background(), c) </s> remove go func(p *proxy) {
_, err := DelayTest(p.RawProxy, f.rawURL)
p.Valid = err == nil
</s> add go func(p C.Proxy) {
p.URLTest(f.rawURL) </s> remove func selectFast(in chan interface{}) chan interface{} {
out := make(chan interface{})
go func() {
p, open := <-in
if open {
out <- p
}
close(out)
for range in {
}
}()
return out
}
</s> add </s> remove t, err := A.DelayTest(proxy, url)
</s> add t, err := proxy.URLTest(url) </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/urltest.go |
<mask> import (
<mask> "crypto/tls"
<mask> "fmt"
<mask> "net"
<mask> "net/http"
<mask> "net/url"
<mask> "sync"
<mask> "time"
<mask>
<mask> C "github.com/Dreamacro/clash/constant"
</s> Improve: `Dial` would reset proxy alive status </s> remove adapters "github.com/Dreamacro/clash/adapters/outbound"
</s> add </s> remove type proxy struct {
RawProxy C.Proxy
Valid bool
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/util.go | |
<mask> globalClientSessionCache tls.ClientSessionCache
<mask> once sync.Once
<mask> )
<mask>
<mask> // DelayTest get the delay for the specified URL
<mask> func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
<mask> addr, err := urlToMetadata(url)
<mask> if err != nil {
<mask> return
<mask> }
<mask>
<mask> start := time.Now()
<mask> instance, err := proxy.Dial(&addr)
<mask> if err != nil {
<mask> return
<mask> }
<mask> defer instance.Close()
<mask> transport := &http.Transport{
<mask> Dial: func(string, string) (net.Conn, error) {
<mask> return instance, nil
<mask> },
<mask> // from http.DefaultTransport
<mask> MaxIdleConns: 100,
<mask> IdleConnTimeout: 90 * time.Second,
<mask> TLSHandshakeTimeout: 10 * time.Second,
<mask> ExpectContinueTimeout: 1 * time.Second,
<mask> }
<mask> client := http.Client{Transport: transport}
<mask> resp, err := client.Get(url)
<mask> if err != nil {
<mask> return
<mask> }
<mask> resp.Body.Close()
<mask> t = int16(time.Since(start) / time.Millisecond)
<mask> return
<mask> }
<mask>
<mask> func urlToMetadata(rawURL string) (addr C.Metadata, err error) {
<mask> u, err := url.Parse(rawURL)
<mask> if err != nil {
<mask> return
<mask> }
</s> Improve: `Dial` would reset proxy alive status </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove t, err := A.DelayTest(proxy, url)
</s> add t, err := proxy.URLTest(url) </s> remove render.JSON(w, r, ErrBadRequest)
</s> add render.JSON(w, r, newError("Must be a Selector")) </s> remove proxies[groupName] = group
</s> add proxies[groupName] = adapters.NewProxy(group) </s> remove for i := 0; i < lb.maxRetry; i++ {
</s> add for i := 0; i < lb.maxRetry; i, key = i+1, key+1 { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"re... | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/util.go | |
<mask> }
<mask> return
<mask> }
<mask>
<mask> func selectFast(in chan interface{}) chan interface{} {
<mask> out := make(chan interface{})
<mask> go func() {
<mask> p, open := <-in
<mask> if open {
<mask> out <- p
<mask> }
<mask> close(out)
<mask> for range in {
<mask> }
<mask> }()
<mask>
<mask> return out
<mask> }
<mask>
<mask> func tcpKeepAlive(c net.Conn) {
<mask> if tcp, ok := c.(*net.TCPConn); ok {
<mask> tcp.SetKeepAlive(true)
<mask> tcp.SetKeepAlivePeriod(30 * time.Second)
<mask> }
</s> Improve: `Dial` would reset proxy alive status </s> remove t, err := A.DelayTest(proxy, url)
</s> add t, err := proxy.URLTest(url) </s> remove _, err := DelayTest(p, u.rawURL)
</s> add _, err := p.URLTest(u.rawURL) </s> remove fast := selectFast(c)
</s> add fast := picker.SelectFast(context.Background(), c) </s> remove proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
selector, ok := proxy.(*A.Selector)
</s> add proxy := r.Context().Value(CtxKeyProxy).(*A.Proxy)
selector, ok := proxy.ProxyAdapter.(*A.Selector) </s> remove func (f *Fallback) findNextValidProxy(start int) (int, *proxy) {
for i := start; i < len(f.proxies); i++ {
if f.proxies[i].Valid {
return i, f.proxies[i]
</s> add func (f *Fallback) findAliveProxy() C.Proxy {
for _, proxy := range f.proxies {
if proxy.Alive() {
return proxy | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | adapters/outbound/util.go | |
proxies["DIRECT"] = adapters.NewProxy(adapters.NewDirect())
proxies["REJECT"] = adapters.NewProxy(adapters.NewReject()) | <mask> groupsConfig := cfg.ProxyGroup
<mask>
<mask> decoder := structure.NewDecoder(structure.Option{TagName: "proxy", WeaklyTypedInput: true})
<mask>
<mask> proxies["DIRECT"] = adapters.NewDirect()
<mask> proxies["REJECT"] = adapters.NewReject()
<mask>
<mask> // parse proxy
<mask> for idx, mapping := range proxiesConfig {
<mask> proxyType, existType := mapping["type"].(string)
<mask> if !existType {
</s> Improve: `Dial` would reset proxy alive status </s> remove proxies[proxy.Name()] = proxy
</s> add proxies[proxy.Name()] = adapters.NewProxy(proxy) </s> remove var proxy C.Proxy
</s> add var proxy C.ProxyAdapter </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove // close old goroutine
</s> add // close proxy group goroutine </s> remove switch raw := proxy.(type) {
case *adapters.URLTest:
raw.Close()
case *adapters.Fallback:
raw.Close()
}
</s> add proxy.Destroy() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | config/config.go |
var proxy C.ProxyAdapter | <mask> if !existType {
<mask> return nil, fmt.Errorf("Proxy %d missing type", idx)
<mask> }
<mask>
<mask> var proxy C.Proxy
<mask> err := fmt.Errorf("can't parse")
<mask> switch proxyType {
<mask> case "ss":
<mask> ssOption := &adapters.ShadowSocksOption{}
<mask> err = decoder.Decode(mapping, ssOption)
</s> Improve: `Dial` would reset proxy alive status </s> remove var group C.Proxy
</s> add var group C.ProxyAdapter </s> remove proxies[groupName] = group
</s> add proxies[groupName] = adapters.NewProxy(group) </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove proxies[proxy.Name()] = proxy
</s> add proxies[proxy.Name()] = adapters.NewProxy(proxy) </s> remove switch raw := proxy.(type) {
case *adapters.URLTest:
raw.Close()
case *adapters.Fallback:
raw.Close()
}
</s> add proxy.Destroy() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | config/config.go |
proxies[proxy.Name()] = adapters.NewProxy(proxy) | <mask>
<mask> if _, exist := proxies[proxy.Name()]; exist {
<mask> return nil, fmt.Errorf("Proxy %s is the duplicate name", proxy.Name())
<mask> }
<mask> proxies[proxy.Name()] = proxy
<mask> }
<mask>
<mask> // parse proxy group
<mask> for idx, mapping := range groupsConfig {
<mask> groupType, existType := mapping["type"].(string)
</s> Improve: `Dial` would reset proxy alive status </s> remove var group C.Proxy
</s> add var group C.ProxyAdapter </s> remove proxies["DIRECT"] = adapters.NewDirect()
proxies["REJECT"] = adapters.NewReject()
</s> add proxies["DIRECT"] = adapters.NewProxy(adapters.NewDirect())
proxies["REJECT"] = adapters.NewProxy(adapters.NewReject()) </s> remove proxies[groupName] = group
</s> add proxies[groupName] = adapters.NewProxy(group) </s> remove var proxy C.Proxy
</s> add var proxy C.ProxyAdapter </s> remove // close old goroutine
</s> add // close proxy group goroutine | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | config/config.go |
var group C.ProxyAdapter | <mask>
<mask> if _, exist := proxies[groupName]; exist {
<mask> return nil, fmt.Errorf("ProxyGroup %s: the duplicate name", groupName)
<mask> }
<mask> var group C.Proxy
<mask> ps := []C.Proxy{}
<mask>
<mask> err := fmt.Errorf("can't parse")
<mask> switch groupType {
<mask> case "url-test":
</s> Improve: `Dial` would reset proxy alive status </s> remove proxies[proxy.Name()] = proxy
</s> add proxies[proxy.Name()] = adapters.NewProxy(proxy) </s> remove var proxy C.Proxy
</s> add var proxy C.ProxyAdapter </s> remove proxies[groupName] = group
</s> add proxies[groupName] = adapters.NewProxy(group) </s> remove // close old goroutine
</s> add // close proxy group goroutine </s> remove switch raw := proxy.(type) {
case *adapters.URLTest:
raw.Close()
case *adapters.Fallback:
raw.Close()
}
</s> add proxy.Destroy() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | config/config.go |
proxies[groupName] = adapters.NewProxy(group) | <mask> }
<mask> if err != nil {
<mask> return nil, fmt.Errorf("Proxy %s: %s", groupName, err.Error())
<mask> }
<mask> proxies[groupName] = group
<mask> }
<mask>
<mask> ps := []C.Proxy{}
<mask> for _, v := range proxies {
<mask> ps = append(ps, v)
</s> Improve: `Dial` would reset proxy alive status </s> remove proxies["GLOBAL"], _ = adapters.NewSelector("GLOBAL", ps)
</s> add global, _ := adapters.NewSelector("GLOBAL", ps)
proxies["GLOBAL"] = adapters.NewProxy(global) </s> remove var group C.Proxy
</s> add var group C.ProxyAdapter </s> remove proxies[proxy.Name()] = proxy
</s> add proxies[proxy.Name()] = adapters.NewProxy(proxy) </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove var proxy C.Proxy
</s> add var proxy C.ProxyAdapter | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | config/config.go |
global, _ := adapters.NewSelector("GLOBAL", ps)
proxies["GLOBAL"] = adapters.NewProxy(global) | <mask> for _, v := range proxies {
<mask> ps = append(ps, v)
<mask> }
<mask>
<mask> proxies["GLOBAL"], _ = adapters.NewSelector("GLOBAL", ps)
<mask> return proxies, nil
<mask> }
<mask>
<mask> func parseRules(cfg *rawConfig) ([]C.Rule, error) {
<mask> rules := []C.Rule{}
</s> Improve: `Dial` would reset proxy alive status </s> remove proxies[groupName] = group
</s> add proxies[groupName] = adapters.NewProxy(group) </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove warpperProxies := make([]*proxy, len(proxies))
for idx := range proxies {
warpperProxies[idx] = &proxy{
RawProxy: proxies[idx],
Valid: true,
}
}
</s> add </s> remove all = append(all, proxy.RawProxy.Name())
</s> add all = append(all, proxy.Name()) </s> remove go func(p *proxy) {
_, err := DelayTest(p.RawProxy, f.rawURL)
p.Valid = err == nil
</s> add go func(p C.Proxy) {
p.URLTest(f.rawURL) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | config/config.go |
type ProxyAdapter interface { | <mask> Metadata() *Metadata
<mask> Close()
<mask> }
<mask>
<mask> type Proxy interface {
<mask> Name() string
<mask> Type() AdapterType
<mask> Dial(metadata *Metadata) (net.Conn, error)
<mask> MarshalJSON() ([]byte, error)
<mask> }
</s> Improve: `Dial` would reset proxy alive status </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | constant/adapters.go |
Destroy() | <mask> Name() string
<mask> Type() AdapterType
<mask> Dial(metadata *Metadata) (net.Conn, error)
<mask> MarshalJSON() ([]byte, error)
<mask> }
<mask>
<mask> type Proxy interface {
</s> Improve: `Dial` would reset proxy alive status </s> remove type Proxy interface {
</s> add type ProxyAdapter interface { </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | constant/adapters.go |
type Proxy interface {
ProxyAdapter
Alive() bool
URLTest(url string) (int16, error)
}
| <mask> MarshalJSON() ([]byte, error)
<mask> }
<mask>
<mask> // AdapterType is enum of adapter type
<mask> type AdapterType int
<mask>
<mask> func (at AdapterType) String() string {
<mask> switch at {
<mask> case Direct:
</s> Improve: `Dial` would reset proxy alive status </s> remove type Proxy interface {
</s> add type ProxyAdapter interface { </s> remove type proxy struct {
RawProxy C.Proxy
Valid bool
}
</s> add </s> remove switch raw := proxy.(type) {
case *adapters.URLTest:
raw.Close()
case *adapters.Fallback:
raw.Close()
}
</s> add proxy.Destroy() </s> remove // close old goroutine
</s> add // close proxy group goroutine | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | constant/adapters.go |
<mask> package executor
<mask>
<mask> import (
<mask> adapters "github.com/Dreamacro/clash/adapters/outbound"
<mask> "github.com/Dreamacro/clash/config"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/dns"
<mask> "github.com/Dreamacro/clash/log"
<mask> P "github.com/Dreamacro/clash/proxy"
</s> Improve: `Dial` would reset proxy alive status </s> remove "net/http"
</s> add </s> remove type proxy struct {
RawProxy C.Proxy
Valid bool
}
</s> add | [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | hub/executor/executor.go | |
// close proxy group goroutine | <mask> func updateProxies(proxies map[string]C.Proxy) {
<mask> tunnel := T.Instance()
<mask> oldProxies := tunnel.Proxies()
<mask>
<mask> // close old goroutine
<mask> for _, proxy := range oldProxies {
<mask> switch raw := proxy.(type) {
<mask> case *adapters.URLTest:
<mask> raw.Close()
<mask> case *adapters.Fallback:
</s> Improve: `Dial` would reset proxy alive status </s> remove switch raw := proxy.(type) {
case *adapters.URLTest:
raw.Close()
case *adapters.Fallback:
raw.Close()
}
</s> add proxy.Destroy() </s> remove var group C.Proxy
</s> add var group C.ProxyAdapter </s> remove var proxy C.Proxy
</s> add var proxy C.ProxyAdapter </s> remove proxies[proxy.Name()] = proxy
</s> add proxies[proxy.Name()] = adapters.NewProxy(proxy) </s> remove proxies["DIRECT"] = adapters.NewDirect()
proxies["REJECT"] = adapters.NewReject()
</s> add proxies["DIRECT"] = adapters.NewProxy(adapters.NewDirect())
proxies["REJECT"] = adapters.NewProxy(adapters.NewReject()) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | hub/executor/executor.go |
proxy.Destroy() | <mask> oldProxies := tunnel.Proxies()
<mask>
<mask> // close old goroutine
<mask> for _, proxy := range oldProxies {
<mask> switch raw := proxy.(type) {
<mask> case *adapters.URLTest:
<mask> raw.Close()
<mask> case *adapters.Fallback:
<mask> raw.Close()
<mask> }
<mask> }
<mask>
<mask> tunnel.UpdateProxies(proxies)
<mask> }
<mask>
</s> Improve: `Dial` would reset proxy alive status </s> remove // close old goroutine
</s> add // close proxy group goroutine </s> remove var group C.Proxy
</s> add var group C.ProxyAdapter </s> remove var proxy C.Proxy
</s> add var proxy C.ProxyAdapter </s> remove proxies[proxy.Name()] = proxy
</s> add proxies[proxy.Name()] = adapters.NewProxy(proxy) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | hub/executor/executor.go |
proxy := r.Context().Value(CtxKeyProxy).(*A.Proxy)
selector, ok := proxy.ProxyAdapter.(*A.Selector) | <mask> render.JSON(w, r, ErrBadRequest)
<mask> return
<mask> }
<mask>
<mask> proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
<mask>
<mask> selector, ok := proxy.(*A.Selector)
<mask> if !ok {
<mask> render.Status(r, http.StatusBadRequest)
<mask> render.JSON(w, r, ErrBadRequest)
<mask> return
<mask> }
</s> Improve: `Dial` would reset proxy alive status </s> remove render.JSON(w, r, ErrBadRequest)
</s> add render.JSON(w, r, newError("Must be a Selector")) </s> remove func selectFast(in chan interface{}) chan interface{} {
out := make(chan interface{})
go func() {
p, open := <-in
if open {
out <- p
}
close(out)
for range in {
}
}()
return out
}
</s> add </s> remove t, err := A.DelayTest(proxy, url)
</s> add t, err := proxy.URLTest(url) </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | hub/route/proxies.go |
render.JSON(w, r, newError("Must be a Selector")) | <mask>
<mask> selector, ok := proxy.(*A.Selector)
<mask> if !ok {
<mask> render.Status(r, http.StatusBadRequest)
<mask> render.JSON(w, r, ErrBadRequest)
<mask> return
<mask> }
<mask>
<mask> if err := selector.Set(req.Name); err != nil {
<mask> render.Status(r, http.StatusBadRequest)
</s> Improve: `Dial` would reset proxy alive status </s> remove proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
selector, ok := proxy.(*A.Selector)
</s> add proxy := r.Context().Value(CtxKeyProxy).(*A.Proxy)
selector, ok := proxy.ProxyAdapter.(*A.Selector) </s> remove // DelayTest get the delay for the specified URL
func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
addr, err := urlToMetadata(url)
if err != nil {
return
}
start := time.Now()
instance, err := proxy.Dial(&addr)
if err != nil {
return
}
defer instance.Close()
transport := &http.Transport{
Dial: func(string, string) (net.Conn, error) {
return instance, nil
},
// from http.DefaultTransport
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
client := http.Client{Transport: transport}
resp, err := client.Get(url)
if err != nil {
return
}
resp.Body.Close()
t = int16(time.Since(start) / time.Millisecond)
return
}
</s> add </s> remove t, err := A.DelayTest(proxy, url)
</s> add t, err := proxy.URLTest(url) </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove func selectFast(in chan interface{}) chan interface{} {
out := make(chan interface{})
go func() {
p, open := <-in
if open {
out <- p
}
close(out)
for range in {
}
}()
return out
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | hub/route/proxies.go |
t, err := proxy.URLTest(url) | <mask> proxy := r.Context().Value(CtxKeyProxy).(C.Proxy)
<mask>
<mask> sigCh := make(chan int16)
<mask> go func() {
<mask> t, err := A.DelayTest(proxy, url)
<mask> if err != nil {
<mask> sigCh <- 0
<mask> }
<mask> sigCh <- t
<mask> }()
</s> Improve: `Dial` would reset proxy alive status </s> remove func selectFast(in chan interface{}) chan interface{} {
out := make(chan interface{})
go func() {
p, open := <-in
if open {
out <- p
}
close(out)
for range in {
}
}()
return out
}
</s> add </s> remove _, err := DelayTest(p, u.rawURL)
</s> add _, err := p.URLTest(u.rawURL) </s> remove // DelayTest get the delay for the specified URL
func DelayTest(proxy C.Proxy, url string) (t int16, err error) {
addr, err := urlToMetadata(url)
if err != nil {
return
}
start := time.Now()
instance, err := proxy.Dial(&addr)
if err != nil {
return
}
defer instance.Close()
transport := &http.Transport{
Dial: func(string, string) (net.Conn, error) {
return instance, nil
},
// from http.DefaultTransport
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
client := http.Client{Transport: transport}
resp, err := client.Get(url)
if err != nil {
return
}
resp.Body.Close()
t = int16(time.Since(start) / time.Millisecond)
return
}
</s> add </s> remove idx := 0
var proxy *proxy
for {
idx, proxy = f.findNextValidProxy(idx)
if proxy == nil {
break
}
adapter, err := proxy.RawProxy.Dial(metadata)
if err != nil {
proxy.Valid = false
idx++
continue
}
return adapter, err
}
return f.proxies[0].RawProxy.Dial(metadata)
</s> add proxy := f.findAliveProxy()
return proxy.Dial(metadata) </s> remove _, proxy := f.findNextValidProxy(0)
if proxy != nil {
return proxy.RawProxy.Name()
}
return f.proxies[0].RawProxy.Name()
</s> add proxy := f.findAliveProxy()
return proxy.Name() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/acf55a7f641cb6f522546397dcc15f4fba9359f1 | hub/route/proxies.go |
"sync" | <mask> "errors"
<mask> "net"
<mask> )
<mask>
<mask> // Pool is a implementation about fake ip generator without storage
<mask> type Pool struct {
<mask> max uint32
<mask> min uint32
</s> Fix: add mutex for fake ip pool | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad13ad8dbab82745e86fc3da89fcec3f71b7d2dd | component/fakeip/pool.go |
mux *sync.Mutex | <mask> type Pool struct {
<mask> max uint32
<mask> min uint32
<mask> offset uint32
<mask> }
<mask>
<mask> // Get return a new fake ip
<mask> func (p *Pool) Get() net.IP {
</s> Fix: add mutex for fake ip pool | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad13ad8dbab82745e86fc3da89fcec3f71b7d2dd | component/fakeip/pool.go |
p.mux.Lock()
defer p.mux.Unlock() | <mask>
<mask> // Get return a new fake ip
<mask> func (p *Pool) Get() net.IP {
<mask> ip := uintToIP(p.min + p.offset)
<mask> p.offset = (p.offset + 1) % (p.max - p.min)
<mask> return ip
<mask> }
<mask>
</s> Fix: add mutex for fake ip pool | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad13ad8dbab82745e86fc3da89fcec3f71b7d2dd | component/fakeip/pool.go |
mux: &sync.Mutex{}, | <mask> max := min + uint32(total)
<mask> return &Pool{
<mask> min: min,
<mask> max: max,
<mask> }, nil
<mask> }
</s> Fix: add mutex for fake ip pool | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad13ad8dbab82745e86fc3da89fcec3f71b7d2dd | component/fakeip/pool.go |
"sync" | <mask> "net/url"
<mask> "strings"
<mask> "time"
<mask>
<mask> "github.com/gorilla/websocket"
<mask> )
</s> Fix: vmess websocket udp crash | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad53b42a68715f390e851c0602f7c1fde13e2888 | component/vmess/websocket.go |
// https://godoc.org/github.com/gorilla/websocket#hdr-Concurrency
rMux sync.Mutex
wMux sync.Mutex | <mask> conn *websocket.Conn
<mask> reader io.Reader
<mask> remoteAddr net.Addr
<mask> }
<mask>
<mask> type WebsocketConfig struct {
<mask> Host string
</s> Fix: vmess websocket udp crash | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad53b42a68715f390e851c0602f7c1fde13e2888 | component/vmess/websocket.go |
wsc.rMux.Lock()
defer wsc.rMux.Unlock() | <mask> }
<mask>
<mask> // Read implements net.Conn.Read()
<mask> func (wsc *websocketConn) Read(b []byte) (int, error) {
<mask> for {
<mask> reader, err := wsc.getReader()
<mask> if err != nil {
<mask> return 0, err
<mask> }
<mask>
</s> Fix: vmess websocket udp crash | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad53b42a68715f390e851c0602f7c1fde13e2888 | component/vmess/websocket.go |
wsc.wMux.Lock()
defer wsc.wMux.Unlock() | <mask>
<mask> // Write implements io.Writer.
<mask> func (wsc *websocketConn) Write(b []byte) (int, error) {
<mask> if err := wsc.conn.WriteMessage(websocket.BinaryMessage, b); err != nil {
<mask> return 0, err
<mask> }
<mask> return len(b), nil
</s> Fix: vmess websocket udp crash | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ad53b42a68715f390e851c0602f7c1fde13e2888 | component/vmess/websocket.go |
if parseErr == R.ErrPlatformNotSupport {
log.Warnln("Rules[%d] [%s] don't support current OS, skip", idx, line)
continue
} | <mask>
<mask> parsed, parseErr := R.ParseRule(rule[0], payload, target, params)
<mask> if parseErr != nil {
<mask> return nil, fmt.Errorf("Rules[%d] [%s] error: %s", idx, line, parseErr.Error())
<mask> }
<mask>
<mask> rules = append(rules, parsed)
<mask> }
<mask>
</s> Feature: support PROCESS-NAME on macOS </s> remove errPayload = errors.New("payload error")
errParams = errors.New("params error")
</s> add errPayload = errors.New("payload error")
errParams = errors.New("params error")
ErrPlatformNotSupport = errors.New("not support on this platform") | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ae1e1dc9f6f2a920b1fc37c552c3763ffa86fa92 | config/config.go |
Process | <mask> IPCIDR
<mask> SrcIPCIDR
<mask> SrcPort
<mask> DstPort
<mask> MATCH
<mask> )
<mask>
<mask> type RuleType int
<mask>
<mask> func (rt RuleType) String() string {
</s> Feature: support PROCESS-NAME on macOS </s> remove errPayload = errors.New("payload error")
errParams = errors.New("params error")
</s> add errPayload = errors.New("payload error")
errParams = errors.New("params error")
ErrPlatformNotSupport = errors.New("not support on this platform") | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ae1e1dc9f6f2a920b1fc37c552c3763ffa86fa92 | constant/rule.go |
case Process:
return "Process" | <mask> case SrcPort:
<mask> return "SrcPort"
<mask> case DstPort:
<mask> return "DstPort"
<mask> case MATCH:
<mask> return "Match"
<mask> default:
<mask> return "Unknown"
<mask> }
<mask> }
</s> Feature: support PROCESS-NAME on macOS </s> remove errPayload = errors.New("payload error")
errParams = errors.New("params error")
</s> add errPayload = errors.New("payload error")
errParams = errors.New("params error")
ErrPlatformNotSupport = errors.New("not support on this platform") | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ae1e1dc9f6f2a920b1fc37c552c3763ffa86fa92 | constant/rule.go |
errPayload = errors.New("payload error")
errParams = errors.New("params error")
ErrPlatformNotSupport = errors.New("not support on this platform") | <mask> "errors"
<mask> )
<mask>
<mask> var (
<mask> errPayload = errors.New("payload error")
<mask> errParams = errors.New("params error")
<mask>
<mask> noResolve = "no-resolve"
<mask> )
<mask>
<mask> func HasNoResolve(params []string) bool {
</s> Feature: support PROCESS-NAME on macOS | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ae1e1dc9f6f2a920b1fc37c552c3763ffa86fa92 | rules/base.go |
case "PROCESS-NAME":
parsed, parseErr = NewProcess(payload, target) | <mask> case "SRC-PORT":
<mask> parsed, parseErr = NewPort(payload, target, true)
<mask> case "DST-PORT":
<mask> parsed, parseErr = NewPort(payload, target, false)
<mask> case "MATCH":
<mask> parsed = NewMatch(target)
<mask> default:
<mask> parseErr = fmt.Errorf("unsupported rule type %s", tp)
<mask> }
</s> Feature: support PROCESS-NAME on macOS </s> remove errPayload = errors.New("payload error")
errParams = errors.New("params error")
</s> add errPayload = errors.New("payload error")
errParams = errors.New("params error")
ErrPlatformNotSupport = errors.New("not support on this platform") | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/ae1e1dc9f6f2a920b1fc37c552c3763ffa86fa92 | rules/parser.go |
ch := make(chan log.Event, 1024) | <mask> render.Status(r, http.StatusOK)
<mask> }
<mask>
<mask> sub := log.Subscribe()
<mask> defer log.UnSubscribe(sub)
<mask> buf := &bytes.Buffer{}
<mask>
<mask> go func() {
</s> Fix: make log api unblocked </s> remove var err error
for elm := range sub {
buf.Reset()
log := elm.(*log.Event)
</s> add go func() {
for elm := range sub {
log := elm.(log.Event)
select {
case ch <- log:
default:
}
}
close(ch)
}()
for log := range ch { </s> remove func print(data *Event) {
</s> add func print(data Event) { </s> remove func newLog(logLevel LogLevel, format string, v ...any) *Event {
return &Event{
</s> add func newLog(logLevel LogLevel, format string, v ...any) Event {
return Event{ | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/aef4dd3fe78bea7babc7b9b4dd2a1545ee504542 | hub/route/server.go |
go func() {
for elm := range sub {
log := elm.(log.Event)
select {
case ch <- log:
default:
}
}
close(ch)
}()
for log := range ch { | <mask>
<mask> sub := log.Subscribe()
<mask> defer log.UnSubscribe(sub)
<mask> buf := &bytes.Buffer{}
<mask> var err error
<mask> for elm := range sub {
<mask> buf.Reset()
<mask> log := elm.(*log.Event)
<mask> if log.LogLevel < level {
<mask> continue
<mask> }
<mask>
<mask> if err := json.NewEncoder(buf).Encode(Log{
</s> Fix: make log api unblocked </s> remove func print(data *Event) {
</s> add func print(data Event) { </s> remove func newLog(logLevel LogLevel, format string, v ...any) *Event {
return &Event{
</s> add func newLog(logLevel LogLevel, format string, v ...any) Event {
return Event{ | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/aef4dd3fe78bea7babc7b9b4dd2a1545ee504542 | hub/route/server.go |
buf.Reset() | <mask> if log.LogLevel < level {
<mask> continue
<mask> }
<mask>
<mask> if err := json.NewEncoder(buf).Encode(Log{
<mask> Type: log.Type(),
<mask> Payload: log.Payload,
</s> Fix: make log api unblocked </s> remove var err error
for elm := range sub {
buf.Reset()
log := elm.(*log.Event)
</s> add go func() {
for elm := range sub {
log := elm.(log.Event)
select {
case ch <- log:
default:
}
}
close(ch)
}()
for log := range ch { </s> remove func print(data *Event) {
</s> add func print(data Event) { </s> remove func newLog(logLevel LogLevel, format string, v ...any) *Event {
return &Event{
</s> add func newLog(logLevel LogLevel, format string, v ...any) Event {
return Event{ | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/aef4dd3fe78bea7babc7b9b4dd2a1545ee504542 | hub/route/server.go |
var err error | <mask> }); err != nil {
<mask> break
<mask> }
<mask>
<mask> if wsConn == nil {
<mask> _, err = w.Write(buf.Bytes())
<mask> w.(http.Flusher).Flush()
<mask> } else {
<mask> err = wsConn.WriteMessage(websocket.TextMessage, buf.Bytes())
</s> Fix: make log api unblocked </s> remove func print(data *Event) {
</s> add func print(data Event) { </s> remove var err error
for elm := range sub {
buf.Reset()
log := elm.(*log.Event)
</s> add go func() {
for elm := range sub {
log := elm.(log.Event)
select {
case ch <- log:
default:
}
}
close(ch)
}()
for log := range ch { </s> remove func newLog(logLevel LogLevel, format string, v ...any) *Event {
return &Event{
</s> add func newLog(logLevel LogLevel, format string, v ...any) Event {
return Event{ | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/aef4dd3fe78bea7babc7b9b4dd2a1545ee504542 | hub/route/server.go |
func print(data Event) { | <mask> func SetLevel(newLevel LogLevel) {
<mask> level = newLevel
<mask> }
<mask>
<mask> func print(data *Event) {
<mask> if data.LogLevel < level {
<mask> return
<mask> }
<mask>
<mask> switch data.LogLevel {
</s> Fix: make log api unblocked </s> remove func newLog(logLevel LogLevel, format string, v ...any) *Event {
return &Event{
</s> add func newLog(logLevel LogLevel, format string, v ...any) Event {
return Event{ </s> remove var err error
for elm := range sub {
buf.Reset()
log := elm.(*log.Event)
</s> add go func() {
for elm := range sub {
log := elm.(log.Event)
select {
case ch <- log:
default:
}
}
close(ch)
}()
for log := range ch { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/aef4dd3fe78bea7babc7b9b4dd2a1545ee504542 | log/log.go |
func newLog(logLevel LogLevel, format string, v ...any) Event {
return Event{ | <mask> log.Debugln(data.Payload)
<mask> }
<mask> }
<mask>
<mask> func newLog(logLevel LogLevel, format string, v ...any) *Event {
<mask> return &Event{
<mask> LogLevel: logLevel,
<mask> Payload: fmt.Sprintf(format, v...),
<mask> }
<mask> }
</s> Fix: make log api unblocked </s> remove func print(data *Event) {
</s> add func print(data Event) { </s> remove var err error
for elm := range sub {
buf.Reset()
log := elm.(*log.Event)
</s> add go func() {
for elm := range sub {
log := elm.(log.Event)
select {
case ch <- log:
default:
}
}
close(ch)
}()
for log := range ch { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/aef4dd3fe78bea7babc7b9b4dd2a1545ee504542 | log/log.go |
hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) | <mask> }
<mask>
<mask> // if Use not empty, drop health check options
<mask> if len(groupOption.Use) != 0 {
<mask> pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> providers = append(providers, pd)
</s> Feature: make every provider support health check </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove healthOption := &provider.HealthCheckOption{
URL: groupOption.URL,
Interval: uint(groupOption.Interval),
}
pd, err := provider.NewCompatibleProvier(groupName, ps, healthOption)
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove var healthCheckOption *HealthCheckOption
</s> add var hcInterval uint = 0 </s> remove 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)
</s> add if hc.auto() {
go hc.process() </s> remove if cp.healthCheck != nil {
cp.healthCheck.close()
}
</s> add cp.healthCheck.close() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/outboundgroup/parser.go |
hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) | <mask> providers = append(providers, pd)
<mask> } else {
<mask> // select don't need health check
<mask> if groupOption.Type == "select" {
<mask> pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> providers = append(providers, pd)
</s> Feature: make every provider support health check </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove healthOption := &provider.HealthCheckOption{
URL: groupOption.URL,
Interval: uint(groupOption.Interval),
}
pd, err := provider.NewCompatibleProvier(groupName, ps, healthOption)
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove 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)
</s> add if hc.auto() {
go hc.process() </s> remove var healthCheckOption *HealthCheckOption
</s> add var hcInterval uint = 0 </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/outboundgroup/parser.go |
hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) | <mask> if groupOption.URL == "" || groupOption.Interval == 0 {
<mask> return nil, errMissHealthCheck
<mask> }
<mask>
<mask> healthOption := &provider.HealthCheckOption{
<mask> URL: groupOption.URL,
<mask> Interval: uint(groupOption.Interval),
<mask> }
<mask> pd, err := provider.NewCompatibleProvier(groupName, ps, healthOption)
<mask> if err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> providers = append(providers, pd)
</s> Feature: make every provider support health check </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove var healthCheckOption *HealthCheckOption
</s> add var hcInterval uint = 0 </s> remove 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)
</s> add if hc.auto() {
go hc.process() </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/outboundgroup/parser.go |
type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} | <mask> URL string
<mask> Interval uint
<mask> }
<mask>
<mask> type healthCheck struct {
<mask> url string
<mask> proxies []C.Proxy
<mask> ticker *time.Ticker
<mask> }
<mask>
<mask> func (hc *healthCheck) process() {
<mask> go hc.check()
<mask> for range hc.ticker.C {
</s> Feature: make every provider support health check </s> remove func (hc *healthCheck) process() {
</s> add func (hc *HealthCheck) process() {
ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
</s> remove for range hc.ticker.C {
hc.check()
</s> add for {
select {
case <-ticker.C:
hc.check()
case <-hc.done:
ticker.Stop()
return
} </s> remove healthCheck *healthCheck
</s> add healthCheck *HealthCheck </s> remove name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *healthCheck
healthCheckOption *HealthCheckOption
ticker *time.Ticker
updatedAt *time.Time
// mux for avoiding creating new goroutines when pulling
mux sync.Mutex
</s> add name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *HealthCheck
ticker *time.Ticker
updatedAt *time.Time </s> remove func (hc *healthCheck) check() {
</s> add func (hc *HealthCheck) setProxy(proxies []C.Proxy) {
hc.proxies = proxies
}
func (hc *HealthCheck) auto() bool {
return hc.interval != 0
}
func (hc *HealthCheck) check() { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/healthcheck.go |
func (hc *HealthCheck) process() {
ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
| <mask> proxies []C.Proxy
<mask> ticker *time.Ticker
<mask> }
<mask>
<mask> func (hc *healthCheck) process() {
<mask> go hc.check()
<mask> for range hc.ticker.C {
<mask> hc.check()
<mask> }
<mask> }
</s> Feature: make every provider support health check </s> remove for range hc.ticker.C {
hc.check()
</s> add for {
select {
case <-ticker.C:
hc.check()
case <-hc.done:
ticker.Stop()
return
} </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove func (hc *healthCheck) check() {
</s> add func (hc *HealthCheck) setProxy(proxies []C.Proxy) {
hc.proxies = proxies
}
func (hc *HealthCheck) auto() bool {
return hc.interval != 0
}
func (hc *HealthCheck) check() { </s> remove name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *healthCheck
healthCheckOption *HealthCheckOption
ticker *time.Ticker
updatedAt *time.Time
// mux for avoiding creating new goroutines when pulling
mux sync.Mutex
</s> add name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *HealthCheck
ticker *time.Ticker
updatedAt *time.Time </s> remove func (hc *healthCheck) close() {
hc.ticker.Stop()
</s> add func (hc *HealthCheck) close() {
hc.done <- struct{}{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/healthcheck.go |
for {
select {
case <-ticker.C:
hc.check()
case <-hc.done:
ticker.Stop()
return
} | <mask> }
<mask>
<mask> func (hc *healthCheck) process() {
<mask> go hc.check()
<mask> for range hc.ticker.C {
<mask> hc.check()
<mask> }
<mask> }
<mask>
<mask> func (hc *healthCheck) check() {
<mask> ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
</s> Feature: make every provider support health check </s> remove func (hc *healthCheck) check() {
</s> add func (hc *HealthCheck) setProxy(proxies []C.Proxy) {
hc.proxies = proxies
}
func (hc *HealthCheck) auto() bool {
return hc.interval != 0
}
func (hc *HealthCheck) check() { </s> remove func (hc *healthCheck) process() {
</s> add func (hc *HealthCheck) process() {
ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
</s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove func (hc *healthCheck) close() {
hc.ticker.Stop()
</s> add func (hc *HealthCheck) close() {
hc.done <- struct{}{} </s> remove func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
ticker := time.NewTicker(time.Duration(interval) * time.Second)
return &healthCheck{
proxies: proxies,
url: url,
ticker: ticker,
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
return &HealthCheck{
proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/healthcheck.go |
func (hc *HealthCheck) setProxy(proxies []C.Proxy) {
hc.proxies = proxies
}
func (hc *HealthCheck) auto() bool {
return hc.interval != 0
}
func (hc *HealthCheck) check() { | <mask> hc.check()
<mask> }
<mask> }
<mask>
<mask> func (hc *healthCheck) check() {
<mask> ctx, cancel := context.WithTimeout(context.Background(), defaultURLTestTimeout)
<mask> for _, proxy := range hc.proxies {
<mask> go proxy.URLTest(ctx, hc.url)
<mask> }
<mask>
</s> Feature: make every provider support health check </s> remove for range hc.ticker.C {
hc.check()
</s> add for {
select {
case <-ticker.C:
hc.check()
case <-hc.done:
ticker.Stop()
return
} </s> remove func (hc *healthCheck) process() {
</s> add func (hc *HealthCheck) process() {
ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
</s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove func (hc *healthCheck) close() {
hc.ticker.Stop()
</s> add func (hc *HealthCheck) close() {
hc.done <- struct{}{} </s> remove 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)
</s> add if hc.auto() {
go hc.process() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/healthcheck.go |
func (hc *HealthCheck) close() {
hc.done <- struct{}{} | <mask> <-ctx.Done()
<mask> cancel()
<mask> }
<mask>
<mask> func (hc *healthCheck) close() {
<mask> hc.ticker.Stop()
<mask> }
<mask>
<mask> func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
<mask> ticker := time.NewTicker(time.Duration(interval) * time.Second)
<mask> return &healthCheck{
</s> Feature: make every provider support health check </s> remove func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
ticker := time.NewTicker(time.Duration(interval) * time.Second)
return &healthCheck{
proxies: proxies,
url: url,
ticker: ticker,
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
return &HealthCheck{
proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1), </s> remove func (hc *healthCheck) process() {
</s> add func (hc *HealthCheck) process() {
ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
</s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/healthcheck.go |
func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
return &HealthCheck{
proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1), | <mask> func (hc *healthCheck) close() {
<mask> hc.ticker.Stop()
<mask> }
<mask>
<mask> func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
<mask> ticker := time.NewTicker(time.Duration(interval) * time.Second)
<mask> return &healthCheck{
<mask> proxies: proxies,
<mask> url: url,
<mask> ticker: ticker,
<mask> }
<mask> }
</s> Feature: make every provider support health check </s> remove func (hc *healthCheck) close() {
hc.ticker.Stop()
</s> add func (hc *HealthCheck) close() {
hc.done <- struct{}{} </s> remove func (hc *healthCheck) process() {
</s> add func (hc *HealthCheck) process() {
ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
</s> remove name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheckOption: option,
ticker: ticker,
</s> add name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheck: hc,
ticker: ticker, </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/healthcheck.go |
var hcInterval uint = 0 | <mask> if err := decoder.Decode(mapping, schema); err != nil {
<mask> return nil, err
<mask> }
<mask>
<mask> var healthCheckOption *HealthCheckOption
<mask> if schema.HealthCheck.Enable {
<mask> healthCheckOption = &HealthCheckOption{
<mask> URL: schema.HealthCheck.URL,
<mask> Interval: uint(schema.HealthCheck.Interval),
<mask> }
</s> Feature: make every provider support health check </s> remove healthCheckOption = &HealthCheckOption{
URL: schema.HealthCheck.URL,
Interval: uint(schema.HealthCheck.Interval),
}
</s> add hcInterval = uint(schema.HealthCheck.Interval) </s> remove healthOption := &provider.HealthCheckOption{
URL: groupOption.URL,
Interval: uint(groupOption.Interval),
}
pd, err := provider.NewCompatibleProvier(groupName, ps, healthOption)
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove 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)
</s> add if hc.auto() {
go hc.process() </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/parser.go |
hcInterval = uint(schema.HealthCheck.Interval) | <mask> }
<mask>
<mask> var healthCheckOption *HealthCheckOption
<mask> if schema.HealthCheck.Enable {
<mask> healthCheckOption = &HealthCheckOption{
<mask> URL: schema.HealthCheck.URL,
<mask> Interval: uint(schema.HealthCheck.Interval),
<mask> }
<mask> }
<mask>
<mask> path := C.Path.Reslove(schema.Path)
<mask>
<mask> var vehicle Vehicle
</s> Feature: make every provider support health check </s> remove var healthCheckOption *HealthCheckOption
</s> add var hcInterval uint = 0 </s> remove name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *healthCheck
healthCheckOption *HealthCheckOption
ticker *time.Ticker
updatedAt *time.Time
// mux for avoiding creating new goroutines when pulling
mux sync.Mutex
</s> add name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *HealthCheck
ticker *time.Ticker
updatedAt *time.Time </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove 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()
}
</s> add pp.healthCheck.setProxy(proxies)
go pp.healthCheck.check() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/parser.go |
hc := NewHealthCheck([]C.Proxy{}, schema.HealthCheck.URL, hcInterval) | <mask> hcInterval = uint(schema.HealthCheck.Interval)
<mask> }
<mask>
<mask> path := C.Path.Reslove(schema.Path)
<mask>
<mask> var vehicle Vehicle
<mask> switch schema.Type {
</s> Feature: make every provider support health check </s> remove healthCheckOption = &HealthCheckOption{
URL: schema.HealthCheck.URL,
Interval: uint(schema.HealthCheck.Interval),
}
</s> add hcInterval = uint(schema.HealthCheck.Interval) </s> remove var healthCheckOption *HealthCheckOption
</s> add var hcInterval uint = 0 </s> remove name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *healthCheck
healthCheckOption *HealthCheckOption
ticker *time.Ticker
updatedAt *time.Time
// mux for avoiding creating new goroutines when pulling
mux sync.Mutex
</s> add name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *HealthCheck
ticker *time.Ticker
updatedAt *time.Time </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove 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()
}
</s> add pp.healthCheck.setProxy(proxies)
go pp.healthCheck.check() | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/parser.go |
return NewProxySetProvider(name, interval, vehicle, hc), nil | <mask> return nil, fmt.Errorf("%w: %s", errVehicleType, schema.Type)
<mask> }
<mask>
<mask> interval := time.Duration(uint(schema.Interval)) * time.Second
<mask> return NewProxySetProvider(name, interval, vehicle, healthCheckOption), nil
<mask> }
</s> Feature: make every provider support health check </s> remove func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
ticker := time.NewTicker(time.Duration(interval) * time.Second)
return &healthCheck{
proxies: proxies,
url: url,
ticker: ticker,
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
return &HealthCheck{
proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1), </s> remove name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheckOption: option,
ticker: ticker,
</s> add name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheck: hc,
ticker: ticker, </s> remove func (hc *healthCheck) close() {
hc.ticker.Stop()
</s> add func (hc *HealthCheck) close() {
hc.done <- struct{}{} </s> remove 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)
</s> add if hc.auto() {
go hc.process() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/parser.go |
<mask> "encoding/json"
<mask> "errors"
<mask> "fmt"
<mask> "io/ioutil"
<mask> "net/url"
<mask> "os"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/outbound"
</s> Feature: make every provider support health check </s> remove "sync"
</s> add </s> remove return NewProxySetProvider(name, interval, vehicle, healthCheckOption), nil
</s> add return NewProxySetProvider(name, interval, vehicle, hc), nil </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove healthOption := &provider.HealthCheckOption{
URL: groupOption.URL,
Interval: uint(groupOption.Interval),
}
pd, err := provider.NewCompatibleProvier(groupName, ps, healthOption)
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go | |
<mask> "fmt"
<mask> "io/ioutil"
<mask> "net/url"
<mask> "os"
<mask> "sync"
<mask> "time"
<mask>
<mask> "github.com/Dreamacro/clash/adapters/outbound"
<mask> C "github.com/Dreamacro/clash/constant"
<mask> "github.com/Dreamacro/clash/log"
</s> Feature: make every provider support health check </s> remove "net/url"
</s> add </s> remove return NewProxySetProvider(name, interval, vehicle, healthCheckOption), nil
</s> add return NewProxySetProvider(name, interval, vehicle, hc), nil </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove healthOption := &provider.HealthCheckOption{
URL: groupOption.URL,
Interval: uint(groupOption.Interval),
}
pd, err := provider.NewCompatibleProvier(groupName, ps, healthOption)
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go | |
name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *HealthCheck
ticker *time.Ticker
updatedAt *time.Time | <mask> Proxies []map[string]interface{} `yaml:"proxies"`
<mask> }
<mask>
<mask> type ProxySetProvider struct {
<mask> name string
<mask> vehicle Vehicle
<mask> hash [16]byte
<mask> proxies []C.Proxy
<mask> healthCheck *healthCheck
<mask> healthCheckOption *HealthCheckOption
<mask> ticker *time.Ticker
<mask> updatedAt *time.Time
<mask>
<mask> // mux for avoiding creating new goroutines when pulling
<mask> mux sync.Mutex
<mask> }
<mask>
<mask> func (pp *ProxySetProvider) MarshalJSON() ([]byte, error) {
<mask> return json.Marshal(map[string]interface{}{
<mask> "name": pp.Name(),
</s> Feature: make every provider support health check </s> remove healthCheck *healthCheck
</s> add healthCheck *HealthCheck </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove healthCheckOption = &HealthCheckOption{
URL: schema.HealthCheck.URL,
Interval: uint(schema.HealthCheck.Interval),
}
</s> add hcInterval = uint(schema.HealthCheck.Interval) </s> remove func (hc *healthCheck) process() {
</s> add func (hc *HealthCheck) process() {
ticker := time.NewTicker(time.Duration(hc.interval) * time.Second)
</s> remove name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheckOption: option,
ticker: ticker,
</s> add name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheck: hc,
ticker: ticker, | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
pp.healthCheck.check() | <mask> return nil
<mask> }
<mask>
<mask> func (pp *ProxySetProvider) HealthCheck() {
<mask> pp.mux.Lock()
<mask> defer pp.mux.Unlock()
<mask> if pp.healthCheck != nil {
<mask> pp.healthCheck.check()
<mask> }
<mask> }
<mask>
<mask> func (pp *ProxySetProvider) Update() error {
<mask> return pp.pull()
<mask> }
</s> Feature: make every provider support health check </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.close()
pp.healthCheck = nil
}
</s> add pp.healthCheck.close() </s> remove 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()
}
</s> add pp.healthCheck.setProxy(proxies)
go pp.healthCheck.check() </s> remove if cp.healthCheck != nil {
cp.healthCheck.check()
}
</s> add cp.healthCheck.check() </s> remove if cp.healthCheck != nil {
cp.healthCheck.close()
}
</s> add cp.healthCheck.close() </s> remove if cp.healthCheck != nil {
go cp.healthCheck.process()
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
pp.healthCheck.close() | <mask> return pp.pull()
<mask> }
<mask>
<mask> func (pp *ProxySetProvider) Destroy() error {
<mask> pp.mux.Lock()
<mask> defer pp.mux.Unlock()
<mask> if pp.healthCheck != nil {
<mask> pp.healthCheck.close()
<mask> pp.healthCheck = nil
<mask> }
<mask>
<mask> if pp.ticker != nil {
<mask> pp.ticker.Stop()
<mask> }
<mask>
</s> Feature: make every provider support health check </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.check()
}
</s> add pp.healthCheck.check() </s> remove 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()
}
</s> add pp.healthCheck.setProxy(proxies)
go pp.healthCheck.check() </s> remove if cp.healthCheck != nil {
cp.healthCheck.close()
}
</s> add cp.healthCheck.close() </s> remove if cp.healthCheck != nil {
cp.healthCheck.check()
}
</s> add cp.healthCheck.check() </s> remove if cp.healthCheck != nil {
go cp.healthCheck.process()
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
pp.healthCheck.setProxy(proxies)
go pp.healthCheck.check() | <mask> }
<mask>
<mask> func (pp *ProxySetProvider) setProxies(proxies []C.Proxy) {
<mask> pp.proxies = proxies
<mask> if pp.healthCheckOption != nil {
<mask> pp.mux.Lock()
<mask> if pp.healthCheck != nil {
<mask> pp.healthCheck.close()
<mask> }
<mask> pp.healthCheck = newHealthCheck(proxies, pp.healthCheckOption.URL, pp.healthCheckOption.Interval)
<mask> go pp.healthCheck.process()
<mask> pp.mux.Unlock()
<mask> }
<mask> }
<mask>
<mask> func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
<mask> var ticker *time.Ticker
<mask> if interval != 0 {
</s> Feature: make every provider support health check </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.close()
pp.healthCheck = nil
}
</s> add pp.healthCheck.close() </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.check()
}
</s> add pp.healthCheck.check() </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { </s> remove 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)
</s> add if hc.auto() {
go hc.process() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider { | <mask> pp.mux.Unlock()
<mask> }
<mask> }
<mask>
<mask> func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
<mask> var ticker *time.Ticker
<mask> if interval != 0 {
<mask> ticker = time.NewTicker(interval)
<mask> }
<mask>
</s> Feature: make every provider support health check </s> remove 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()
}
</s> add pp.healthCheck.setProxy(proxies)
go pp.healthCheck.check() </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { </s> remove func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
ticker := time.NewTicker(time.Duration(interval) * time.Second)
return &healthCheck{
proxies: proxies,
url: url,
ticker: ticker,
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
return &HealthCheck{
proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1), </s> remove func (hc *healthCheck) close() {
hc.ticker.Stop()
</s> add func (hc *HealthCheck) close() {
hc.done <- struct{}{} </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
if hc.auto() {
go hc.process()
}
| <mask> ticker = time.NewTicker(interval)
<mask> }
<mask>
<mask> return &ProxySetProvider{
<mask> name: name,
<mask> vehicle: vehicle,
<mask> proxies: []C.Proxy{},
<mask> healthCheck: hc,
</s> Feature: make every provider support health check </s> remove name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheckOption: option,
ticker: ticker,
</s> add name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheck: hc,
ticker: ticker, </s> remove 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)
</s> add if hc.auto() {
go hc.process() </s> remove return NewProxySetProvider(name, interval, vehicle, healthCheckOption), nil
</s> add return NewProxySetProvider(name, interval, vehicle, hc), nil </s> remove func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
ticker := time.NewTicker(time.Duration(interval) * time.Second)
return &healthCheck{
proxies: proxies,
url: url,
ticker: ticker,
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
return &HealthCheck{
proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1), </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider { | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheck: hc,
ticker: ticker, | <mask> ticker = time.NewTicker(interval)
<mask> }
<mask>
<mask> return &ProxySetProvider{
<mask> name: name,
<mask> vehicle: vehicle,
<mask> proxies: []C.Proxy{},
<mask> healthCheckOption: option,
<mask> ticker: ticker,
<mask> }
<mask> }
<mask>
<mask> type CompatibleProvier struct {
<mask> name string
</s> Feature: make every provider support health check </s> remove healthCheck *healthCheck
</s> add healthCheck *HealthCheck </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove func newHealthCheck(proxies []C.Proxy, url string, interval uint) *healthCheck {
ticker := time.NewTicker(time.Duration(interval) * time.Second)
return &healthCheck{
proxies: proxies,
url: url,
ticker: ticker,
</s> add func NewHealthCheck(proxies []C.Proxy, url string, interval uint) *HealthCheck {
return &HealthCheck{
proxies: proxies,
url: url,
interval: interval,
done: make(chan struct{}, 1), </s> remove name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *healthCheck
healthCheckOption *HealthCheckOption
ticker *time.Ticker
updatedAt *time.Time
// mux for avoiding creating new goroutines when pulling
mux sync.Mutex
</s> add name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *HealthCheck
ticker *time.Ticker
updatedAt *time.Time | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
healthCheck *HealthCheck | <mask> }
<mask>
<mask> type CompatibleProvier struct {
<mask> name string
<mask> healthCheck *healthCheck
<mask> proxies []C.Proxy
<mask> }
<mask>
<mask> func (cp *CompatibleProvier) MarshalJSON() ([]byte, error) {
<mask> return json.Marshal(map[string]interface{}{
</s> Feature: make every provider support health check </s> remove name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *healthCheck
healthCheckOption *HealthCheckOption
ticker *time.Ticker
updatedAt *time.Time
// mux for avoiding creating new goroutines when pulling
mux sync.Mutex
</s> add name string
vehicle Vehicle
hash [16]byte
proxies []C.Proxy
healthCheck *HealthCheck
ticker *time.Ticker
updatedAt *time.Time </s> remove type healthCheck struct {
url string
proxies []C.Proxy
ticker *time.Ticker
</s> add type HealthCheck struct {
url string
proxies []C.Proxy
interval uint
done chan struct{} </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { </s> remove name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheckOption: option,
ticker: ticker,
</s> add name: name,
vehicle: vehicle,
proxies: []C.Proxy{},
healthCheck: hc,
ticker: ticker, </s> remove if cp.healthCheck != nil {
cp.healthCheck.check()
}
</s> add cp.healthCheck.check() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
cp.healthCheck.close() | <mask> return nil
<mask> }
<mask>
<mask> func (cp *CompatibleProvier) Destroy() error {
<mask> if cp.healthCheck != nil {
<mask> cp.healthCheck.close()
<mask> }
<mask> return nil
<mask> }
<mask>
<mask> func (cp *CompatibleProvier) HealthCheck() {
<mask> if cp.healthCheck != nil {
</s> Feature: make every provider support health check </s> remove if cp.healthCheck != nil {
cp.healthCheck.check()
}
</s> add cp.healthCheck.check() </s> remove if cp.healthCheck != nil {
go cp.healthCheck.process()
}
</s> add </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.check()
}
</s> add pp.healthCheck.check() </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.close()
pp.healthCheck = nil
}
</s> add pp.healthCheck.close() </s> remove healthCheck *healthCheck
</s> add healthCheck *HealthCheck | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
cp.healthCheck.check() | <mask> return nil
<mask> }
<mask>
<mask> func (cp *CompatibleProvier) HealthCheck() {
<mask> if cp.healthCheck != nil {
<mask> cp.healthCheck.check()
<mask> }
<mask> }
<mask>
<mask> func (cp *CompatibleProvier) Update() error {
<mask> return nil
<mask> }
</s> Feature: make every provider support health check </s> remove if cp.healthCheck != nil {
cp.healthCheck.close()
}
</s> add cp.healthCheck.close() </s> remove if cp.healthCheck != nil {
go cp.healthCheck.process()
}
</s> add </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.check()
}
</s> add pp.healthCheck.check() </s> remove healthCheck *healthCheck
</s> add healthCheck *HealthCheck </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
<mask> return nil
<mask> }
<mask>
<mask> func (cp *CompatibleProvier) Initial() error {
<mask> if cp.healthCheck != nil {
<mask> go cp.healthCheck.process()
<mask> }
<mask> return nil
<mask> }
<mask>
<mask> func (cp *CompatibleProvier) VehicleType() VehicleType {
<mask> return Compatible
</s> Feature: make every provider support health check </s> remove if cp.healthCheck != nil {
cp.healthCheck.close()
}
</s> add cp.healthCheck.close() </s> remove if cp.healthCheck != nil {
cp.healthCheck.check()
}
</s> add cp.healthCheck.check() </s> remove healthCheck *healthCheck
</s> add healthCheck *HealthCheck </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { </s> remove pp.mux.Lock()
defer pp.mux.Unlock()
if pp.healthCheck != nil {
pp.healthCheck.check()
}
</s> add pp.healthCheck.check() | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go | |
func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { | <mask> func (cp *CompatibleProvier) Proxies() []C.Proxy {
<mask> return cp.proxies
<mask> }
<mask>
<mask> func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
<mask> if len(proxies) == 0 {
<mask> return nil, errors.New("Provider need one proxy at least")
<mask> }
<mask>
<mask> var hc *healthCheck
</s> Feature: make every provider support health check </s> remove 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)
</s> add if hc.auto() {
go hc.process() </s> remove healthCheck *healthCheck
</s> add healthCheck *HealthCheck </s> remove func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, option *HealthCheckOption) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, vehicle Vehicle, hc *HealthCheck) *ProxySetProvider { </s> remove if cp.healthCheck != nil {
cp.healthCheck.check()
}
</s> add cp.healthCheck.check() </s> remove if cp.healthCheck != nil {
go cp.healthCheck.process()
}
</s> add | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
if hc.auto() {
go hc.process() | <mask> if len(proxies) == 0 {
<mask> return nil, errors.New("Provider need one proxy at least")
<mask> }
<mask>
<mask> var hc *healthCheck
<mask> if option != nil {
<mask> if _, err := url.Parse(option.URL); err != nil {
<mask> return nil, fmt.Errorf("URL format error: %w", err)
<mask> }
<mask> hc = newHealthCheck(proxies, option.URL, option.Interval)
<mask> }
<mask>
<mask> return &CompatibleProvier{
<mask> name: name,
<mask> proxies: proxies,
</s> Feature: make every provider support health check </s> remove func NewCompatibleProvier(name string, proxies []C.Proxy, option *HealthCheckOption) (*CompatibleProvier, error) {
</s> add func NewCompatibleProvier(name string, proxies []C.Proxy, hc *HealthCheck) (*CompatibleProvier, error) { </s> remove healthOption := &provider.HealthCheckOption{
URL: groupOption.URL,
Interval: uint(groupOption.Interval),
}
pd, err := provider.NewCompatibleProvier(groupName, ps, healthOption)
</s> add hc := provider.NewHealthCheck(ps, groupOption.URL, uint(groupOption.Interval))
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) </s> remove var healthCheckOption *HealthCheckOption
</s> add var hcInterval uint = 0 </s> remove pd, err := provider.NewCompatibleProvier(groupName, ps, nil)
</s> add hc := provider.NewHealthCheck(ps, "", 0)
pd, err := provider.NewCompatibleProvier(groupName, ps, hc) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/af40048841994fa1b9776ccd4b5487b5c0f9355f | adapters/provider/provider.go |
Password: option.Password,
ALPN: option.ALPN,
ServerName: option.Server,
SkipCertVerify: option.SkipCertVerify,
ClientSessionCache: getClientSessionCache(), | <mask> func NewTrojan(option TrojanOption) (*Trojan, error) {
<mask> server := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
<mask>
<mask> tOption := &trojan.Option{
<mask> Password: option.Password,
<mask> ALPN: option.ALPN,
<mask> ServerName: option.Server,
<mask> SkipCertVerify: option.SkipCertVerify,
<mask> }
<mask>
<mask> if option.SNI != "" {
<mask> tOption.ServerName = option.SNI
<mask> }
</s> Improve: add session cache for trojan </s> remove Password string
ALPN []string
ServerName string
SkipCertVerify bool
</s> add Password string
ALPN []string
ServerName string
SkipCertVerify bool
ClientSessionCache tls.ClientSessionCache | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b06846610821a3d150ee1f338e8e22cbd250c45a | adapters/outbound/trojan.go |
Password string
ALPN []string
ServerName string
SkipCertVerify bool
ClientSessionCache tls.ClientSessionCache | <mask> CommandUDP byte = 3
<mask> )
<mask>
<mask> type Option struct {
<mask> Password string
<mask> ALPN []string
<mask> ServerName string
<mask> SkipCertVerify bool
<mask> }
<mask>
<mask> type Trojan struct {
<mask> option *Option
<mask> hexPassword []byte
</s> Improve: add session cache for trojan </s> remove Password: option.Password,
ALPN: option.ALPN,
ServerName: option.Server,
SkipCertVerify: option.SkipCertVerify,
</s> add Password: option.Password,
ALPN: option.ALPN,
ServerName: option.Server,
SkipCertVerify: option.SkipCertVerify,
ClientSessionCache: getClientSessionCache(), | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b06846610821a3d150ee1f338e8e22cbd250c45a | component/trojan/trojan.go |
ClientSessionCache: t.option.ClientSessionCache, | <mask> NextProtos: alpn,
<mask> MinVersion: tls.VersionTLS12,
<mask> InsecureSkipVerify: t.option.SkipCertVerify,
<mask> ServerName: t.option.ServerName,
<mask> }
<mask>
<mask> tlsConn := tls.Client(conn, tlsConfig)
<mask> if err := tlsConn.Handshake(); err != nil {
<mask> return nil, err
<mask> }
</s> Improve: add session cache for trojan </s> remove Password: option.Password,
ALPN: option.ALPN,
ServerName: option.Server,
SkipCertVerify: option.SkipCertVerify,
</s> add Password: option.Password,
ALPN: option.ALPN,
ServerName: option.Server,
SkipCertVerify: option.SkipCertVerify,
ClientSessionCache: getClientSessionCache(), </s> remove Password string
ALPN []string
ServerName string
SkipCertVerify bool
</s> add Password string
ALPN []string
ServerName string
SkipCertVerify bool
ClientSessionCache tls.ClientSessionCache | [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b06846610821a3d150ee1f338e8e22cbd250c45a | component/trojan/trojan.go |
user string
pass string | <mask> addr string
<mask> name string
<mask> tls bool
<mask> skipCertVerify bool
<mask> tlsConfig *tls.Config
<mask> }
<mask>
<mask> type Socks5Option struct {
</s> Feature: SOCKS5 authentication support (#34)
* Feature: socks5 auth support
* Chore: make code unified
* Fix: auth buffer length </s> remove // VER, CMD, RSV
_, err := rw.Write([]byte{5, 1, 0})
</s> add // VER, NMETHODS, METHODS
if len(ss.user) > 0 {
_, err = rw.Write([]byte{5, 1, 2})
} else {
_, err = rw.Write([]byte{5, 1, 0})
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b0e062dc7ce01e4c91300bc5a03845e3a731e25a | adapters/outbound/socks5.go |
UserName string `proxy:"username,omitempty"`
Password string `proxy:"password,omitempty"` | <mask> Server string `proxy:"server"`
<mask> Port int `proxy:"port"`
<mask> TLS bool `proxy:"tls,omitempty"`
<mask> SkipCertVerify bool `proxy:"skip-cert-verify,omitempty"`
<mask> }
<mask>
<mask> func (ss *Socks5) Name() string {
</s> Feature: SOCKS5 authentication support (#34)
* Feature: socks5 auth support
* Chore: make code unified
* Fix: auth buffer length </s> remove // VER, CMD, RSV
_, err := rw.Write([]byte{5, 1, 0})
</s> add // VER, NMETHODS, METHODS
if len(ss.user) > 0 {
_, err = rw.Write([]byte{5, 1, 2})
} else {
_, err = rw.Write([]byte{5, 1, 0})
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b0e062dc7ce01e4c91300bc5a03845e3a731e25a | adapters/outbound/socks5.go |
var err error | <mask>
<mask> func (ss *Socks5) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
<mask> buf := make([]byte, socks.MaxAddrLen)
<mask>
<mask> // VER, NMETHODS, METHODS
<mask> if len(ss.user) > 0 {
<mask> _, err = rw.Write([]byte{5, 1, 2})
</s> Feature: SOCKS5 authentication support (#34)
* Feature: socks5 auth support
* Chore: make code unified
* Fix: auth buffer length </s> remove // VER, CMD, RSV
_, err := rw.Write([]byte{5, 1, 0})
</s> add // VER, NMETHODS, METHODS
if len(ss.user) > 0 {
_, err = rw.Write([]byte{5, 1, 2})
} else {
_, err = rw.Write([]byte{5, 1, 0})
} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b0e062dc7ce01e4c91300bc5a03845e3a731e25a | adapters/outbound/socks5.go |
// VER, NMETHODS, METHODS
if len(ss.user) > 0 {
_, err = rw.Write([]byte{5, 1, 2})
} else {
_, err = rw.Write([]byte{5, 1, 0})
} | <mask>
<mask> func (ss *Socks5) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
<mask> buf := make([]byte, socks.MaxAddrLen)
<mask>
<mask> // VER, CMD, RSV
<mask> _, err := rw.Write([]byte{5, 1, 0})
<mask> if err != nil {
<mask> return err
<mask> }
<mask>
<mask> if _, err := io.ReadFull(rw, buf[:2]); err != nil {
</s> Feature: SOCKS5 authentication support (#34)
* Feature: socks5 auth support
* Chore: make code unified
* Fix: auth buffer length | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b0e062dc7ce01e4c91300bc5a03845e3a731e25a | adapters/outbound/socks5.go |
// VER, METHOD | <mask> return err
<mask> }
<mask>
<mask> if _, err := io.ReadFull(rw, buf[:2]); err != nil {
<mask> return err
<mask> }
<mask>
<mask> if buf[0] != 5 {
<mask> return errors.New("SOCKS version error")
</s> Feature: SOCKS5 authentication support (#34)
* Feature: socks5 auth support
* Chore: make code unified
* Fix: auth buffer length </s> remove // VER, CMD, RSV
_, err := rw.Write([]byte{5, 1, 0})
</s> add // VER, NMETHODS, METHODS
if len(ss.user) > 0 {
_, err = rw.Write([]byte{5, 1, 2})
} else {
_, err = rw.Write([]byte{5, 1, 0})
} | [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b0e062dc7ce01e4c91300bc5a03845e3a731e25a | adapters/outbound/socks5.go |
user: option.UserName,
pass: option.Password, | <mask> addr: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
<mask> name: option.Name,
<mask> tls: option.TLS,
<mask> skipCertVerify: option.SkipCertVerify,
<mask> tlsConfig: tlsConfig,
<mask> }
</s> Feature: SOCKS5 authentication support (#34)
* Feature: socks5 auth support
* Chore: make code unified
* Fix: auth buffer length </s> remove // VER, CMD, RSV
_, err := rw.Write([]byte{5, 1, 0})
</s> add // VER, NMETHODS, METHODS
if len(ss.user) > 0 {
_, err = rw.Write([]byte{5, 1, 2})
} else {
_, err = rw.Write([]byte{5, 1, 0})
} | [
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b0e062dc7ce01e4c91300bc5a03845e3a731e25a | adapters/outbound/socks5.go |
return NewProxySetProvider(name, interval, filter, vehicle, hc) | <mask> }
<mask>
<mask> interval := time.Duration(uint(schema.Interval)) * time.Second
<mask> filter := schema.Filter
<mask> return NewProxySetProvider(name, interval, filter, vehicle, hc), nil
<mask> }
</s> Fix: provider filter potential panic </s> remove func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
if _, err := regexp.Compile(filter); err != nil {
return nil, fmt.Errorf("invalid filter regex: %w", err)
}
</s> remove return wrapper
</s> add return wrapper, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
] | https://github.com/Dreamacro/clash/commit/b1bed7623dd47e33c974f4485567c9723859aad0 | adapter/provider/parser.go |
func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
if _, err := regexp.Compile(filter); err != nil {
return nil, fmt.Errorf("invalid filter regex: %w", err)
}
| <mask> pd.healthCheck.close()
<mask> pd.fetcher.Destroy()
<mask> }
<mask>
<mask> func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
<mask> if hc.auto() {
<mask> go hc.process()
<mask> }
<mask>
<mask> pd := &proxySetProvider{
</s> Fix: provider filter potential panic </s> remove return NewProxySetProvider(name, interval, filter, vehicle, hc), nil
</s> add return NewProxySetProvider(name, interval, filter, vehicle, hc) </s> remove return wrapper
</s> add return wrapper, nil | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b1bed7623dd47e33c974f4485567c9723859aad0 | adapter/provider/provider.go |
return wrapper, nil | <mask> pd.fetcher = fetcher
<mask>
<mask> wrapper := &ProxySetProvider{pd}
<mask> runtime.SetFinalizer(wrapper, stopProxyProvider)
<mask> return wrapper
<mask> }
<mask>
<mask> // for auto gc
<mask> type CompatibleProvider struct {
<mask> *compatibleProvider
</s> Fix: provider filter potential panic </s> remove func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) *ProxySetProvider {
</s> add func NewProxySetProvider(name string, interval time.Duration, filter string, vehicle types.Vehicle, hc *HealthCheck) (*ProxySetProvider, error) {
if _, err := regexp.Compile(filter); err != nil {
return nil, fmt.Errorf("invalid filter regex: %w", err)
}
</s> remove return NewProxySetProvider(name, interval, filter, vehicle, hc), nil
</s> add return NewProxySetProvider(name, interval, filter, vehicle, hc) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b1bed7623dd47e33c974f4485567c9723859aad0 | adapter/provider/provider.go |
name, err := getExecPathFromAddress(metadata) | <mask> func (ps *Process) Match(metadata *C.Metadata) bool {
<mask> key := fmt.Sprintf("%s:%s:%s", metadata.NetWork.String(), metadata.SrcIP.String(), metadata.SrcPort)
<mask> cached, hit := processCache.Get(key)
<mask> if !hit {
<mask> name, err := getExecPathFromAddress(metadata.SrcIP, metadata.SrcPort, metadata.NetWork == C.TCP)
<mask> if err != nil {
<mask> log.Debugln("[%s] getExecPathFromAddress error: %s", C.Process.String(), err.Error())
<mask> return false
<mask> }
<mask>
</s> Improve: simplify macOS process searching </s> remove func getExecPathFromAddress(ip net.IP, portStr string, isTCP bool) (string, error) {
port, err := strconv.Atoi(portStr)
</s> add func getExecPathFromAddress(metadata *C.Metadata) (string, error) {
ip := metadata.SrcIP
port, err := strconv.Atoi(metadata.SrcPort) </s> remove spath := "net.inet.tcp.pcblist_n"
if !isTCP {
</s> add var spath string
switch metadata.NetWork {
case C.TCP:
spath = "net.inet.tcp.pcblist_n"
case C.UDP: </s> remove var kinds uint32 = 0
so, inp := 0, 0
for i := roundUp8(xinpgenSize(buf)); i < uint32(len(buf)) && xinpgenSize(buf[i:]) > 24; i += roundUp8(xinpgenSize(buf[i:])) {
thisKind := binary.LittleEndian.Uint32(buf[i+4 : i+8])
if kinds&thisKind == 0 {
kinds |= thisKind
switch thisKind {
case 0x1:
// XSO_SOCKET
so = int(i)
case 0x10:
// XSO_INPCB
inp = int(i)
default:
break
}
}
// all blocks needed by tcp/udp
if (isTCP && kinds != 0x3f) || (!isTCP && kinds != 0x1f) {
continue
}
kinds = 0
// xsocket_n.xso_protocol
proto := binary.LittleEndian.Uint32(buf[so+36 : so+40])
if proto != syscall.IPPROTO_TCP && proto != syscall.IPPROTO_UDP {
continue
}
</s> add // from darwin-xnu/bsd/netinet/in_pcblist.c:get_pcblist_n
// size/offset are round up (aligned) to 8 bytes in darwin
// rup8(sizeof(xinpcb_n)) + rup8(sizeof(xsocket_n)) +
// 2 * rup8(sizeof(xsockbuf_n)) + rup8(sizeof(xsockstat_n))
itemSize := 384
if metadata.NetWork == C.TCP {
// rup8(sizeof(xtcpcb_n))
itemSize += 208
}
// skip the first and last xinpgen(24 bytes) block
for i := 24; i < len(buf)-24; i += itemSize {
// offset of xinpcb_n and xsocket_n
inp, so := i, i+104 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b1d9dfd6bf2b880cf21db4cbbdee46a179d12b7c | rules/process_darwin.go |
func getExecPathFromAddress(metadata *C.Metadata) (string, error) {
ip := metadata.SrcIP
port, err := strconv.Atoi(metadata.SrcPort) | <mask>
<mask> return filepath.Base(string(buf[:firstZero])), nil
<mask> }
<mask>
<mask> func getExecPathFromAddress(ip net.IP, portStr string, isTCP bool) (string, error) {
<mask> port, err := strconv.Atoi(portStr)
<mask> if err != nil {
<mask> return "", err
<mask> }
<mask>
<mask> spath := "net.inet.tcp.pcblist_n"
</s> Improve: simplify macOS process searching </s> remove spath := "net.inet.tcp.pcblist_n"
if !isTCP {
</s> add var spath string
switch metadata.NetWork {
case C.TCP:
spath = "net.inet.tcp.pcblist_n"
case C.UDP: </s> remove name, err := getExecPathFromAddress(metadata.SrcIP, metadata.SrcPort, metadata.NetWork == C.TCP)
</s> add name, err := getExecPathFromAddress(metadata) </s> remove func xinpgenSize(b []byte) uint32 {
return binary.LittleEndian.Uint32(b[:4])
}
func roundUp8(n uint32) uint32 {
if n == 0 {
return uint32(8)
}
return (n + 7) & ((^uint32(8)) + 1)
</s> add func readNativeUint32(b []byte) uint32 {
return *(*uint32)(unsafe.Pointer(&b[0])) | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b1d9dfd6bf2b880cf21db4cbbdee46a179d12b7c | rules/process_darwin.go |
var spath string
switch metadata.NetWork {
case C.TCP:
spath = "net.inet.tcp.pcblist_n"
case C.UDP: | <mask> if err != nil {
<mask> return "", err
<mask> }
<mask>
<mask> spath := "net.inet.tcp.pcblist_n"
<mask> if !isTCP {
<mask> spath = "net.inet.udp.pcblist_n"
<mask> }
<mask>
<mask> value, err := syscall.Sysctl(spath)
<mask> if err != nil {
</s> Improve: simplify macOS process searching </s> remove func getExecPathFromAddress(ip net.IP, portStr string, isTCP bool) (string, error) {
port, err := strconv.Atoi(portStr)
</s> add func getExecPathFromAddress(metadata *C.Metadata) (string, error) {
ip := metadata.SrcIP
port, err := strconv.Atoi(metadata.SrcPort) </s> remove name, err := getExecPathFromAddress(metadata.SrcIP, metadata.SrcPort, metadata.NetWork == C.TCP)
</s> add name, err := getExecPathFromAddress(metadata) </s> remove var kinds uint32 = 0
so, inp := 0, 0
for i := roundUp8(xinpgenSize(buf)); i < uint32(len(buf)) && xinpgenSize(buf[i:]) > 24; i += roundUp8(xinpgenSize(buf[i:])) {
thisKind := binary.LittleEndian.Uint32(buf[i+4 : i+8])
if kinds&thisKind == 0 {
kinds |= thisKind
switch thisKind {
case 0x1:
// XSO_SOCKET
so = int(i)
case 0x10:
// XSO_INPCB
inp = int(i)
default:
break
}
}
// all blocks needed by tcp/udp
if (isTCP && kinds != 0x3f) || (!isTCP && kinds != 0x1f) {
continue
}
kinds = 0
// xsocket_n.xso_protocol
proto := binary.LittleEndian.Uint32(buf[so+36 : so+40])
if proto != syscall.IPPROTO_TCP && proto != syscall.IPPROTO_UDP {
continue
}
</s> add // from darwin-xnu/bsd/netinet/in_pcblist.c:get_pcblist_n
// size/offset are round up (aligned) to 8 bytes in darwin
// rup8(sizeof(xinpcb_n)) + rup8(sizeof(xsocket_n)) +
// 2 * rup8(sizeof(xsockbuf_n)) + rup8(sizeof(xsockstat_n))
itemSize := 384
if metadata.NetWork == C.TCP {
// rup8(sizeof(xtcpcb_n))
itemSize += 208
}
// skip the first and last xinpgen(24 bytes) block
for i := 24; i < len(buf)-24; i += itemSize {
// offset of xinpcb_n and xsocket_n
inp, so := i, i+104 | [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
] | https://github.com/Dreamacro/clash/commit/b1d9dfd6bf2b880cf21db4cbbdee46a179d12b7c | rules/process_darwin.go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.