init

go-gost/x/registry/admission.go

@@ -0,0 +1,39 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/admission"
+)
+
+type admissionRegistry struct {
+	registry[admission.Admission]
+}
+
+func (r *admissionRegistry) Register(name string, v admission.Admission) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *admissionRegistry) Get(name string) admission.Admission {
+	if name != "" {
+		return &admissionWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *admissionRegistry) get(name string) admission.Admission {
+	return r.registry.Get(name)
+}
+
+type admissionWrapper struct {
+	name string
+	r    *admissionRegistry
+}
+
+func (w *admissionWrapper) Admit(ctx context.Context, addr string, opts ...admission.Option) bool {
+	p := w.r.get(w.name)
+	if p == nil {
+		return false
+	}
+	return p.Admit(ctx, addr, opts...)
+}

go-gost/x/registry/auther.go

@@ -0,0 +1,39 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/auth"
+)
+
+type autherRegistry struct {
+	registry[auth.Authenticator]
+}
+
+func (r *autherRegistry) Register(name string, v auth.Authenticator) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *autherRegistry) Get(name string) auth.Authenticator {
+	if name != "" {
+		return &autherWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *autherRegistry) get(name string) auth.Authenticator {
+	return r.registry.Get(name)
+}
+
+type autherWrapper struct {
+	name string
+	r    *autherRegistry
+}
+
+func (w *autherWrapper) Authenticate(ctx context.Context, user, password string, opts ...auth.Option) (string, bool) {
+	v := w.r.get(w.name)
+	if v == nil {
+		return "", true
+	}
+	return v.Authenticate(ctx, user, password, opts...)
+}

go-gost/x/registry/bypass.go

@@ -0,0 +1,47 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/bypass"
+)
+
+type bypassRegistry struct {
+	registry[bypass.Bypass]
+}
+
+func (r *bypassRegistry) Register(name string, v bypass.Bypass) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *bypassRegistry) Get(name string) bypass.Bypass {
+	if name != "" {
+		return &bypassWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *bypassRegistry) get(name string) bypass.Bypass {
+	return r.registry.Get(name)
+}
+
+type bypassWrapper struct {
+	name string
+	r    *bypassRegistry
+}
+
+func (w *bypassWrapper) Contains(ctx context.Context, network, addr string, opts ...bypass.Option) bool {
+	bp := w.r.get(w.name)
+	if bp == nil {
+		return false
+	}
+	return bp.Contains(ctx, network, addr, opts...)
+}
+
+func (p *bypassWrapper) IsWhitelist() bool {
+	bp := p.r.get(p.name)
+	if bp == nil {
+		return false
+	}
+	return bp.IsWhitelist()
+}

go-gost/x/registry/chain.go

@@ -0,0 +1,64 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/chain"
+	"github.com/go-gost/core/metadata"
+	"github.com/go-gost/core/selector"
+)
+
+type chainRegistry struct {
+	registry[chain.Chainer]
+}
+
+func (r *chainRegistry) Register(name string, v chain.Chainer) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *chainRegistry) Get(name string) chain.Chainer {
+	if name != "" {
+		return &chainWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *chainRegistry) get(name string) chain.Chainer {
+	return r.registry.Get(name)
+}
+
+type chainWrapper struct {
+	name string
+	r    *chainRegistry
+}
+
+func (w *chainWrapper) Marker() selector.Marker {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	if mi, ok := v.(selector.Markable); ok {
+		return mi.Marker()
+	}
+	return nil
+}
+
+func (w *chainWrapper) Metadata() metadata.Metadata {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+
+	if mi, ok := v.(metadata.Metadatable); ok {
+		return mi.Metadata()
+	}
+	return nil
+}
+
+func (w *chainWrapper) Route(ctx context.Context, network, address string, opts ...chain.RouteOption) chain.Route {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.Route(ctx, network, address, opts...)
+}

go-gost/x/registry/connector.go

@@ -0,0 +1,19 @@
+package registry
+
+import (
+	"github.com/go-gost/core/connector"
+	"github.com/go-gost/core/logger"
+)
+
+type NewConnector func(opts ...connector.Option) connector.Connector
+
+type connectorRegistry struct {
+	registry[NewConnector]
+}
+
+func (r *connectorRegistry) Register(name string, v NewConnector) error {
+	if err := r.registry.Register(name, v); err != nil {
+		logger.Default().Fatal(err)
+	}
+	return nil
+}

go-gost/x/registry/dialer.go

@@ -0,0 +1,19 @@
+package registry
+
+import (
+	"github.com/go-gost/core/dialer"
+	"github.com/go-gost/core/logger"
+)
+
+type NewDialer func(opts ...dialer.Option) dialer.Dialer
+
+type dialerRegistry struct {
+	registry[NewDialer]
+}
+
+func (r *dialerRegistry) Register(name string, v NewDialer) error {
+	if err := r.registry.Register(name, v); err != nil {
+		logger.Default().Fatal(err)
+	}
+	return nil
+}

go-gost/x/registry/handler.go

@@ -0,0 +1,19 @@
+package registry
+
+import (
+	"github.com/go-gost/core/handler"
+	"github.com/go-gost/core/logger"
+)
+
+type NewHandler func(opts ...handler.Option) handler.Handler
+
+type handlerRegistry struct {
+	registry[NewHandler]
+}
+
+func (r *handlerRegistry) Register(name string, v NewHandler) error {
+	if err := r.registry.Register(name, v); err != nil {
+		logger.Default().Fatal(err)
+	}
+	return nil
+}

go-gost/x/registry/hop.go

@@ -0,0 +1,52 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/chain"
+	"github.com/go-gost/core/hop"
+)
+
+type hopRegistry struct {
+	registry[hop.Hop]
+}
+
+func (r *hopRegistry) Register(name string, v hop.Hop) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *hopRegistry) Get(name string) hop.Hop {
+	if name != "" {
+		return &hopWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *hopRegistry) get(name string) hop.Hop {
+	return r.registry.Get(name)
+}
+
+type hopWrapper struct {
+	name string
+	r    *hopRegistry
+}
+
+func (w *hopWrapper) Nodes() []*chain.Node {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	if nl, ok := v.(hop.NodeList); ok {
+		return nl.Nodes()
+	}
+	return nil
+}
+
+func (w *hopWrapper) Select(ctx context.Context, opts ...hop.SelectOption) *chain.Node {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+
+	return v.Select(ctx, opts...)
+}

go-gost/x/registry/hosts.go

@@ -0,0 +1,40 @@
+package registry
+
+import (
+	"context"
+	"net"
+
+	"github.com/go-gost/core/hosts"
+)
+
+type hostsRegistry struct {
+	registry[hosts.HostMapper]
+}
+
+func (r *hostsRegistry) Register(name string, v hosts.HostMapper) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *hostsRegistry) Get(name string) hosts.HostMapper {
+	if name != "" {
+		return &hostsWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *hostsRegistry) get(name string) hosts.HostMapper {
+	return r.registry.Get(name)
+}
+
+type hostsWrapper struct {
+	name string
+	r    *hostsRegistry
+}
+
+func (w *hostsWrapper) Lookup(ctx context.Context, network, host string, opts ...hosts.Option) ([]net.IP, bool) {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil, false
+	}
+	return v.Lookup(ctx, network, host, opts...)
+}

go-gost/x/registry/ingress.go

@@ -0,0 +1,48 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/ingress"
+)
+
+type ingressRegistry struct {
+	registry[ingress.Ingress]
+}
+
+func (r *ingressRegistry) Register(name string, v ingress.Ingress) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *ingressRegistry) Get(name string) ingress.Ingress {
+	if name != "" {
+		return &ingressWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *ingressRegistry) get(name string) ingress.Ingress {
+	return r.registry.Get(name)
+}
+
+type ingressWrapper struct {
+	name string
+	r    *ingressRegistry
+}
+
+func (w *ingressWrapper) GetRule(ctx context.Context, host string, opts ...ingress.Option) *ingress.Rule {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.GetRule(ctx, host, opts...)
+}
+
+func (w *ingressWrapper) SetRule(ctx context.Context, rule *ingress.Rule, opts ...ingress.Option) bool {
+	v := w.r.get(w.name)
+	if v == nil {
+		return false
+	}
+
+	return v.SetRule(ctx, rule, opts...)
+}

go-gost/x/registry/limiter.go

@@ -0,0 +1,114 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/limiter"
+	"github.com/go-gost/core/limiter/conn"
+	"github.com/go-gost/core/limiter/rate"
+	"github.com/go-gost/core/limiter/traffic"
+)
+
+type trafficLimiterRegistry struct {
+	registry[traffic.TrafficLimiter]
+}
+
+func (r *trafficLimiterRegistry) Register(name string, v traffic.TrafficLimiter) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *trafficLimiterRegistry) Get(name string) traffic.TrafficLimiter {
+	if name != "" {
+		return &trafficLimiterWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *trafficLimiterRegistry) get(name string) traffic.TrafficLimiter {
+	return r.registry.Get(name)
+}
+
+type trafficLimiterWrapper struct {
+	name string
+	r    *trafficLimiterRegistry
+}
+
+func (w *trafficLimiterWrapper) In(ctx context.Context, key string, opts ...limiter.Option) traffic.Limiter {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.In(ctx, key, opts...)
+}
+
+func (w *trafficLimiterWrapper) Out(ctx context.Context, key string, opts ...limiter.Option) traffic.Limiter {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.Out(ctx, key, opts...)
+}
+
+type connLimiterRegistry struct {
+	registry[conn.ConnLimiter]
+}
+
+func (r *connLimiterRegistry) Register(name string, v conn.ConnLimiter) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *connLimiterRegistry) Get(name string) conn.ConnLimiter {
+	if name != "" {
+		return &connLimiterWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *connLimiterRegistry) get(name string) conn.ConnLimiter {
+	return r.registry.Get(name)
+}
+
+type connLimiterWrapper struct {
+	name string
+	r    *connLimiterRegistry
+}
+
+func (w *connLimiterWrapper) Limiter(key string) conn.Limiter {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.Limiter(key)
+}
+
+type rateLimiterRegistry struct {
+	registry[rate.RateLimiter]
+}
+
+func (r *rateLimiterRegistry) Register(name string, v rate.RateLimiter) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *rateLimiterRegistry) Get(name string) rate.RateLimiter {
+	if name != "" {
+		return &rateLimiterWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *rateLimiterRegistry) get(name string) rate.RateLimiter {
+	return r.registry.Get(name)
+}
+
+type rateLimiterWrapper struct {
+	name string
+	r    *rateLimiterRegistry
+}
+
+func (w *rateLimiterWrapper) Limiter(key string) rate.Limiter {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.Limiter(key)
+}

go-gost/x/registry/listener.go

@@ -0,0 +1,19 @@
+package registry
+
+import (
+	"github.com/go-gost/core/listener"
+	"github.com/go-gost/core/logger"
+)
+
+type NewListener func(opts ...listener.Option) listener.Listener
+
+type listenerRegistry struct {
+	registry[NewListener]
+}
+
+func (r *listenerRegistry) Register(name string, v NewListener) error {
+	if err := r.registry.Register(name, v); err != nil {
+		logger.Default().Fatal(err)
+	}
+	return nil
+}

go-gost/x/registry/logger.go

@@ -0,0 +1,13 @@
+package registry
+
+import (
+	"github.com/go-gost/core/logger"
+)
+
+type loggerRegistry struct {
+	registry[logger.Logger]
+}
+
+func (r *loggerRegistry) Register(name string, v logger.Logger) error {
+	return r.registry.Register(name, v)
+}

go-gost/x/registry/observer.go

@@ -0,0 +1,39 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/observer"
+)
+
+type observerRegistry struct {
+	registry[observer.Observer]
+}
+
+func (r *observerRegistry) Register(name string, v observer.Observer) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *observerRegistry) Get(name string) observer.Observer {
+	if name != "" {
+		return &observerWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *observerRegistry) get(name string) observer.Observer {
+	return r.registry.Get(name)
+}
+
+type observerWrapper struct {
+	name string
+	r    *observerRegistry
+}
+
+func (w *observerWrapper) Observe(ctx context.Context, events []observer.Event, opts ...observer.Option) error {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.Observe(ctx, events, opts...)
+}

go-gost/x/registry/recorder.go

@@ -0,0 +1,39 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/recorder"
+)
+
+type recorderRegistry struct {
+	registry[recorder.Recorder]
+}
+
+func (r *recorderRegistry) Register(name string, v recorder.Recorder) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *recorderRegistry) Get(name string) recorder.Recorder {
+	if name != "" {
+		return &recorderWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *recorderRegistry) get(name string) recorder.Recorder {
+	return r.registry.Get(name)
+}
+
+type recorderWrapper struct {
+	name string
+	r    *recorderRegistry
+}
+
+func (w *recorderWrapper) Record(ctx context.Context, b []byte, opts ...recorder.RecordOption) error {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.Record(ctx, b, opts...)
+}

go-gost/x/registry/registry.go

@@ -0,0 +1,190 @@
+package registry
+
+import (
+	"errors"
+	"io"
+	"sync"
+
+	"github.com/go-gost/core/admission"
+	"github.com/go-gost/core/auth"
+	"github.com/go-gost/core/bypass"
+	"github.com/go-gost/core/chain"
+	"github.com/go-gost/core/hop"
+	"github.com/go-gost/core/hosts"
+	"github.com/go-gost/core/ingress"
+	"github.com/go-gost/core/limiter/conn"
+	"github.com/go-gost/core/limiter/rate"
+	"github.com/go-gost/core/limiter/traffic"
+	"github.com/go-gost/core/logger"
+	"github.com/go-gost/core/observer"
+	"github.com/go-gost/core/recorder"
+	reg "github.com/go-gost/core/registry"
+	"github.com/go-gost/core/resolver"
+	"github.com/go-gost/core/router"
+	"github.com/go-gost/core/sd"
+	"github.com/go-gost/core/service"
+)
+
+var (
+	ErrDup = errors.New("registry: duplicate object")
+)
+
+var (
+	listenerReg  reg.Registry[NewListener]         = new(listenerRegistry)
+	handlerReg   reg.Registry[NewHandler]          = new(handlerRegistry)
+	dialerReg    reg.Registry[NewDialer]           = new(dialerRegistry)
+	connectorReg reg.Registry[NewConnector]        = new(connectorRegistry)
+	serviceReg   reg.Registry[service.Service]     = new(serviceRegistry)
+	chainReg     reg.Registry[chain.Chainer]       = new(chainRegistry)
+	hopReg       reg.Registry[hop.Hop]             = new(hopRegistry)
+	autherReg    reg.Registry[auth.Authenticator]  = new(autherRegistry)
+	admissionReg reg.Registry[admission.Admission] = new(admissionRegistry)
+	bypassReg    reg.Registry[bypass.Bypass]       = new(bypassRegistry)
+	resolverReg  reg.Registry[resolver.Resolver]   = new(resolverRegistry)
+	hostsReg     reg.Registry[hosts.HostMapper]    = new(hostsRegistry)
+	recorderReg  reg.Registry[recorder.Recorder]   = new(recorderRegistry)
+
+	trafficLimiterReg reg.Registry[traffic.TrafficLimiter] = new(trafficLimiterRegistry)
+	connLimiterReg    reg.Registry[conn.ConnLimiter]       = new(connLimiterRegistry)
+	rateLimiterReg    reg.Registry[rate.RateLimiter]       = new(rateLimiterRegistry)
+
+	ingressReg  reg.Registry[ingress.Ingress]   = new(ingressRegistry)
+	routerReg   reg.Registry[router.Router]     = new(routerRegistry)
+	sdReg       reg.Registry[sd.SD]             = new(sdRegistry)
+	observerReg reg.Registry[observer.Observer] = new(observerRegistry)
+
+	loggerReg reg.Registry[logger.Logger] = new(loggerRegistry)
+)
+
+type registry[T any] struct {
+	m sync.Map
+}
+
+func (r *registry[T]) Register(name string, v T) error {
+	if name == "" {
+		return nil
+	}
+	if _, loaded := r.m.LoadOrStore(name, v); loaded {
+		return ErrDup
+	}
+
+	return nil
+}
+
+func (r *registry[T]) Unregister(name string) {
+	if v, ok := r.m.Load(name); ok {
+		if closer, ok := v.(io.Closer); ok {
+			closer.Close()
+		}
+		r.m.Delete(name)
+	}
+}
+
+func (r *registry[T]) IsRegistered(name string) bool {
+	_, ok := r.m.Load(name)
+	return ok
+}
+
+func (r *registry[T]) Get(name string) (t T) {
+	if name == "" {
+		return
+	}
+	v, _ := r.m.Load(name)
+	t, _ = v.(T)
+	return
+}
+
+func (r *registry[T]) GetAll() (m map[string]T) {
+	m = make(map[string]T)
+	r.m.Range(func(key, value any) bool {
+		k, _ := key.(string)
+		v, _ := value.(T)
+		m[k] = v
+		return true
+	})
+	return
+}
+
+func ListenerRegistry() reg.Registry[NewListener] {
+	return listenerReg
+}
+
+func HandlerRegistry() reg.Registry[NewHandler] {
+	return handlerReg
+}
+
+func DialerRegistry() reg.Registry[NewDialer] {
+	return dialerReg
+}
+
+func ConnectorRegistry() reg.Registry[NewConnector] {
+	return connectorReg
+}
+
+func ServiceRegistry() reg.Registry[service.Service] {
+	return serviceReg
+}
+
+func ChainRegistry() reg.Registry[chain.Chainer] {
+	return chainReg
+}
+
+func HopRegistry() reg.Registry[hop.Hop] {
+	return hopReg
+}
+
+func AutherRegistry() reg.Registry[auth.Authenticator] {
+	return autherReg
+}
+
+func AdmissionRegistry() reg.Registry[admission.Admission] {
+	return admissionReg
+}
+
+func BypassRegistry() reg.Registry[bypass.Bypass] {
+	return bypassReg
+}
+
+func ResolverRegistry() reg.Registry[resolver.Resolver] {
+	return resolverReg
+}
+
+func HostsRegistry() reg.Registry[hosts.HostMapper] {
+	return hostsReg
+}
+
+func RecorderRegistry() reg.Registry[recorder.Recorder] {
+	return recorderReg
+}
+
+func TrafficLimiterRegistry() reg.Registry[traffic.TrafficLimiter] {
+	return trafficLimiterReg
+}
+
+func ConnLimiterRegistry() reg.Registry[conn.ConnLimiter] {
+	return connLimiterReg
+}
+
+func RateLimiterRegistry() reg.Registry[rate.RateLimiter] {
+	return rateLimiterReg
+}
+
+func IngressRegistry() reg.Registry[ingress.Ingress] {
+	return ingressReg
+}
+
+func RouterRegistry() reg.Registry[router.Router] {
+	return routerReg
+}
+
+func SDRegistry() reg.Registry[sd.SD] {
+	return sdReg
+}
+
+func ObserverRegistry() reg.Registry[observer.Observer] {
+	return observerReg
+}
+
+func LoggerRegistry() reg.Registry[logger.Logger] {
+	return loggerReg
+}

go-gost/x/registry/resolver.go

@@ -0,0 +1,40 @@
+package registry
+
+import (
+	"context"
+	"net"
+
+	"github.com/go-gost/core/resolver"
+)
+
+type resolverRegistry struct {
+	registry[resolver.Resolver]
+}
+
+func (r *resolverRegistry) Register(name string, v resolver.Resolver) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *resolverRegistry) Get(name string) resolver.Resolver {
+	if name != "" {
+		return &resolverWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *resolverRegistry) get(name string) resolver.Resolver {
+	return r.registry.Get(name)
+}
+
+type resolverWrapper struct {
+	name string
+	r    *resolverRegistry
+}
+
+func (w *resolverWrapper) Resolve(ctx context.Context, network, host string, opts ...resolver.Option) ([]net.IP, error) {
+	r := w.r.get(w.name)
+	if r == nil {
+		return nil, resolver.ErrInvalid
+	}
+	return r.Resolve(ctx, network, host, opts...)
+}

go-gost/x/registry/router.go

@@ -0,0 +1,39 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/router"
+)
+
+type routerRegistry struct {
+	registry[router.Router]
+}
+
+func (r *routerRegistry) Register(name string, v router.Router) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *routerRegistry) Get(name string) router.Router {
+	if name != "" {
+		return &routerWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *routerRegistry) get(name string) router.Router {
+	return r.registry.Get(name)
+}
+
+type routerWrapper struct {
+	name string
+	r    *routerRegistry
+}
+
+func (w *routerWrapper) GetRoute(ctx context.Context, dst string, opts ...router.Option) *router.Route {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.GetRoute(ctx, dst, opts...)
+}

go-gost/x/registry/sd.go

@@ -0,0 +1,66 @@
+package registry
+
+import (
+	"context"
+
+	"github.com/go-gost/core/sd"
+)
+
+type sdRegistry struct {
+	registry[sd.SD]
+}
+
+func (r *sdRegistry) Register(name string, v sd.SD) error {
+	return r.registry.Register(name, v)
+}
+
+func (r *sdRegistry) Get(name string) sd.SD {
+	if name != "" {
+		return &sdWrapper{name: name, r: r}
+	}
+	return nil
+}
+
+func (r *sdRegistry) get(name string) sd.SD {
+	return r.registry.Get(name)
+}
+
+type sdWrapper struct {
+	name string
+	r    *sdRegistry
+}
+
+func (w *sdWrapper) Register(ctx context.Context, service *sd.Service, opts ...sd.Option) error {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+	return v.Register(ctx, service, opts...)
+}
+
+func (w *sdWrapper) Deregister(ctx context.Context, service *sd.Service) error {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+
+	return v.Deregister(ctx, service)
+}
+
+func (w *sdWrapper) Renew(ctx context.Context, service *sd.Service) error {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil
+	}
+
+	return v.Renew(ctx, service)
+}
+
+func (w *sdWrapper) Get(ctx context.Context, name string) ([]*sd.Service, error) {
+	v := w.r.get(w.name)
+	if v == nil {
+		return nil, nil
+	}
+
+	return v.Get(ctx, name)
+}

go-gost/x/registry/service.go

@@ -0,0 +1,9 @@
+package registry
+
+import (
+	"github.com/go-gost/core/service"
+)
+
+type serviceRegistry struct {
+	registry[service.Service]
+}