service: add limiter.scope option

listener/dns/listener.go

@@ -10,7 +10,6 @@ import (
 	"net"
 	"net/http"
 	"strings"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -18,7 +17,7 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -80,11 +79,7 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
 			return
 		}
 
-		ln = limiter_wrapper.WrapListener(
-			l.options.Service,
-			ln,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		)
+		ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 
 		l.server = &dnsServer{
 			server: &dns.Server{
@@ -121,11 +116,7 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
 		}
 		ln = tls.NewListener(ln, l.options.TLSConfig)
 
-		ln = limiter_wrapper.WrapListener(
-			l.options.Service,
-			ln,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		)
+		ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 
 		l.server = &dnsServer{
 			server: &dns.Server{
@@ -163,11 +154,7 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
 		}
 		ln = tls.NewListener(ln, l.options.TLSConfig)
 
-		ln = limiter_wrapper.WrapListener(
-			l.options.Service,
-			ln,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		)
+		ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 
 		l.server = &dohServer{
 			addr:      l.options.Addr,
@@ -205,8 +192,8 @@ func (l *dnsListener) Init(md md.Metadata) (err error) {
 
 		pc = limiter_wrapper.WrapPacketConn(
 			pc,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-			"",
+			l.options.TrafficLimiter,
+			traffic_limiter.ServiceLimitKey,
 			limiter.ScopeOption(limiter.ScopeService),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(network),
@@ -251,7 +238,7 @@ func (l *dnsListener) Accept() (conn net.Conn, err error) {
 		conn = admission.WrapConn(l.options.Admission, conn)
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/dns/metadata.go

@@ -12,13 +12,12 @@ const (
 )
 
 type metadata struct {
-	mode                   string
-	readBufferSize         int
-	readTimeout            time.Duration
-	writeTimeout           time.Duration
-	backlog                int
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	mode           string
+	readBufferSize int
+	readTimeout    time.Duration
+	writeTimeout   time.Duration
+	backlog        int
+	mptcp          bool
 }
 
 func (l *dnsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -41,13 +40,5 @@ func (l *dnsListener) parseMetadata(md mdata.Metadata) (err error) {
 	}
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/dtls/listener.go

@@ -14,7 +14,6 @@ import (
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	xdtls "github.com/go-gost/x/internal/util/dtls"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -84,11 +83,7 @@ func (l *dtlsListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	l.ln = ln
@@ -104,13 +99,14 @@ func (l *dtlsListener) Accept() (conn net.Conn, err error) {
 	conn = xdtls.Conn(c, l.md.bufferSize)
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),
 		limiter.NetworkOption(conn.LocalAddr().Network()),
 		limiter.SrcOption(conn.RemoteAddr().String()),
 	)
+
 	return
 }
 

listener/dtls/metadata.go

@@ -12,10 +12,9 @@ const (
 )
 
 type metadata struct {
-	mtu                    int
-	bufferSize             int
-	flightInterval         time.Duration
-	limiterRefreshInterval time.Duration
+	mtu            int
+	bufferSize     int
+	flightInterval time.Duration
 }
 
 func (l *dtlsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -27,13 +26,5 @@ func (l *dtlsListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.flightInterval = mdutil.GetDuration(md, "dtls.flightInterval", "flightInterval")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return nil
 }

listener/ftcp/listener.go

@@ -2,7 +2,6 @@ package ftcp
 
 import (
 	"net"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -11,7 +10,7 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/udp"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -55,13 +54,14 @@ func (l *ftcpListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+
 	conn = metrics.WrapPacketConn(l.options.Service, conn)
 	conn = stats.WrapPacketConn(conn, l.options.Stats)
 	conn = admission.WrapPacketConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapPacketConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		"",
+		l.options.TrafficLimiter,
+		traffic_limiter.ServiceLimitKey,
 		limiter.ScopeOption(limiter.ScopeService),
 		limiter.ServiceOption(l.options.Service),
 		limiter.NetworkOption(conn.LocalAddr().Network()),
@@ -88,7 +88,7 @@ func (l *ftcpListener) Accept() (conn net.Conn, err error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/ftcp/metadata.go

@@ -15,8 +15,7 @@ const (
 )
 
 type metadata struct {
-	ttl                    time.Duration
-	limiterRefreshInterval time.Duration
+	ttl time.Duration
 
 	readBufferSize int
 	readQueueSize  int
@@ -50,13 +49,5 @@ func (l *ftcpListener) parseMetadata(md mdata.Metadata) (err error) {
 		l.md.backlog = defaultBacklog
 	}
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/grpc/listener.go

@@ -13,7 +13,6 @@ import (
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	pb "github.com/go-gost/x/internal/util/grpc/proto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -67,15 +66,12 @@ func (l *grpcListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	var opts []grpc.ServerOption
@@ -124,13 +120,14 @@ func (l *grpcListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(conn.LocalAddr().Network()),
 			limiter.SrcOption(conn.RemoteAddr().String()),
 		)
+
 	case err, ok = <-l.errChan:
 		if !ok {
 			err = listener.ErrClosed

listener/grpc/metadata.go

@@ -22,7 +22,6 @@ type metadata struct {
 	keepalivePermitWithoutStream bool
 	keepaliveMaxConnectionIdle   time.Duration
 	mptcp                        bool
-	limiterRefreshInterval       time.Duration
 }
 
 func (l *grpcListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -54,13 +53,5 @@ func (l *grpcListener) parseMetadata(md mdata.Metadata) (err error) {
 		l.md.mptcp = mdutil.GetBool(md, "mptcp")
 	}
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/http2/h2/listener.go

@@ -16,7 +16,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -92,11 +91,7 @@ func (l *h2Listener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	if l.h2c {
@@ -130,7 +125,7 @@ func (l *h2Listener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/http2/h2/metadata.go

@@ -1,8 +1,6 @@
 package h2
 
 import (
-	"time"
-
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
@@ -12,10 +10,9 @@ const (
 )
 
 type metadata struct {
-	path                   string
-	backlog                int
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	path    string
+	backlog int
+	mptcp   bool
 }
 
 func (l *h2Listener) parseMetadata(md mdata.Metadata) (err error) {
@@ -32,13 +29,5 @@ func (l *h2Listener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.path = mdutil.GetString(md, path)
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/http2/listener.go

@@ -14,7 +14,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	mdx "github.com/go-gost/x/metadata"
@@ -81,11 +80,7 @@ func (l *http2Listener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	ln = tls.NewListener(
@@ -111,13 +106,14 @@ func (l *http2Listener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(conn.LocalAddr().Network()),
 			limiter.SrcOption(conn.RemoteAddr().String()),
 		)
+
 	case err, ok = <-l.errChan:
 		if !ok {
 			err = listener.ErrClosed

listener/http2/metadata.go

@@ -1,8 +1,6 @@
 package http2
 
 import (
-	"time"
-
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
@@ -12,9 +10,8 @@ const (
 )
 
 type metadata struct {
-	backlog                int
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	backlog int
+	mptcp   bool
 }
 
 func (l *http2Listener) parseMetadata(md mdata.Metadata) (err error) {
@@ -28,13 +25,5 @@ func (l *http2Listener) parseMetadata(md mdata.Metadata) (err error) {
 	}
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/http3/h3/listener.go

@@ -2,7 +2,6 @@ package h3
 
 import (
 	"net"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -10,7 +9,6 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	pht_util "github.com/go-gost/x/internal/util/pht"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -93,7 +91,7 @@ func (l *http3Listener) Accept() (conn net.Conn, err error) {
 	conn = admission.WrapConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/http3/h3/metadata.go

@@ -26,8 +26,6 @@ type metadata struct {
 	maxIdleTimeout   time.Duration
 	handshakeTimeout time.Duration
 	maxStreams       int
-
-	limiterRefreshInterval time.Duration
 }
 
 func (l *http3Listener) parseMetadata(md mdata.Metadata) (err error) {
@@ -69,13 +67,5 @@ func (l *http3Listener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.maxIdleTimeout = mdutil.GetDuration(md, maxIdleTimeout)
 	l.md.maxStreams = mdutil.GetInt(md, maxStreams)
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/http3/wt/listener.go

@@ -4,7 +4,6 @@ import (
 	"net"
 	"net/http"
 	"net/http/httputil"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -12,8 +11,8 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	wt_util "github.com/go-gost/x/internal/util/wt"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -79,8 +78,8 @@ func (l *wtListener) Init(md md.Metadata) (err error) {
 	pc = admission.WrapPacketConn(l.options.Admission, pc)
 	pc = limiter_wrapper.WrapPacketConn(
 		pc,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		"",
+		l.options.TrafficLimiter,
+		traffic_limiter.ServiceLimitKey,
 		limiter.ScopeOption(limiter.ScopeService),
 		limiter.ServiceOption(l.options.Service),
 		limiter.NetworkOption(network),
@@ -130,7 +129,7 @@ func (l *wtListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/http3/wt/metadata.go

@@ -21,8 +21,6 @@ type metadata struct {
 	maxIdleTimeout   time.Duration
 	handshakeTimeout time.Duration
 	maxStreams       int
-
-	limiterRefreshInterval time.Duration
 }
 
 func (l *wtListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -56,13 +54,5 @@ func (l *wtListener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.maxIdleTimeout = mdutil.GetDuration(md, maxIdleTimeout)
 	l.md.maxStreams = mdutil.GetInt(md, maxStreams)
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/icmp/listener.go

@@ -3,7 +3,6 @@ package quic
 import (
 	"context"
 	"net"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -11,7 +10,7 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	icmp_pkg "github.com/go-gost/x/internal/util/icmp"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -83,8 +82,8 @@ func (l *icmpListener) Init(md md.Metadata) (err error) {
 	conn = admission.WrapPacketConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapPacketConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		"",
+		l.options.TrafficLimiter,
+		traffic_limiter.ServiceLimitKey,
 		limiter.ScopeOption(limiter.ScopeService),
 		limiter.ServiceOption(l.options.Service),
 		limiter.NetworkOption(conn.LocalAddr().Network()),
@@ -123,7 +122,7 @@ func (l *icmpListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/icmp/metadata.go

@@ -17,7 +17,6 @@ type metadata struct {
 	maxIdleTimeout   time.Duration
 
 	backlog                int
-	limiterRefreshInterval time.Duration
 }
 
 func (l *icmpListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -35,13 +34,5 @@ func (l *icmpListener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.handshakeTimeout = mdutil.GetDuration(md, "handshakeTimeout")
 	l.md.maxIdleTimeout = mdutil.GetDuration(md, "maxIdleTimeout")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/kcp/listener.go

@@ -11,7 +11,7 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	kcp_util "github.com/go-gost/x/internal/util/kcp"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -82,8 +82,8 @@ func (l *kcpListener) Init(md md.Metadata) (err error) {
 	conn = admission.WrapUDPConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapUDPConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		"",
+		l.options.TrafficLimiter,
+		traffic_limiter.ServiceLimitKey,
 		limiter.ScopeOption(limiter.ScopeService),
 		limiter.ServiceOption(l.options.Service),
 		limiter.NetworkOption(conn.LocalAddr().Network()),
@@ -124,7 +124,7 @@ func (l *kcpListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/kcp/metadata.go

@@ -2,7 +2,6 @@ package kcp
 
 import (
 	"encoding/json"
-	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	kcp_util "github.com/go-gost/x/internal/util/kcp"
@@ -14,9 +13,8 @@ const (
 )
 
 type metadata struct {
-	config                 *kcp_util.Config
-	backlog                int
-	limiterRefreshInterval time.Duration
+	config  *kcp_util.Config
+	backlog int
 }
 
 func (l *kcpListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -66,13 +64,5 @@ func (l *kcpListener) parseMetadata(md mdata.Metadata) (err error) {
 		l.md.backlog = defaultBacklog
 	}
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/mtcp/listener.go

@@ -12,7 +12,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	"github.com/go-gost/x/internal/util/mux"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
@@ -71,11 +70,7 @@ func (l *mtcpListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 	l.ln = ln
 
@@ -101,7 +96,7 @@ func (l *mtcpListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/mtcp/metadata.go

@@ -1,8 +1,6 @@
 package mtcp
 
 import (
-	"time"
-
 	md "github.com/go-gost/core/metadata"
 	"github.com/go-gost/x/internal/util/mux"
 	mdutil "github.com/go-gost/x/metadata/util"
@@ -13,10 +11,9 @@ const (
 )
 
 type metadata struct {
-	mptcp                  bool
-	muxCfg                 *mux.Config
-	backlog                int
-	limiterRefreshInterval time.Duration
+	mptcp   bool
+	muxCfg  *mux.Config
+	backlog int
 }
 
 func (l *mtcpListener) parseMetadata(md md.Metadata) (err error) {
@@ -40,13 +37,5 @@ func (l *mtcpListener) parseMetadata(md md.Metadata) (err error) {
 		l.md.backlog = defaultBacklog
 	}
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/mtls/listener.go

@@ -13,7 +13,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	"github.com/go-gost/x/internal/util/mux"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
@@ -70,11 +69,7 @@ func (l *mtlsListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 	l.Listener = tls.NewListener(ln, l.options.TLSConfig)
 
@@ -92,13 +87,14 @@ func (l *mtlsListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(conn.LocalAddr().Network()),
 			limiter.SrcOption(conn.RemoteAddr().String()),
 		)
+
 	case err, ok = <-l.errChan:
 		if !ok {
 			err = listener.ErrClosed

listener/mtls/metadata.go

@@ -1,8 +1,6 @@
 package mtls
 
 import (
-	"time"
-
 	mdata "github.com/go-gost/core/metadata"
 	"github.com/go-gost/x/internal/util/mux"
 	mdutil "github.com/go-gost/x/metadata/util"
@@ -13,10 +11,9 @@ const (
 )
 
 type metadata struct {
-	muxCfg                 *mux.Config
-	backlog                int
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	muxCfg  *mux.Config
+	backlog int
+	mptcp   bool
 }
 
 func (l *mtlsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -36,13 +33,5 @@ func (l *mtlsListener) parseMetadata(md mdata.Metadata) (err error) {
 	}
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/mws/listener.go

@@ -15,7 +15,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	"github.com/go-gost/x/internal/util/mux"
 	ws_util "github.com/go-gost/x/internal/util/ws"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
@@ -112,11 +111,7 @@ func (l *mwsListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	if l.tlsEnabled {
@@ -142,13 +137,14 @@ func (l *mwsListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(conn.LocalAddr().Network()),
 			limiter.SrcOption(conn.RemoteAddr().String()),
 		)
+
 	case err, ok = <-l.errChan:
 		if !ok {
 			err = listener.ErrClosed

listener/mws/metadata.go

@@ -27,8 +27,7 @@ type metadata struct {
 
 	muxCfg *mux.Config
 
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	mptcp bool
 }
 
 func (l *mwsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -68,13 +67,5 @@ func (l *mwsListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/obfs/http/listener.go

@@ -12,7 +12,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -65,11 +64,7 @@ func (l *obfsListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	l.Listener = ln
@@ -84,7 +79,7 @@ func (l *obfsListener) Accept() (net.Conn, error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/obfs/http/metadata.go

@@ -2,16 +2,14 @@ package http
 
 import (
 	"net/http"
-	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
 
 type metadata struct {
-	header                 http.Header
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	header http.Header
+	mptcp  bool
 }
 
 func (l *obfsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -29,13 +27,5 @@ func (l *obfsListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/obfs/tls/listener.go

@@ -12,7 +12,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -65,11 +64,7 @@ func (l *obfsListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	l.Listener = ln
@@ -84,7 +79,7 @@ func (l *obfsListener) Accept() (net.Conn, error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/obfs/tls/metadata.go

@@ -1,27 +1,16 @@
 package tls
 
 import (
-	"time"
-
 	md "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
 
 type metadata struct {
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	mptcp bool
 }
 
 func (l *obfsListener) parseMetadata(md md.Metadata) (err error) {
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/pht/listener.go

@@ -4,7 +4,6 @@ package pht
 
 import (
 	"net"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -12,7 +11,6 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	pht_util "github.com/go-gost/x/internal/util/pht"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -100,7 +98,7 @@ func (l *phtListener) Accept() (conn net.Conn, err error) {
 	conn = admission.WrapConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/pht/metadata.go

@@ -2,7 +2,6 @@ package pht
 
 import (
 	"strings"
-	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
@@ -16,12 +15,11 @@ const (
 )
 
 type metadata struct {
-	authorizePath          string
-	pushPath               string
-	pullPath               string
-	backlog                int
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	authorizePath string
+	pushPath      string
+	pullPath      string
+	backlog       int
+	mptcp         bool
 }
 
 func (l *phtListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -53,13 +51,5 @@ func (l *phtListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/quic/listener.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"net"
 	"strings"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -12,8 +11,8 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	quic_util "github.com/go-gost/x/internal/util/quic"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -78,8 +77,8 @@ func (l *quicListener) Init(md md.Metadata) (err error) {
 	conn = admission.WrapPacketConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapPacketConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		"",
+		l.options.TrafficLimiter,
+		traffic_limiter.ServiceLimitKey,
 		limiter.ScopeOption(limiter.ScopeService),
 		limiter.ServiceOption(l.options.Service),
 		limiter.NetworkOption(conn.LocalAddr().Network()),
@@ -119,7 +118,7 @@ func (l *quicListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/quic/metadata.go

@@ -18,9 +18,8 @@ type metadata struct {
 	maxIdleTimeout   time.Duration
 	maxStreams       int
 
-	cipherKey              []byte
-	backlog                int
-	limiterRefreshInterval time.Duration
+	cipherKey []byte
+	backlog   int
 }
 
 func (l *quicListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -54,13 +53,5 @@ func (l *quicListener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.maxIdleTimeout = mdutil.GetDuration(md, maxIdleTimeout)
 	l.md.maxStreams = mdutil.GetInt(md, maxStreams)
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/redirect/tcp/listener.go

@@ -12,7 +12,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -70,11 +69,7 @@ func (l *redirectListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 	l.ln = ln
 	return
@@ -88,7 +83,7 @@ func (l *redirectListener) Accept() (conn net.Conn, err error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/redirect/tcp/metadata.go

@@ -1,29 +1,18 @@
 package tcp
 
 import (
-	"time"
-
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
 
 type metadata struct {
-	tproxy                 bool
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	tproxy bool
+	mptcp  bool
 }
 
 func (l *redirectListener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.tproxy = mdutil.GetBool(md, "tproxy")
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/redirect/udp/listener.go

@@ -2,14 +2,12 @@ package udp
 
 import (
 	"net"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
 	"github.com/go-gost/core/logger"
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -62,7 +60,7 @@ func (l *redirectListener) Accept() (conn net.Conn, err error) {
 	conn = admission.WrapConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/redirect/udp/metadata.go

@@ -13,9 +13,8 @@ const (
 )
 
 type metadata struct {
-	ttl                    time.Duration
-	readBufferSize         int
-	limiterRefreshInterval time.Duration
+	ttl            time.Duration
+	readBufferSize int
 }
 
 func (l *redirectListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -34,13 +33,5 @@ func (l *redirectListener) parseMetadata(md mdata.Metadata) (err error) {
 		l.md.readBufferSize = defaultReadBufferSize
 	}
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/rtcp/listener.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"net"
 	"sync"
-	"time"
 
 	"github.com/go-gost/core/chain"
 	"github.com/go-gost/core/limiter"
@@ -13,7 +12,6 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -85,11 +83,7 @@ func (l *rtcpListener) Accept() (conn net.Conn, err error) {
 		ln = metrics.WrapListener(l.options.Service, ln)
 		ln = stats.WrapListener(ln, l.options.Stats)
 		ln = admission.WrapListener(l.options.Admission, ln)
-		ln = limiter_wrapper.WrapListener(
-			l.options.Service,
-			ln,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		)
+		ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 		ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 		l.setListener(ln)
 	}
@@ -110,7 +104,7 @@ func (l *rtcpListener) Accept() (conn net.Conn, err error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/rtcp/metadata.go

@@ -1,23 +1,11 @@
 package rtcp
 
 import (
-	"time"
-
 	mdata "github.com/go-gost/core/metadata"
-	mdutil "github.com/go-gost/x/metadata/util"
 )
 
-type metadata struct {
-	limiterRefreshInterval time.Duration
-}
+type metadata struct{}
 
 func (l *rtcpListener) parseMetadata(md mdata.Metadata) (err error) {
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
 	return
 }

listener/rudp/listener.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"net"
 	"sync"
-	"time"
 
 	"github.com/go-gost/core/chain"
 	"github.com/go-gost/core/limiter"
@@ -13,7 +12,6 @@ import (
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -86,11 +84,7 @@ func (l *rudpListener) Accept() (conn net.Conn, err error) {
 			return nil, listener.NewAcceptError(err)
 		}
 
-		ln = limiter_wrapper.WrapListener(
-			l.options.Service,
-			ln,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		)
+		ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 		ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 		l.setListener(ln)
@@ -116,8 +110,8 @@ func (l *rudpListener) Accept() (conn net.Conn, err error) {
 		uc = admission.WrapUDPConn(l.options.Admission, uc)
 		conn = limiter_wrapper.WrapUDPConn(
 			uc,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-			"",
+			l.options.TrafficLimiter,
+			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(conn.LocalAddr().Network()),

listener/rudp/metadata.go

@@ -15,11 +15,10 @@ const (
 )
 
 type metadata struct {
-	ttl                    time.Duration
-	readBufferSize         int
-	readQueueSize          int
-	backlog                int
-	limiterRefreshInterval time.Duration
+	ttl            time.Duration
+	readBufferSize int
+	readQueueSize  int
+	backlog        int
 }
 
 func (l *rudpListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -49,13 +48,5 @@ func (l *rudpListener) parseMetadata(md mdata.Metadata) (err error) {
 		l.md.backlog = defaultBacklog
 	}
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/serial/listener.go

@@ -9,8 +9,8 @@ import (
 	"github.com/go-gost/core/listener"
 	"github.com/go-gost/core/logger"
 	md "github.com/go-gost/core/metadata"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	serial "github.com/go-gost/x/internal/util/serial"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -101,8 +101,8 @@ func (l *serialListener) listenLoop() {
 			conn = stats.WrapConn(conn, l.options.Stats)
 			conn = limiter_wrapper.WrapConn(
 				conn,
-				limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-				"",
+				l.options.TrafficLimiter,
+				traffic_limiter.ServiceLimitKey,
 				limiter.ScopeOption(limiter.ScopeService),
 				limiter.ServiceOption(l.options.Service),
 				limiter.NetworkOption(conn.LocalAddr().Network()),

listener/serial/metadata.go

@@ -8,20 +8,11 @@ import (
 )
 
 type metadata struct {
-	timeout                time.Duration
-	limiterRefreshInterval time.Duration
+	timeout time.Duration
 }
 
 func (l *serialListener) parseMetadata(md md.Metadata) (err error) {
 	l.md.timeout = mdutil.GetDuration(md, "timeout", "serial.timeout", "listener.serial.timeout")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/ssh/listener.go

@@ -13,7 +13,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
@@ -72,11 +71,7 @@ func (l *sshListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 	l.Listener = ln
 
@@ -104,7 +99,7 @@ func (l *sshListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),

listener/ssh/metadata.go

@@ -2,7 +2,6 @@ package ssh
 
 import (
 	"os"
-	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
@@ -16,11 +15,10 @@ const (
 )
 
 type metadata struct {
-	signer                 ssh.Signer
-	authorizedKeys         map[string]bool
-	backlog                int
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	signer         ssh.Signer
+	authorizedKeys map[string]bool
+	backlog        int
+	mptcp          bool
 }
 
 func (l *sshListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -74,13 +72,5 @@ func (l *sshListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/sshd/listener.go

@@ -14,7 +14,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
 	sshd_util "github.com/go-gost/x/internal/util/sshd"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
@@ -80,11 +79,7 @@ func (l *sshdListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 	l.Listener = ln
 
@@ -112,13 +107,14 @@ func (l *sshdListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(conn.LocalAddr().Network()),
 			limiter.SrcOption(conn.RemoteAddr().String()),
 		)
+
 	case err, ok = <-l.errChan:
 		if !ok {
 			err = listener.ErrClosed

listener/sshd/metadata.go

@@ -3,7 +3,6 @@ package ssh
 import (
 	"fmt"
 	"os"
-	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
@@ -18,11 +17,10 @@ const (
 )
 
 type metadata struct {
-	signer                 ssh.Signer
-	authorizedKeys         map[string]bool
-	backlog                int
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	signer         ssh.Signer
+	authorizedKeys map[string]bool
+	backlog        int
+	mptcp          bool
 }
 
 func (l *sshdListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -84,13 +82,5 @@ func (l *sshdListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/tap/listener.go

@@ -10,7 +10,7 @@ import (
 	"github.com/go-gost/core/logger"
 	mdata "github.com/go-gost/core/metadata"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	mdx "github.com/go-gost/x/metadata"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -96,8 +96,8 @@ func (l *tapListener) listenLoop() {
 			c = stats.WrapConn(c, l.options.Stats)
 			c = limiter_wrapper.WrapConn(
 				c,
-				limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-				c.RemoteAddr().String(),
+				l.options.TrafficLimiter,
+				traffic_limiter.ServiceLimitKey,
 				limiter.ScopeOption(limiter.ScopeService),
 				limiter.ServiceOption(l.options.Service),
 				limiter.NetworkOption(c.LocalAddr().Network()),

listener/tap/metadata.go

@@ -3,7 +3,6 @@ package tap
 import (
 	"net"
 	"strings"
-	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	tap_util "github.com/go-gost/x/internal/util/tap"
@@ -15,8 +14,7 @@ const (
 )
 
 type metadata struct {
-	config                 *tap_util.Config
-	limiterRefreshInterval time.Duration
+	config *tap_util.Config
 }
 
 func (l *tapListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -73,13 +71,5 @@ func (l *tapListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.config = config
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/tcp/listener.go

@@ -12,7 +12,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -68,11 +67,7 @@ func (l *tcpListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 	l.ln = ln
 
@@ -87,7 +82,7 @@ func (l *tcpListener) Accept() (conn net.Conn, err error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/tcp/metadata.go

@@ -1,27 +1,16 @@
 package tcp
 
 import (
-	"time"
-
 	md "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
 
 type metadata struct {
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	mptcp bool
 }
 
 func (l *tcpListener) parseMetadata(md md.Metadata) (err error) {
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/tls/listener.go

@@ -13,7 +13,6 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -66,11 +65,7 @@ func (l *tlsListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	l.ln = tls.NewListener(ln, l.options.TLSConfig)
@@ -86,7 +81,7 @@ func (l *tlsListener) Accept() (conn net.Conn, err error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/tls/metadata.go

@@ -1,27 +1,16 @@
 package tls
 
 import (
-	"time"
-
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
 
 type metadata struct {
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	mptcp bool
 }
 
 func (l *tlsListener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/tun/listener.go

@@ -11,7 +11,7 @@ import (
 	mdata "github.com/go-gost/core/metadata"
 	"github.com/go-gost/core/router"
 	xnet "github.com/go-gost/x/internal/net"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	mdx "github.com/go-gost/x/metadata"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -97,8 +97,8 @@ func (l *tunListener) listenLoop() {
 			c = stats.WrapConn(c, l.options.Stats)
 			c = limiter_wrapper.WrapConn(
 				c,
-				limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-				c.RemoteAddr().String(),
+				l.options.TrafficLimiter,
+				traffic_limiter.ServiceLimitKey,
 				limiter.ScopeOption(limiter.ScopeService),
 				limiter.ServiceOption(l.options.Service),
 				limiter.NetworkOption(c.LocalAddr().Network()),

listener/tun/metadata.go

@@ -3,7 +3,6 @@ package tun
 import (
 	"net"
 	"strings"
-	"time"
 
 	"github.com/go-gost/core/logger"
 	mdata "github.com/go-gost/core/metadata"
@@ -20,9 +19,8 @@ const (
 )
 
 type metadata struct {
-	config                 *tun_util.Config
-	readBufferSize         int
-	limiterRefreshInterval time.Duration
+	config         *tun_util.Config
+	readBufferSize int
 }
 
 func (l *tunListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -113,13 +111,5 @@ func (l *tunListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.config = config
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/udp/listener.go

@@ -2,7 +2,6 @@ package udp
 
 import (
 	"net"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
@@ -11,7 +10,7 @@ import (
 	admission "github.com/go-gost/x/admission/wrapper"
 	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/udp"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
+	traffic_limiter "github.com/go-gost/x/limiter/traffic"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
 	stats "github.com/go-gost/x/observer/stats/wrapper"
@@ -64,8 +63,8 @@ func (l *udpListener) Init(md md.Metadata) (err error) {
 	conn = admission.WrapPacketConn(l.options.Admission, conn)
 	conn = limiter_wrapper.WrapPacketConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-		"",
+		l.options.TrafficLimiter,
+		traffic_limiter.ServiceLimitKey,
 		limiter.ScopeOption(limiter.ScopeService),
 		limiter.ServiceOption(l.options.Service),
 		limiter.NetworkOption(conn.LocalAddr().Network()),

listener/udp/metadata.go

@@ -20,7 +20,6 @@ type metadata struct {
 	backlog                int
 	keepalive              bool
 	ttl                    time.Duration
-	limiterRefreshInterval time.Duration
 }
 
 func (l *udpListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -52,13 +51,5 @@ func (l *udpListener) parseMetadata(md mdata.Metadata) (err error) {
 	}
 	l.md.keepalive = mdutil.GetBool(md, keepalive)
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/unix/listener.go

@@ -2,14 +2,12 @@ package unix
 
 import (
 	"net"
-	"time"
 
 	"github.com/go-gost/core/limiter"
 	"github.com/go-gost/core/listener"
 	"github.com/go-gost/core/logger"
 	md "github.com/go-gost/core/metadata"
 	admission "github.com/go-gost/x/admission/wrapper"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
 	metrics "github.com/go-gost/x/metrics/wrapper"
@@ -52,11 +50,7 @@ func (l *unixListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 	l.ln = ln
 
@@ -71,7 +65,7 @@ func (l *unixListener) Accept() (conn net.Conn, err error) {
 
 	conn = limiter_wrapper.WrapConn(
 		conn,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+		l.options.TrafficLimiter,
 		conn.RemoteAddr().String(),
 		limiter.ScopeOption(limiter.ScopeConn),
 		limiter.ServiceOption(l.options.Service),

listener/unix/metadata.go

@@ -1,24 +1,11 @@
 package unix
 
 import (
-	"time"
-
 	md "github.com/go-gost/core/metadata"
-	mdutil "github.com/go-gost/x/metadata/util"
 )
 
-type metadata struct {
-	limiterRefreshInterval time.Duration
-}
+type metadata struct{}
 
 func (l *unixListener) parseMetadata(md md.Metadata) (err error) {
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }

listener/ws/listener.go

@@ -16,7 +16,6 @@ import (
 	xnet "github.com/go-gost/x/internal/net"
 	xhttp "github.com/go-gost/x/internal/net/http"
 	"github.com/go-gost/x/internal/net/proxyproto"
-	limiter_util "github.com/go-gost/x/internal/util/limiter"
 	ws_util "github.com/go-gost/x/internal/util/ws"
 	climiter "github.com/go-gost/x/limiter/conn/wrapper"
 	limiter_wrapper "github.com/go-gost/x/limiter/traffic/wrapper"
@@ -108,11 +107,7 @@ func (l *wsListener) Init(md md.Metadata) (err error) {
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)
 	ln = admission.WrapListener(l.options.Admission, ln)
-	ln = limiter_wrapper.WrapListener(
-		l.options.Service,
-		ln,
-		limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
-	)
+	ln = limiter_wrapper.WrapListener(l.options.Service, ln, l.options.TrafficLimiter)
 	ln = climiter.WrapListener(l.options.ConnLimiter, ln)
 
 	if l.tlsEnabled {
@@ -138,13 +133,14 @@ func (l *wsListener) Accept() (conn net.Conn, err error) {
 	case conn = <-l.cqueue:
 		conn = limiter_wrapper.WrapConn(
 			conn,
-			limiter_util.NewCachedTrafficLimiter(l.options.TrafficLimiter, l.md.limiterRefreshInterval, 60*time.Second),
+			l.options.TrafficLimiter,
 			conn.RemoteAddr().String(),
 			limiter.ScopeOption(limiter.ScopeConn),
 			limiter.ServiceOption(l.options.Service),
 			limiter.NetworkOption(conn.LocalAddr().Network()),
 			limiter.SrcOption(conn.RemoteAddr().String()),
 		)
+
 	case err, ok = <-l.errChan:
 		if !ok {
 			err = listener.ErrClosed

listener/ws/metadata.go

@@ -24,8 +24,7 @@ type metadata struct {
 	enableCompression bool
 	header            http.Header
 
-	mptcp                  bool
-	limiterRefreshInterval time.Duration
+	mptcp bool
 }
 
 func (l *wsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -55,13 +54,5 @@ func (l *wsListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
-	l.md.limiterRefreshInterval = mdutil.GetDuration(md, "limiter.refreshInterval")
-	if l.md.limiterRefreshInterval == 0 {
-		l.md.limiterRefreshInterval = 30 * time.Second
-	}
-	if l.md.limiterRefreshInterval < time.Second {
-		l.md.limiterRefreshInterval = time.Second
-	}
-
 	return
 }