Remove soft and hard limits

Author: mostafa

api/api.go

@@ -165,8 +165,6 @@ func (a *API) GetServers(context.Context, *emptypb.Empty) (*structpb.Struct, err
 			"network":      server.Network,
 			"address":      server.Address,
 			"status":       uint(server.Status),
-			"softLimit":    server.SoftLimit,
-			"hardLimit":    server.HardLimit,
 			"tickInterval": server.TickInterval.Nanoseconds(),
 		}
 	}

cmd/run.go

@@ -556,13 +556,10 @@ var runCmd = &cobra.Command{
 		// Create and initialize servers.
 		for name, cfg := range conf.Global.Servers {
 			logger := loggers[name]
-			softLimit, hardLimit := cfg.GetRLimits(logger)
 			servers[name] = network.NewServer(
 				runCtx,
 				cfg.Network,
 				cfg.Address,
-				softLimit,
-				hardLimit,
 				cfg.GetTickInterval(),
 				[]gnet.Option{
 					// Scheduling options
@@ -599,8 +596,6 @@ var runCmd = &cobra.Command{
 				attribute.String("name", name),
 				attribute.String("network", cfg.Network),
 				attribute.String("address", cfg.Address),
-				attribute.Int64("softLimit", int64(cfg.SoftLimit)),
-				attribute.Int64("hardLimit", int64(cfg.HardLimit)),
 				attribute.String("tickInterval", cfg.TickInterval.String()),
 				attribute.Bool("multiCore", cfg.MultiCore),
 				attribute.Bool("lockOSThread", cfg.LockOSThread),

config/config.go

@@ -130,8 +130,6 @@ func (c *Config) LoadDefaults(ctx context.Context) {
 	defaultServer := Server{
 		Network:          DefaultListenNetwork,
 		Address:          DefaultListenAddress,
-		SoftLimit:        0,
-		HardLimit:        0,
 		EnableTicker:     false,
 		TickInterval:     DefaultTickInterval,
 		MultiCore:        true,

config/getters_unix.go

@@ -5,9 +5,6 @@ package config
 
 import (
 	"log/syslog"
-	"syscall"
-
-	"github.com/rs/zerolog"
 )
 
 var rSyslogPriorities = map[string]syslog.Priority{
@@ -28,25 +25,3 @@ func (l Logger) GetSyslogPriority() syslog.Priority {
 	}
 	return syslog.LOG_DAEMON | syslog.LOG_INFO
 }
-
-// GetSystemLimits returns the current system limits or the configured limits.
-func (s Server) GetRLimits(logger zerolog.Logger) (uint64, uint64) {
-	var limits syscall.Rlimit
-	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limits); err != nil {
-		logger.Debug().Msg("failed to get system limits")
-	}
-
-	if s.SoftLimit <= 0 && limits != (syscall.Rlimit{}) {
-		s.SoftLimit = limits.Cur
-		logger.Debug().Uint64("soft_limit", s.SoftLimit).Msg(
-			"Soft limit is not set, using system limit")
-	}
-
-	if s.HardLimit <= 0 && limits != (syscall.Rlimit{}) {
-		s.HardLimit = limits.Max
-		logger.Debug().Uint64("hard_limit", s.HardLimit).Msg(
-			"Hard limit is not set, using system limit")
-	}
-
-	return s.HardLimit, s.SoftLimit
-}

config/types.go

@@ -94,8 +94,6 @@ type Server struct {
 	WriteBufferCap   int           `json:"writeBufferCap"`
 	SocketRecvBuffer int           `json:"socketRecvBuffer"`
 	SocketSendBuffer int           `json:"socketSendBuffer"`
-	SoftLimit        uint64        `json:"softLimit"`
-	HardLimit        uint64        `json:"hardLimit"`
 	TCPKeepAlive     time.Duration `json:"tcpKeepAlive" jsonschema:"oneof_type=string;integer"`
 	TickInterval     time.Duration `json:"tickInterval" jsonschema:"oneof_type=string;integer"`
 	Network          string        `json:"network" jsonschema:"enum=tcp,enum=udp,enum=unix"`

gatewayd.yaml

@@ -50,8 +50,6 @@ servers:
   default:
     network: tcp
     address: 0.0.0.0:15432
-    softLimit: 0 # 0 means honor system limit
-    hardLimit: 0 # 0 means honor system limit
     enableTicker: False
     tickInterval: 5s # duration
     multiCore: True

network/server.go

@@ -31,8 +31,6 @@ type Server struct {
 	Network      string // tcp/udp/unix
 	Address      string
 	Options      []gnet.Option
-	SoftLimit    uint64
-	HardLimit    uint64
 	Status       config.Status
 	TickInterval time.Duration
 }
@@ -106,22 +104,6 @@ func (s *Server) OnOpen(gconn gnet.Conn) ([]byte, gnet.Action) {
 	}
 	span.AddEvent("Ran the OnOpening hooks")
 
-	// Check if the server is at the soft or hard limit.
-	// TODO: Get rid the hard/soft limit.
-	if s.SoftLimit > 0 && uint64(s.engine.CountConnections()) >= s.SoftLimit {
-		s.logger.Warn().Msg("Soft limit reached")
-	}
-
-	if s.HardLimit > 0 && uint64(s.engine.CountConnections()) >= s.HardLimit {
-		s.logger.Error().Msg("Hard limit reached")
-		_, err := gconn.Write([]byte("Hard limit reached\n"))
-		if err != nil {
-			s.logger.Error().Err(err).Msg("Failed to write to connection")
-			span.RecordError(err)
-		}
-		return nil, gnet.Close
-	}
-
 	// Use the proxy to connect to the backend. Close the connection if the pool is exhausted.
 	// This effectively get a connection from the pool and puts both the incoming and the server
 	// connections in the pool of the busy connections.
@@ -417,7 +399,6 @@ func (s *Server) IsRunning() bool {
 func NewServer(
 	ctx context.Context,
 	network, address string,
-	softLimit, hardLimit uint64,
 	tickInterval time.Duration,
 	options []gnet.Option,
 	proxy IProxy,
@@ -436,8 +417,6 @@ func NewServer(
 		Options:        options,
 		TickInterval:   tickInterval,
 		Status:         config.Stopped,
-		HardLimit:      hardLimit,
-		SoftLimit:      softLimit,
 		proxy:          proxy,
 		logger:         logger,
 		pluginRegistry: pluginRegistry,

network/server_test.go

@@ -172,8 +172,6 @@ func TestRunServer(t *testing.T) {
 		context.Background(),
 		"tcp",
 		"127.0.0.1:15432",
-		0,
-		0,
 		config.DefaultTickInterval,
 		[]gnet.Option{
 			gnet.WithMulticore(false),