add node filter config

config/parsing/hop/parse.go

@@ -32,7 +32,7 @@ func ParseHop(cfg *config.HopConfig, log logger.Logger) (hop.Hop, error) {
 			}
 		}
 		switch strings.ToLower(cfg.Plugin.Type) {
-		case "http":
+		case plugin.HTTP:
 			return hop_plugin.NewHTTPPlugin(
 				cfg.Name, cfg.Plugin.Addr,
 				plugin.TLSConfigOption(tlsCfg),

config/parsing/node/parse.go

@@ -147,46 +147,47 @@ func ParseNode(hop string, cfg *config.NodeConfig, log logger.Logger) (*chain.No
 		chain.TimeoutTransportOption(10*time.Second),
 	)
 
-	// convert *.example.com to .example.com
-	// convert *example.com to example.com
-	host := cfg.Host
-	if strings.HasPrefix(host, "*") {
-		host = host[1:]
-		if !strings.HasPrefix(host, ".") {
-			host = "." + host
-		}
-	}
-
 	opts := []chain.NodeOption{
 		chain.TransportNodeOption(tr),
 		chain.BypassNodeOption(bypass.BypassGroup(bypass_parser.List(cfg.Bypass, cfg.Bypasses...)...)),
 		chain.ResoloverNodeOption(registry.ResolverRegistry().Get(cfg.Resolver)),
 		chain.HostMapperNodeOption(registry.HostsRegistry().Get(cfg.Hosts)),
 		chain.MetadataNodeOption(nm),
-		chain.HostNodeOption(host),
-		chain.ProtocolNodeOption(cfg.Protocol),
-		chain.PathNodeOption(cfg.Path),
 		chain.NetworkNodeOption(cfg.Network),
 	}
+
+	if filter := cfg.Filter; filter != nil {
+		// convert *.example.com to .example.com
+		// convert *example.com to example.com
+		host := filter.Host
+		if strings.HasPrefix(host, "*") {
+			host = host[1:]
+			if !strings.HasPrefix(host, ".") {
+				host = "." + host
+			}
+		}
+
+		settings := &chain.NodeFilterSettings{
+			Protocol: filter.Protocol,
+			Host:     host,
+			Path:     filter.Path,
+		}
+		opts = append(opts, chain.NodeFilterOption(settings))
+	}
+
 	if cfg.HTTP != nil {
 		settings := &chain.HTTPNodeSettings{
 			Host:   cfg.HTTP.Host,
 			Header: cfg.HTTP.Header,
 		}
 
-		auth := cfg.HTTP.Auth
-		if auth == nil {
-			auth = cfg.Auth
-		}
-		if auth != nil {
+		if auth := cfg.HTTP.Auth; auth != nil && auth.Username != "" {
 			settings.Auther = xauth.NewAuthenticator(
 				xauth.AuthsOption(map[string]string{auth.Username: auth.Password}),
 				xauth.LoggerOption(log.WithFields(map[string]any{
-					"kind":     "node",
-					"node":     cfg.Name,
-					"addr":     cfg.Addr,
-					"host":     cfg.Host,
-					"protocol": cfg.Protocol,
+					"kind": "node",
+					"node": cfg.Name,
+					"addr": cfg.Addr,
 				})),
 			)
 		}
@@ -200,6 +201,7 @@ func ParseNode(hop string, cfg *config.NodeConfig, log logger.Logger) (*chain.No
 		}
 		opts = append(opts, chain.HTTPNodeOption(settings))
 	}
+
 	if cfg.TLS != nil {
 		tlsCfg := &chain.TLSNodeSettings{
 			ServerName: cfg.TLS.ServerName,

config/parsing/service/parse.go

@@ -275,6 +275,14 @@ func parseForwarder(cfg *config.ForwarderConfig, log logger.Logger) (hop.Hop, er
 		return nil, nil
 	}
 
+	hopName := cfg.Hop
+	if hopName == "" {
+		hopName = cfg.Name
+	}
+	if hopName != "" {
+		return registry.HopRegistry().Get(hopName), nil
+	}
+
 	hc := config.HopConfig{
 		Name:     cfg.Name,
 		Selector: cfg.Selector,
@@ -290,27 +298,42 @@ func parseForwarder(cfg *config.ForwarderConfig, log logger.Logger) (hop.Hop, er
 				if i > 0 {
 					name = fmt.Sprintf("%s-%d", node.Name, i)
 				}
+
+				filter := node.Filter
+				if filter == nil {
+					if node.Protocol != "" || node.Host != "" || node.Path != "" {
+						filter = &config.NodeFilterConfig{
+							Protocol: node.Protocol,
+							Host:     node.Host,
+							Path:     node.Path,
+						}
+					}
+				}
+
+				httpCfg := node.HTTP
+				if node.Auth != nil {
+					if httpCfg == nil {
+						httpCfg = &config.HTTPNodeConfig{}
+					}
+					if httpCfg.Auth == nil {
+						httpCfg.Auth = node.Auth
+					}
+				}
 				hc.Nodes = append(hc.Nodes, &config.NodeConfig{
 					Name:     name,
 					Addr:     addr,
-					Host:     node.Host,
 					Network:  node.Network,
-					Protocol: node.Protocol,
-					Path:     node.Path,
 					Bypass:   node.Bypass,
 					Bypasses: node.Bypasses,
-					HTTP:     node.HTTP,
+					Filter:   filter,
+					HTTP:     httpCfg,
 					TLS:      node.TLS,
-					Auth:     node.Auth,
 					Metadata: node.Metadata,
 				})
 			}
 		}
 	}
-	if len(hc.Nodes) > 0 {
-		return hop_parser.ParseHop(&hc, log)
-	}
-	return registry.HopRegistry().Get(hc.Name), nil
+	return hop_parser.ParseHop(&hc, log)
 }
 
 func chainGroup(name string, group *config.ChainGroupConfig) chain.Chainer {