add hop

chain/chain.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/go-gost/core/chain"
+	"github.com/go-gost/core/logger"
 	"github.com/go-gost/core/metadata"
 	"github.com/go-gost/core/selector"
 )
@@ -12,6 +13,25 @@ var (
 	_ chain.Chainer = (*chainGroup)(nil)
 )
 
+type ChainOptions struct {
+	Metadata metadata.Metadata
+	Logger   logger.Logger
+}
+
+type ChainOption func(*ChainOptions)
+
+func MetadataChainOption(md metadata.Metadata) ChainOption {
+	return func(opts *ChainOptions) {
+		opts.Metadata = md
+	}
+}
+
+func LoggerChainOption(logger logger.Logger) ChainOption {
+	return func(opts *ChainOptions) {
+		opts.Logger = logger
+	}
+}
+
 type chainNamer interface {
 	Name() string
 }
@@ -21,13 +41,22 @@ type Chain struct {
 	hops     []chain.Hop
 	marker   selector.Marker
 	metadata metadata.Metadata
+	logger   logger.Logger
 }
 
-func NewChain(name string, hops ...chain.Hop) *Chain {
+func NewChain(name string, opts ...ChainOption) *Chain {
+	var options ChainOptions
+	for _, opt := range opts {
+		if opt != nil {
+			opt(&options)
+		}
+	}
+
 	return &Chain{
-		name:   name,
-		hops:   hops,
-		marker: selector.NewFailMarker(),
+		name:     name,
+		metadata: options.Metadata,
+		marker:   selector.NewFailMarker(),
+		logger:   options.Logger,
 	}
 }
 
@@ -35,10 +64,6 @@ func (c *Chain) AddHop(hop chain.Hop) {
 	c.hops = append(c.hops, hop)
 }
 
-func (c *Chain) WithMetadata(md metadata.Metadata) {
-	c.metadata = md
-}
-
 // Metadata implements metadata.Metadatable interface.
 func (c *Chain) Metadata() metadata.Metadata {
 	return c.metadata

chain/hop.go

@@ -2,25 +2,17 @@ package chain
 
 import (
 	"context"
-	"io"
-	"sync"
-	"time"
 
 	"github.com/go-gost/core/bypass"
 	"github.com/go-gost/core/chain"
 	"github.com/go-gost/core/logger"
 	"github.com/go-gost/core/selector"
-	"github.com/go-gost/x/internal/loader"
 )
 
 type HopOptions struct {
-	bypass      bypass.Bypass
-	selector    selector.Selector[*chain.Node]
-	fileLoader  loader.Loader
-	httpLoader  loader.Loader
-	redisLoader loader.Loader
-	period      time.Duration
-	logger      logger.Logger
+	bypass   bypass.Bypass
+	selector selector.Selector[*chain.Node]
+	logger   logger.Logger
 }
 
 type HopOption func(*HopOptions)
@@ -37,30 +29,6 @@ func SelectorHopOption(s selector.Selector[*chain.Node]) HopOption {
 	}
 }
 
-func FileLoaderHopOption(fileLoader loader.Loader) HopOption {
-	return func(opts *HopOptions) {
-		opts.fileLoader = fileLoader
-	}
-}
-
-func RedisLoaderHopOption(redisLoader loader.Loader) HopOption {
-	return func(opts *HopOptions) {
-		opts.redisLoader = redisLoader
-	}
-}
-
-func HTTPLoaderHopOption(httpLoader loader.Loader) HopOption {
-	return func(opts *HopOptions) {
-		opts.httpLoader = httpLoader
-	}
-}
-
-func ReloadPeriodHopOption(period time.Duration) HopOption {
-	return func(opts *HopOptions) {
-		opts.period = period
-	}
-}
-
 func LoggerHopOption(logger logger.Logger) HopOption {
 	return func(opts *HopOptions) {
 		opts.logger = logger
@@ -68,10 +36,8 @@ func LoggerHopOption(logger logger.Logger) HopOption {
 }
 
 type chainHop struct {
-	nodes      []*chain.Node
-	options    HopOptions
-	cancelFunc context.CancelFunc
-	mu         sync.RWMutex
+	nodes   []*chain.Node
+	options HopOptions
 }
 
 func NewChainHop(nodes []*chain.Node, opts ...HopOption) chain.Hop {
@@ -82,18 +48,9 @@ func NewChainHop(nodes []*chain.Node, opts ...HopOption) chain.Hop {
 		}
 	}
 
-	ctx, cancel := context.WithCancel(context.TODO())
-
 	hop := &chainHop{
-		nodes:      nodes,
-		options:    options,
-		cancelFunc: cancel,
-	}
-	if err := hop.reload(ctx); err != nil {
-		options.logger.Warnf("reload: %v", err)
-	}
-	if hop.options.period > 0 {
-		go hop.periodReload(ctx)
+		nodes:   nodes,
+		options: options,
 	}
 
 	return hop
@@ -138,61 +95,3 @@ func (p *chainHop) Select(ctx context.Context, opts ...chain.SelectOption) *chai
 	}
 	return nodes[0]
 }
-
-func (p *chainHop) periodReload(ctx context.Context) error {
-	period := p.options.period
-	if period < time.Second {
-		period = time.Second
-	}
-	ticker := time.NewTicker(period)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			if err := p.reload(ctx); err != nil {
-				p.options.logger.Warnf("reload: %v", err)
-				// return err
-			}
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-}
-
-func (p *chainHop) reload(ctx context.Context) error {
-	_, err := p.load(ctx)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *chainHop) load(ctx context.Context) (data []byte, err error) {
-	if p.options.fileLoader != nil {
-		r, er := p.options.fileLoader.Load(ctx)
-		if er != nil {
-			p.options.logger.Warnf("file loader: %v", er)
-		}
-		return io.ReadAll(r)
-	}
-
-	if p.options.redisLoader != nil {
-		r, er := p.options.redisLoader.Load(ctx)
-		if er != nil {
-			p.options.logger.Warnf("redis loader: %v", er)
-		}
-		return io.ReadAll(r)
-	}
-
-	if p.options.httpLoader != nil {
-		r, er := p.options.redisLoader.Load(ctx)
-		if er != nil {
-			p.options.logger.Warnf("http loader: %v", er)
-		}
-		return io.ReadAll(r)
-	}
-
-	return
-}