124 lines
2.3 KiB
Go
124 lines
2.3 KiB
Go
package chain
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/go-gost/core/bypass"
|
|
"github.com/go-gost/core/hosts"
|
|
"github.com/go-gost/core/metadata"
|
|
"github.com/go-gost/core/resolver"
|
|
"github.com/go-gost/core/selector"
|
|
)
|
|
|
|
type Node struct {
|
|
Name string
|
|
Addr string
|
|
transport *Transport
|
|
bypass bypass.Bypass
|
|
resolver resolver.Resolver
|
|
hostMapper hosts.HostMapper
|
|
marker selector.Marker
|
|
metadata metadata.Metadata
|
|
}
|
|
|
|
func NewNode(name, addr string) *Node {
|
|
return &Node{
|
|
Name: name,
|
|
Addr: addr,
|
|
marker: selector.NewFailMarker(),
|
|
}
|
|
}
|
|
|
|
func (node *Node) WithTransport(tr *Transport) *Node {
|
|
node.transport = tr
|
|
return node
|
|
}
|
|
|
|
func (node *Node) WithBypass(bypass bypass.Bypass) *Node {
|
|
node.bypass = bypass
|
|
return node
|
|
}
|
|
|
|
func (node *Node) WithResolver(reslv resolver.Resolver) *Node {
|
|
node.resolver = reslv
|
|
return node
|
|
}
|
|
|
|
func (node *Node) WithHostMapper(m hosts.HostMapper) *Node {
|
|
node.hostMapper = m
|
|
return node
|
|
}
|
|
|
|
func (node *Node) WithMetadata(md metadata.Metadata) *Node {
|
|
node.metadata = md
|
|
return node
|
|
}
|
|
|
|
// Marker implements selector.Markable interface.
|
|
func (node *Node) Marker() selector.Marker {
|
|
return node.marker
|
|
}
|
|
|
|
// Metadata implements metadadta.Metadatable interface.
|
|
func (node *Node) Metadata() metadata.Metadata {
|
|
return node.metadata
|
|
}
|
|
|
|
func (node *Node) Copy() *Node {
|
|
n := &Node{}
|
|
*n = *node
|
|
return n
|
|
}
|
|
|
|
type NodeGroup struct {
|
|
nodes []*Node
|
|
selector selector.Selector[*Node]
|
|
bypass bypass.Bypass
|
|
}
|
|
|
|
func NewNodeGroup(nodes ...*Node) *NodeGroup {
|
|
return &NodeGroup{
|
|
nodes: nodes,
|
|
}
|
|
}
|
|
|
|
func (g *NodeGroup) AddNode(node *Node) {
|
|
g.nodes = append(g.nodes, node)
|
|
}
|
|
|
|
func (g *NodeGroup) Nodes() []*Node {
|
|
return g.nodes
|
|
}
|
|
|
|
func (g *NodeGroup) WithSelector(selector selector.Selector[*Node]) *NodeGroup {
|
|
g.selector = selector
|
|
return g
|
|
}
|
|
|
|
func (g *NodeGroup) WithBypass(bypass bypass.Bypass) *NodeGroup {
|
|
g.bypass = bypass
|
|
return g
|
|
}
|
|
|
|
func (g *NodeGroup) FilterAddr(addr string) *NodeGroup {
|
|
var nodes []*Node
|
|
for _, node := range g.nodes {
|
|
if node.bypass == nil || !node.bypass.Contains(addr) {
|
|
nodes = append(nodes, node)
|
|
}
|
|
}
|
|
return &NodeGroup{
|
|
nodes: nodes,
|
|
selector: g.selector,
|
|
bypass: g.bypass,
|
|
}
|
|
}
|
|
|
|
func (g *NodeGroup) Next(ctx context.Context) *Node {
|
|
if g == nil || len(g.nodes) == 0 {
|
|
return nil
|
|
}
|
|
|
|
return g.selector.Select(ctx, g.nodes...)
|
|
}
|