add plugin system

resolver/plugin.go

@@ -0,0 +1,65 @@
+package resolver
+
+import (
+	"context"
+	"net"
+
+	resolver_pkg "github.com/go-gost/core/resolver"
+	"github.com/go-gost/plugin/resolver/proto"
+	xlogger "github.com/go-gost/x/logger"
+)
+
+type pluginResolver struct {
+	client  proto.ResolverClient
+	options options
+}
+
+// NewPluginResolver creates a plugin Resolver.
+func NewPluginResolver(opts ...Option) (resolver_pkg.Resolver, error) {
+	var options options
+	for _, opt := range opts {
+		opt(&options)
+	}
+	if options.logger == nil {
+		options.logger = xlogger.Nop()
+	}
+
+	p := &pluginResolver{
+		options: options,
+	}
+	if options.client != nil {
+		p.client = proto.NewResolverClient(options.client)
+	}
+	return p, nil
+}
+
+func (p *pluginResolver) Resolve(ctx context.Context, network, host string) (ips []net.IP, err error) {
+	p.options.logger.Debugf("resolve %s/%s", host, network)
+
+	if p.client == nil {
+		return
+	}
+
+	r, err := p.client.Resolve(context.Background(),
+		&proto.ResolveRequest{
+			Network: network,
+			Host:    host,
+		})
+	if err != nil {
+		p.options.logger.Error(err)
+		return
+	}
+	for _, s := range r.Ips {
+		if ip := net.ParseIP(s); ip != nil {
+			ips = append(ips, ip)
+		}
+	}
+	return
+}
+
+func (p *pluginResolver) Close() error {
+	if p.options.client != nil {
+		return p.options.client.Close()
+	}
+	return nil
+}

resolver/resolver.go

@@ -12,6 +12,7 @@ import (
 	resolver_util "github.com/go-gost/x/internal/util/resolver"
 	"github.com/go-gost/x/resolver/exchanger"
 	"github.com/miekg/dns"
+	"google.golang.org/grpc"
 )
 
 type NameServer struct {
@@ -25,21 +26,28 @@ type NameServer struct {
 	exchanger exchanger.Exchanger
 }
 
-type resolverOptions struct {
+type options struct {
 	domain string
+	client *grpc.ClientConn
 	logger logger.Logger
 }
 
-type ResolverOption func(opts *resolverOptions)
+type Option func(opts *options)
 
-func DomainResolverOption(domain string) ResolverOption {
-	return func(opts *resolverOptions) {
+func DomainOption(domain string) Option {
+	return func(opts *options) {
 		opts.domain = domain
 	}
 }
 
-func LoggerResolverOption(logger logger.Logger) ResolverOption {
-	return func(opts *resolverOptions) {
+func PluginConnOption(c *grpc.ClientConn) Option {
+	return func(opts *options) {
+		opts.client = c
+	}
+}
+
+func LoggerOption(logger logger.Logger) Option {
+	return func(opts *options) {
 		opts.logger = logger
 	}
 }
@@ -47,11 +55,11 @@ func LoggerResolverOption(logger logger.Logger) ResolverOption {
 type resolver struct {
 	servers []NameServer
 	cache   *resolver_util.Cache
-	options resolverOptions
+	options options
 }
 
-func NewResolver(nameservers []NameServer, opts ...ResolverOption) (resolverpkg.Resolver, error) {
-	options := resolverOptions{}
+func NewResolver(nameservers []NameServer, opts ...Option) (resolverpkg.Resolver, error) {
+	options := options{}
 	for _, opt := range opts {
 		opt(&options)
 	}