go-gost/gost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update registry

Browse Source
This commit is contained in:
ginuerzh
2022-02-27 22:32:15 +08:00
parent 0aee4f0ebd
commit 07132d8de7
115 changed files with 651 additions and 680 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
pkg/registry/admission.go
View File

@ -1,52 +1,26 @@
package registry
import (
"sync"
"github.com/go-gost/gost/pkg/admission"
)
var (
admissionReg = &admissionRegistry{}
)
func Admission() *admissionRegistry {
return admissionReg
}
type admissionRegistry struct {
m sync.Map
registry
}
func (r *admissionRegistry) Register(name string, admission admission.Admission) error {
if name == "" || admission == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, admission); loaded {
return ErrDup
}
return nil
}
func (r *admissionRegistry) Unregister(name string) {
r.m.Delete(name)
}
func (r *admissionRegistry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
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 nil
if name != "" {
return &admissionWrapper{name: name, r: r}
}
return &admissionWrapper{name: name}
return nil
}
func (r *admissionRegistry) get(name string) admission.Admission {
if v, ok := r.m.Load(name); ok {
if v := r.registry.Get(name); v != nil {
return v.(admission.Admission)
}
return nil
@ -54,10 +28,11 @@ func (r *admissionRegistry) get(name string) admission.Admission {
type admissionWrapper struct {
name string
r *admissionRegistry
}
func (w *admissionWrapper) Admit(addr string) bool {
p := admissionReg.get(w.name)
p := w.r.get(w.name)
if p == nil {
return false
}

43
pkg/registry/auther.go
View File

@ -1,52 +1,26 @@
package registry
import (
"sync"
"github.com/go-gost/gost/pkg/auth"
)
var (
autherReg = &autherRegistry{}
)
func Auther() *autherRegistry {
return autherReg
}
type autherRegistry struct {
m sync.Map
registry
}
func (r *autherRegistry) Register(name string, auther auth.Authenticator) error {
if name == "" || auther == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, auther); loaded {
return ErrDup
}
return nil
}
func (r *autherRegistry) Unregister(name string) {
r.m.Delete(name)
}
func (r *autherRegistry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
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 nil
if name != "" {
return &autherWrapper{name: name, r: r}
}
return &autherWrapper{name: name}
return nil
}
func (r *autherRegistry) get(name string) auth.Authenticator {
if v, ok := r.m.Load(name); ok {
if v := r.registry.Get(name); v != nil {
return v.(auth.Authenticator)
}
return nil
@ -54,10 +28,11 @@ func (r *autherRegistry) get(name string) auth.Authenticator {
type autherWrapper struct {
name string
r *autherRegistry
}
func (w *autherWrapper) Authenticate(user, password string) bool {
v := autherReg.get(w.name)
v := w.r.get(w.name)
if v == nil {
return true
}

43
pkg/registry/bypass.go
View File

@ -1,52 +1,26 @@
package registry
import (
"sync"
"github.com/go-gost/gost/pkg/bypass"
)
var (
bypassReg = &bypassRegistry{}
)
func Bypass() *bypassRegistry {
return bypassReg
}
type bypassRegistry struct {
m sync.Map
registry
}
func (r *bypassRegistry) Register(name string, bypass bypass.Bypass) error {
if name == "" || bypass == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, bypass); loaded {
return ErrDup
}
return nil
}
func (r *bypassRegistry) Unregister(name string) {
r.m.Delete(name)
}
func (r *bypassRegistry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
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 nil
if name != "" {
return &bypassWrapper{name: name, r: r}
}
return &bypassWrapper{name: name}
return nil
}
func (r *bypassRegistry) get(name string) bypass.Bypass {
if v, ok := r.m.Load(name); ok {
if v := r.registry.Get(name); v != nil {
return v.(bypass.Bypass)
}
return nil
@ -54,10 +28,11 @@ func (r *bypassRegistry) get(name string) bypass.Bypass {
type bypassWrapper struct {
name string
r *bypassRegistry
}
func (w *bypassWrapper) Contains(addr string) bool {
bp := bypassReg.get(w.name)
bp := w.r.get(w.name)
if bp == nil {
return false
}

43
pkg/registry/chain.go
View File

@ -1,52 +1,26 @@
package registry
import (
"sync"
"github.com/go-gost/gost/pkg/chain"
)
var (
chainReg = &chainRegistry{}
)
func Chain() *chainRegistry {
return chainReg
}
type chainRegistry struct {
m sync.Map
registry
}
func (r *chainRegistry) Register(name string, chain chain.Chainer) error {
if name == "" || chain == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, chain); loaded {
return ErrDup
}
return nil
}
func (r *chainRegistry) Unregister(name string) {
r.m.Delete(name)
}
func (r *chainRegistry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
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 nil
if name != "" {
return &chainWrapper{name: name, r: r}
}
return &chainWrapper{name: name}
return nil
}
func (r *chainRegistry) get(name string) chain.Chainer {
if v, ok := r.m.Load(name); ok {
if v := r.registry.Get(name); v != nil {
return v.(chain.Chainer)
}
return nil
@ -54,10 +28,11 @@ func (r *chainRegistry) get(name string) chain.Chainer {
type chainWrapper struct {
name string
r *chainRegistry
}
func (w *chainWrapper) Route(network, address string) *chain.Route {
v := Chain().get(w.name)
v := w.r.get(w.name)
if v == nil {
return nil
}

26
pkg/registry/connector.go Normal file
View File

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

26
pkg/registry/dialer.go Normal file
View File

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

26
pkg/registry/handler.go Normal file
View File

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

42
pkg/registry/hosts.go
View File

@ -2,52 +2,27 @@ package registry
import (
"net"
"sync"
"github.com/go-gost/gost/pkg/hosts"
)
var (
hostsReg = &hostsRegistry{}
)
func Hosts() *hostsRegistry {
return hostsReg
}
type hostsRegistry struct {
m sync.Map
registry
}
func (r *hostsRegistry) Register(name string, hosts hosts.HostMapper) error {
if name == "" || hosts == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, hosts); loaded {
return ErrDup
}
return nil
}
func (r *hostsRegistry) Unregister(name string) {
r.m.Delete(name)
}
func (r *hostsRegistry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
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 nil
if name != "" {
return &hostsWrapper{name: name, r: r}
}
return &hostsWrapper{name: name}
return nil
}
func (r *hostsRegistry) get(name string) hosts.HostMapper {
if v, ok := r.m.Load(name); ok {
if v := r.registry.Get(name); v != nil {
return v.(hosts.HostMapper)
}
return nil
@ -55,10 +30,11 @@ func (r *hostsRegistry) get(name string) hosts.HostMapper {
type hostsWrapper struct {
name string
r *hostsRegistry
}
func (w *hostsWrapper) Lookup(network, host string) ([]net.IP, bool) {
v := Hosts().get(w.name)
v := w.r.get(w.name)
if v == nil {
return nil, false
}

26
pkg/registry/listener.go Normal file
View File

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

133
pkg/registry/registry.go
View File

@ -2,70 +2,115 @@ package registry
import (
"errors"
"sync"
"github.com/go-gost/gost/pkg/connector"
"github.com/go-gost/gost/pkg/dialer"
"github.com/go-gost/gost/pkg/handler"
"github.com/go-gost/gost/pkg/listener"
"github.com/go-gost/gost/pkg/logger"
"github.com/go-gost/gost/pkg/admission"
"github.com/go-gost/gost/pkg/auth"
"github.com/go-gost/gost/pkg/bypass"
"github.com/go-gost/gost/pkg/chain"
"github.com/go-gost/gost/pkg/hosts"
"github.com/go-gost/gost/pkg/resolver"
"github.com/go-gost/gost/pkg/service"
)
var (
ErrDup = errors.New("registry: duplicate instance")
ErrDup = errors.New("registry: duplicate object")
)
type NewListener func(opts ...listener.Option) listener.Listener
type NewHandler func(opts ...handler.Option) handler.Handler
type NewDialer func(opts ...dialer.Option) dialer.Dialer
type NewConnector func(opts ...connector.Option) connector.Connector
var (
listeners = make(map[string]NewListener)
handlers = make(map[string]NewHandler)
dialers = make(map[string]NewDialer)
connectors = make(map[string]NewConnector)
listenerReg Registry[NewListener] = &listenerRegistry{}
handlerReg Registry[NewHandler] = &handlerRegistry{}
dialerReg Registry[NewDialer] = &dialerRegistry{}
connectorReg Registry[NewConnector] = &connectorRegistry{}
serviceReg Registry[service.Service] = &serviceRegistry{}
chainReg Registry[chain.Chainer] = &chainRegistry{}
autherReg Registry[auth.Authenticator] = &autherRegistry{}
admissionReg Registry[admission.Admission] = &admissionRegistry{}
bypassReg Registry[bypass.Bypass] = &bypassRegistry{}
resolverReg Registry[resolver.Resolver] = &resolverRegistry{}
hostsReg Registry[hosts.HostMapper] = &hostsRegistry{}
)
func RegisterListener(name string, newf NewListener) {
if listeners[name] != nil {
logger.Default().Fatalf("register duplicate listener: %s", name)
type Registry[T any] interface {
Register(name string, v T) error
Unregister(name string)
IsRegistered(name string) bool
Get(name string) T
}
type registry struct {
m sync.Map
}
func (r *registry) Register(name string, v any) error {
if name == "" || v == nil {
return nil
}
listeners[name] = newf
}
func GetListener(name string) NewListener {
return listeners[name]
}
func RegisterHandler(name string, newf NewHandler) {
if handlers[name] != nil {
logger.Default().Fatalf("register duplicate handler: %s", name)
if _, loaded := r.m.LoadOrStore(name, v); loaded {
return ErrDup
}
handlers[name] = newf
return nil
}
func GetHandler(name string) NewHandler {
return handlers[name]
func (r *registry) Unregister(name string) {
r.m.Delete(name)
}
func RegisterDialer(name string, newf NewDialer) {
if dialers[name] != nil {
logger.Default().Fatalf("register duplicate dialer: %s", name)
func (r *registry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
}
func (r *registry) Get(name string) any {
if name == "" {
return nil
}
dialers[name] = newf
v, _ := r.m.Load(name)
return v
}
func GetDialer(name string) NewDialer {
return dialers[name]
func ListenerRegistry() Registry[NewListener] {
return listenerReg
}
func RegiserConnector(name string, newf NewConnector) {
if connectors[name] != nil {
logger.Default().Fatalf("register duplicate connector: %s", name)
}
connectors[name] = newf
func HandlerRegistry() Registry[NewHandler] {
return handlerReg
}
func GetConnector(name string) NewConnector {
return connectors[name]
func DialerRegistry() Registry[NewDialer] {
return dialerReg
}
func ConnectorRegistry() Registry[NewConnector] {
return connectorReg
}
func ServiceRegistry() Registry[service.Service] {
return serviceReg
}
func ChainRegistry() Registry[chain.Chainer] {
return chainReg
}
func AutherRegistry() Registry[auth.Authenticator] {
return autherReg
}
func AdmissionRegistry() Registry[admission.Admission] {
return admissionReg
}
func BypassRegistry() Registry[bypass.Bypass] {
return bypassReg
}
func ResolverRegistry() Registry[resolver.Resolver] {
return resolverReg
}
func HostsRegistry() Registry[hosts.HostMapper] {
return hostsReg
}

42
pkg/registry/resolver.go
View File

@ -3,52 +3,27 @@ package registry
import (
"context"
"net"
"sync"
"github.com/go-gost/gost/pkg/resolver"
)
var (
resolverReg = &resolverRegistry{}
)
func Resolver() *resolverRegistry {
return resolverReg
}
type resolverRegistry struct {
m sync.Map
registry
}
func (r *resolverRegistry) Register(name string, resolver resolver.Resolver) error {
if name == "" || resolver == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, resolver); loaded {
return ErrDup
}
return nil
}
func (r *resolverRegistry) Unregister(name string) {
r.m.Delete(name)
}
func (r *resolverRegistry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
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 nil
if name != "" {
return &resolverWrapper{name: name, r: r}
}
return &resolverWrapper{name: name}
return nil
}
func (r *resolverRegistry) get(name string) resolver.Resolver {
if v, ok := r.m.Load(name); ok {
if v := r.registry.Get(name); v != nil {
return v.(resolver.Resolver)
}
return nil
@ -56,10 +31,11 @@ func (r *resolverRegistry) get(name string) resolver.Resolver {
type resolverWrapper struct {
name string
r *resolverRegistry
}
func (w *resolverWrapper) Resolve(ctx context.Context, network, host string) ([]net.IP, error) {
r := Resolver().get(w.name)
r := w.r.get(w.name)
if r == nil {
return nil, resolver.ErrInvalid
}

42
pkg/registry/service.go
View File

@ -1,50 +1,20 @@
package registry
import (
"sync"
"github.com/go-gost/gost/pkg/service"
)
var (
svcReg = &serviceRegistry{}
)
func Service() *serviceRegistry {
return svcReg
}
type serviceRegistry struct {
m sync.Map
registry
}
func (r *serviceRegistry) Register(name string, svc service.Service) error {
if name == "" || svc == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, svc); loaded {
return ErrDup
}
return nil
}
func (r *serviceRegistry) Unregister(name string) {
r.m.Delete(name)
}
func (r *serviceRegistry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
func (r *serviceRegistry) Register(name string, v service.Service) error {
return r.registry.Register(name, v)
}
func (r *serviceRegistry) Get(name string) service.Service {
if name == "" {
return nil
if v := r.registry.Get(name); v != nil {
return v.(service.Service)
}
v, ok := r.m.Load(name)
if !ok {
return nil
}
return v.(service.Service)
return nil
}